Beginnings of Visual Compilers

Beginnings of Visual Compilers

It occurred to me the other day that I may have been the inventor of the first Visual Compiler.

Sometime about 1976 while contracting at Lear Siegler I has occasion to work on the MCDU (Multifunction Control/Display Unit) software for a military aircraft. 

Up until the end of 1973 I had been software manager at Cascade Data - a small business computer manufacturer in Grand Rapids Michigan.  While with Cascade Data I developed along with a second person a RPG compiler for which I used techniques of Cheatham that I had picked up in a two week compiler construction summer course at Cornell.  I can't provide a full reference at the present time since the course materials are currently in another location.

While developing the software for the MCDU it occurred to me that I could use similar techniques to create a compiler to create tables to be traversed in response to key pushes that were made by the pilot in order to make selections via the MCDU display. 

Therefore, I create a Backus-Naur Form (BNF) syntax for MCDU entry to change the display due to particular Line Select Key and Mode Key pushes or to indicate that data entered in the scratchpad line of the MCDU should be selected as the new value of a particular field. 

This is quite similar to the current use of mouse clicks on buttons or other widgets of a Windows form and entry into a dialog box.

The entry "language" to be compiled was via punched cards.  What was to happen when a key was pushed was supplied by an action name. The punched cards were then compiled by the compiler to produce tables to be interpreted by a portion of the aircraft's program.  The code for the actions also had to be contained in the aircraft's embedded program with its compiler associating the table action name with the executable action.

Then when a key was pushed on the MCDU, the portion of the table for the currently displayed page was looked up to determine the action associated with the key.  Then the action was executed.  The action might cause a new page to be displayed or, for instance, convert scratchpad data to a numeric value of a particular format, evaluate the converted data for within range and the like, and, if valid, cause a particular aircraft variable to be modified.  That is, one action for each particular key push event where each action performed a specified task.

Later, in the summer of 1993, I again contracted at Smith Industries which had purchased the Grand Rapids LSI location and business.  In this case it was to fix problem reports related to the Control/Display and Interpret Command subsystems for the new version of the Dual Flight Management Computer System (FMCS) that had been converted to Ada for the Boeing 737.

While doing so it occurred to me that something was vaguely familiar.  After awhile it occurred to me that the Interpret Command tables were what had become of my military aircraft compiled tables.  Except that there was no longer the compiler and they were being modified by hand.  And since this was more difficult, that the programmers had been selecting an action that approximated what needed to be done and then modified it to add code that would determine why the action routine had been entered in order to perform the action that was actually was needed. 

Hence the action code had become more complicated due to the necessary logic to determine the reason that the action had been entered thus causing extended code validation as well as problems that had to be solved in order to release the new FMCS version.

Anyway, as with the current visual compilers such as Microsoft Visual Basic, C#, C++, and such there was an action routine for which the code was to be supplied associated with each widget.  With the current compilers, the programmer can place widgets into a display form and then click on them to allow for naming the action and supplying the code.  Then, when the compiled or interpreted program is run, clicking on the displayed widget causes the supplied code to be executed.

With the MCDUs, the MCDU has its standard configuration and my compiler created the internal tables (which the Visual compilers must do) to cause the associated action to be executed.

Therefore, unless someone comes along that did it prior to 1976, it seems to me that I can take credit for being the first to develop the concept.