SLogo

Logo is a computer programming language designed to teach programming to children. It is a user-friendly, interpreted language, designed with a "low floor, high ceiling"; in other words, the designers of Logo intended for the language to allow novice programmers to get started quickly writing programs but also wanted the language to be powerful and extensive for more advanced users.

In the early days, Logo was used to control a simple physical robot, called a turtle. Users could issue commands such as FORWARD 50 to make the turtle advance 50 steps, or RIGHT 90 to make it turn ninety degrees. The turtle robot carried a pen, so users could produce drawings on paper, such as the one shown to the left, by controlling the turtle and its pen. The turtle, which has since moved on to the computer screen, has become one of the most familiar and important parts of the Logo language. For the complete history see here.

As a dialect of LISP, Logo is a complex and powerful language. For this project you will design and implement a much simplified version of Logo. "Simple Logo", or SLogo, should retain the features most commonly used by beginning users so that it can be used to provide an introduction to computer programming.

Basic Specifications

You should form teams of two or three to design an integrated development environment, IDE, that allows a SLogo programmer to accomplish the following tasks:

• enter commands to the turtle interactively (see descriptions of the basic commands here). This is the so-called read-eval-print loop used in Scheme, Lisp, Smalltalk and other language IDEs. The key here is that the user should be able to type any Logo expression, press some key/mouse button and have the expression evaluated. This should be doable on a per expression basis. The environment in which the user enters commands is called a workspace. Your IDE should support multiple workspaces with cut/paste between them.
• read a file of valid SLogo subroutines/variables and have these definitions added to the set of valid SLogo commands that can be entered in the read-eval-print loop. Thus the user can develop a library of subroutines, save these, and then reload these subroutines later.
• save SLogo subroutines/variables to a file so that these definitions can be read in (see previous requirement). You do not need to save the entire workspace, but should be able to save the user's definitions in a workspace.
• display the results of the turtle executing commands. The turtle should be driven via commands entered in the workspace and optionally by buttons or other user controls. The IDE should support feedback so that the user is always aware of the turtle's position, heading, or other parameters affected by the environment. The turtle data can be toggled off/on if it affects performance, but should be accessible if the user wants to know turtle information. Note, the turtle starts in the center of the display which is considered (0, 0).
• display errors that may result from the user's commands

At its heart, SLogo consists of a basic turtle graphics package and support for a set of commands allowing the user to control the turtle and the pen using basic programming constructs such as conditionals, loops, and procedures. When a user launches the SLogo IDE from the command line, it should bring up a command window and a turtle graphics window. The interpreter will need to receive, parse, and execute commands from the window, reporting any errors it encounters along the way (and not crashing!), and displaying the results of the commands in the graphics window.

Some example SLogo programs are available online.

Extensions

In the early days, Logo was run on small, slow machines and thus its environments were given only limited capabilities. Additionally, there was only a single turtle drawn as a triangle in only one display window to show the turtle's actions. In modern times, Logo has been used to run simulations with thousands of turtles and also to make animations. Your job in extending the basic program is to bring your logo environment from the seventies into the new millennium (and beyond?). Thus, you should design your program to easily allow the following extensions.

Some basic enhancements to your IDE will make it nicer to use (in order of increasing difficulty):

• allow the user to specify an image to use for the turtle instead of a triangle
• allow the user to change the properties of the turtle's pen (at least up/down, its thickness, and color) graphically
• allow the user to choose the turtle's image from a set of images (initially a default set, but the user could add to the set)
• display the current defined variable names and their values
• display the current user defined procedures
• allow the user to change the properties of the pen's trail (i.e., solid, dashed, double, etc.) graphically
• allow the user to zoom in or out within the display (this should not change the dimensions of the turtle's world, just the user's view of it)
• allow the user to resize the environment arbitrarily
• allow the user to undo/redo the last action(s) done in the IDE

In order to allow the user to run simulations or create games, you should allow the user to create as many turtles as they want. By default, there are an infinite number of turtles hidden at the home position. So, if you show the second turtle it should appear at home, unless the user has moved it first, then shown it. To do this, you will need to add the following:

• add some commands to the logo grammar (see the extended command descriptions here)
• think about how some of your controls will work for many turtles (for example, the pen property setter)

It is already reasonably easy for the user to make simple animations using SLogo because the user can create multiple turtles, set the turtle's appearance to something other than a triangle, zoom in, and animate the turtle's actions. To further facilitate quality animations, you should add the following:

• allow the user to set a background image for the turtle's display
• allow the user to add sound
• allow the user to show a second, canonical display of the action, i.e., an unzoomed display in which all of the turtles are visible and viewed simply as triangles
• allow the user to start, stop, reset, and single step the turtles performing a set of SLogo commands
• allow the user to reset the display back to some previous time and replay from there

Finally, you can improve the environment for programming by including the extensions below:

• allow more complex control structures
• allow local variables and parameters to procedures
• allow recursion
• allow infix mathematical and relational expressions
• allow variable number of parameters to procedures where appropriate
• add list processing functions and lists, stacks, queues, and random access arrays
• add a debugger (a small step if you have completed the animation and variable viewing extensions above)

Deliverables

1. A one to two page description of the packages and classes you envision as part of implementing SLogo (a picture could be extremely helpful here). Your design description should especially discuss how you plan to separate the graphical interface from the interpreter and how you plan to let them communicate when necessary. 
2. A one to two page description of your graphical user interface, including, if necessary, drawn "screen shots" of how you plan to lay out your interface and how you plan to connect the interface to the rest of the program.
3. A detailed description, about a page, of how your program will handle the following use case: "The user starts the program, types 'fd 50' in the command window, and sees the turtle move in the display window leaving a trail." It should be clear from this description which objects are responsible for completing each part of the task.

Resources

For background and more complete information about logo consult these links:

• The Logo Foundation
• Tutorial on Turtle Graphics
• Brain Harvey's ucblogo user manual
• George Mills MSW Logo
• Mitchel Resnick's StarLogo
• Digitool's Object Logo
• Hrvoje Blazevic's GNU Emacs Logo mode with interactive debugging tools