Experlisp, Common Lisp

By Andy Cohen

Welcome back to Mactutor’s Lisp column! By the time this issue is printed Experlisp from Expertelligence should be released. For the many of you out there who have yet to see this new version of Lisp, the Lisp Listener Window shall present it’s first description of Experlisp along with more descriptions of Common Lisp procedures.

Experlisp

Experlisp consists of a “Listener Window”, an editor and a compiler. The Listener Window can act as an interpreter, however it only operates on one line of code. One can use it to try out a simple list and see what the list will do. For multiple line lists or programs one must write the code using the editor. The editor has it’s own window or windows, which are called Edit Buffers when untitled. It can have more than one Edit Buffer open at the same time just as Macdraw and MSWord. The editor consists of all the standard editing operations that appear in most Macintosh text editing programs. Cutting and pasting between files is extremely easy and fast because multiple lists can be displayed simultaneously. After one types in their lists the “Compile” menu provides the choice of compiling and executing a selected group of code or the entire program. When either is selected the compiler kicks in and compiles the Lisp code to 68000 machine code. It happens rather quickly and when completed, the program is initiated. All interaction with the program then takes place in the Listener Window, unless programmed otherwise. A screen dump of the Experlisp display is shown in Figure 5. Please note that this was taken using the prereleased version. The released version, I’m told does not include the Help or Output menus on the menu bar. Also the “Run” menu was changed to “Compile”.

Figure 2. Two Dimensional Bunny Graphics

Experlisp is a combination of three worlds. First, as I have already mentioned last month, Experlisp is based on the Common Lisp standard described by Winston and Horn’s “Lisp” 2nd edition. It also contains elements from Zetalisp, the version of Lisp used on Symbolics workstations. This is no surprise since Experlisp was developed on a Symbolics machine. Finally (I saved the best part), Experlisp can access the Macintosh toolbox. In fact one must use the same syntax as shown in Inside Macintosh, the Mac developers “Bible”. Experlisp has the capability to open and close windows, define and create menus on the menu bar and generate all the Macintosh graphics primitives. Experlisp also contains all the graphics features found in Experlogo (also developed by Expertelligence). One can generate turtle graphics as in any logo, however Experlogo and Experlisp use the term Bunny graphics. This is characterized by instructions which tell a “Turtle” (from the original Logo, which moved a mechanical device which looked like a turtle) or “Bunny” to move in specific directions. Bunny graphics can be two dimensional, three dimensional or spherical. Spherical is not your typical form of graphics. In spherical graphics the lines seem to be drawn upon a three dimensional globe. Figure 1 is a box drawn repeatedly while rotated in a circle in 2D, figure 2 is the same box pattern in 3D and figure 3 is in spherical.

Figure 3. Three Dimensional Bunny Graphics

Figure 4. Spherical Bunny Graphics

Next month I will discuss how the above figures were generated.

One of the most exciting features about Experlisp is it’s speed. It is fast. The program operates at a speed comparable to programs written in assembly language and Forth. However, Lisp is significantly easier to learn and it does handle symbol manipulation as we shall eventually see. As I mentioned last month, one might question it’s usability in AI applications due to the memory size of the Mac. Expertelligence informs me that the Lisp program code is treated in a virtual manner typical to the Macintosh. Code is loaded when needed. Therefore, the size of your program depends upon disk space rather than RAM. The memory limitations do not effect the program size, instead they effect the size of a function. In Lisp one can define a function similar to the way Forth generates it’s own syntax. [Note the use of reverse polish notation, common to Forth code.] For example:

             (DEFUN AVERAGE (W X Y Z)
                 (/ (+ W X Y Z) 4))  

The above defines the word AVERAGE as the average of a four argument list. Whenever AVERAGE is used followed by four numbers it will generate the mean of the numbers, as shown below:

              (AVERAGE 7 3 9 5)
              ;6

Experlisp can allow functions up to 250Kbytes in size! Note that my example didn’t generate one full Kbyte of code.

It sounds great, however like all things there are imperfections. Even though the compiler generates 68000 code there is presently no way to execute that code other than via the Experlisp editor and compiler. Stand-alone applications in Experlisp might become a reality soon however, according to what I have been told by Expertelligence. The manual states that Experlisp 2.0 will be a “much expanded..developer’s version”. There is also the question of debugging facilities. In MacPascal and MSBasic 2.0 there are extremely useful tracing commands which show the programmer exactly what the code is doing every step of the way during execution. Unfortunately, Experlisp does not have that. However, that is no surprise since both Macpascal and MSBasic 2.0 are both completely interpreted languages. Remember, Experlisp is compiled. Error messages are displayed in the Listener Window during compilation. Additionally, Experlisp does provide us with a TRACE Macro which shows the values of a function both before and after execution as well as the ability to break during execution and examine values. Although, it would be useful to see more then just the effects on arguments at the function level. We hope to provide the code for more indepth tracing in Experlisp sometime in a future installment of the Lisp Listener Window. There is another disadvantage for which there is no easy answer; Experlisp works only on a Macintosh 512 or the XL. Sorry, the 128K Mac is too skinny. If this gets you down, try to be patient. The upgrade will more than likely continue to go down in price. One last unfortunate note is the cost. Experlisp will list price at $500.00. This high cost, I’m told, was due to the development costs of Experlisp and it’s copy protection scheme. It will (eventually) be protected using a small piece of hardware which connects between the keyboard and the Mac. If Experlisp becomes as popular as I think it will, this number will probably also come down. At this time Experlisp is a good investment for someone who is very serious about learning and using Lisp for both AI and nonAI programming tasks regardless of the above disadvantages. If I thought otherwise I would not be writing this column!

