SLogo Design Exercise
Form a group with your final project team for this exercise. Someone should volunteer to take notes on the group's discussion as you go so that it can be compared with others' solutions.
This project is intended to get you to try to design a program without worrying about exactly how it will be implemented. In other words, you should explore a design in enough detail to convincingly complete the deliverables below without writing any actual code.
Specifications
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.
For this exercise, design an Integrated Development Environment, or IDE, for a simplified version of Logo, or SLogo, that focuses on allowing users to write and manage programs to draw such pictures. Specifically, the user should be able 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
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. Extend your basic design to bring your SLogo environment from the seventies into the new millennium (and beyond?). Thus, your design should 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
During the course of your discussion, make sure you address the deliverables below and try to summarize your discussion as follows:
- A 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 rather than on the parsing (which you know well).
- A description of your graphical user interface, including 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.
- A description 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
Or view these videos