Last month I mentioned that I was skeptical about whether or not we might be able to produce a serious AI application on the Mac. This month, after learning more about Experlisp, I’m willing to stick my neck out a bit and say that I feel that a relatively serious application is possible. However, the application will probably be a limited expert system using shallow production rules as opposed to indepth semantic networks. One of the advantages to Experlisp is the ease in which one may build the application’s user interface. That in itself places the Mac in the running for real applications using Lisp. Although, serious AI development will require at least a hard disk drive along with the external drive. Time will tell if I’ll eat these words.

More Lisp Procedures

We finished last week with brief descriptions of the CAR and CDR procedures. The procedures are used in taking lists apart. One can nest these procedures so that longer lists may be dissected. For example:

      (CDR ‘(BEANS PEAS CORN CARROTS))
       ;(PEAS CORN CARROTS)
      (CDR ‘(PEAS CORN CARROTS))
       ;(CORN CARROTS) 
      (CAR ‘(CORN CARROTS))
       ;(CORN)  

The above can be written as the following:

      (CAR(CDR(CDR ‘(BEANS PEAS CORN- CARROTS)
        ;(CORN)

All lists following the “;” and in bold are output from the computer) These CARs and CDRs can be combined into one procedure. The above can also be written as follows:

 (CADDR ‘(BEANS PEAS CORN CARROTS))
   ;(CORN)

Each “A” within the “C” and the “R” represents a CAR, while each “D” represents a CDR. Any combination is possible. In Experlisp a depth of four combinations are allowed. That is, CxxxxR, CxxxR or CxxR, while x=”A” or “D”.

Other procedures are used in adding new arguments to a list or for making new lists. These are called Construct lists. The CONS function (short for constructor) puts a new argument at the beginning of a list.

For example:

(CAR (CONS ‘x ‘(y z)))
;x

The CONS adds the “x” to (y z ) making (x y z) from which the CAR extracted the “x”.

The APPEND function puts the arguments from given lists into one new list. For example:

 (APPEND ‘(A B C) ‘(D E F))
;(A B C D E F) 

The LIST function takes the arguments from given lists or entire lists and puts them into a new list. For example;

(LIST (A B C) (D E F) (G H I))
;((A B C) (D E F) (G H I))

The actual value of the LIST function is not apparent since I have not yet discussed assigning values to symbols. One way to perform this assignment is with the SETQ function. SETQ places the value or values of the second argument following the SETQ function and assigns it or them to the first argument. The following example demonstrates this:

 (SETQ VEGETABLES (PEAS BEANS CARROTS)) 
;VEGETABLES
;(PEAS BEANS CARROTS)

After evaluating the first list the symbol VEGETABLES represents (PEAS BEANS CARROTS).When one types the assigned symbol into the Listener Window (after compiling and running the above list) the assigned values are displayed. Of course this example is extremely simple. In coming installments the SETQ function will be used with more interesting examples which will better illustrate the object oriented qualities of Lisp. Getting back to the LIST function, the following example shows it’s real strength in relation to APPEND and CONS:

 (SETQ J (A B C D))                             (LIST J J)
;((A B C D) (A B C D))                         or                    
                          (LIST ‘J J)
;(J (A B C D))                                 or                    
                         
 (LIST ‘J ‘J)
;(J J)                                                   


 (APPEND J J)
;(A B C D A B C D)                               

 (CONS J J)
;((A B C D) A B C D)                              or
 (CONS ‘J J)
;(J A B C D)

Prerelease Caveat

If you have obtained a prereleased version of Experlisp (v0.1), note that the MIN and MAX procedures are not functional. The nested CARs and CDRs won’t work either. You might have also noticed that sometime at the end of March you could not get Experlisp v0.1 to boot up. Expertelligence has something in the code that checks for the date. Beyond the release date (March 31st) the prerelease should not be functional. Unless of course one worked around the current date (set your calender back!). There are other problems associated with using the prerelease. The prerelease manual is actually only an incomplete reference manual and does not contain specific details of Experlisp. Also there is some mixture between Zetalisp and the Common Lisp standard. These combinations are not apparent in the prereleased manual, but are in the release. Obviously, one should not gamble on using a prereleased Experlisp for any kind of programming efforts outside of hacking for fun. If you are without a version of Experlisp but you do have Xlisp some of the above described procedures will work. Type them in as shown, but remember to use lowercase.

Next month the Lisp Listener Window will include sample source listings for generating bunny graphics, windows, menus and various Macintosh toolbox commands.