Logo (programming language)
From Network Dictionary Wiki
Logo is a computer programming language used for functional programming. It is an easier to read adaptation and dialect of the Lisp language; some have called it "Lisp without the parentheses." It was created for educational use, more so for constructivist teaching, by Daniel G. Bobrow, Wally Feurzeig and Seymour Papert. Today, it is known mainly for its "turtle graphics", but it also has significant facilities for handling lists, files, I/O, and recursion. Logo can be used to teach most computer science concepts, as UC Berkeley Lecturer Brian Harvey does in his "Computer Science Logo Style" trilogy.
Contents |
History
Logo was created in 1967 at Bolt, Beranek and Newman (BBN), a Cambridge, Massachusetts research firm, by Wally Feurzeig and Seymour Papert[1]. Its intellectual roots are in artificial intelligence, mathematical logic and developmental psychology. The first four years of Logo research, development and teaching work was done at BBN. The first implementation of Logo, called "ghost", was written in LISP on an SDS 950. The goal was to create a "mathland" where kids could play with words and sentences. Modeled on LISP, the design goals of Logo included accessible powerTemplate:Huh and informative error messages. The use of virtual Turtles allowed for immediate visual feedback and debugging.
The first working turtle robot was created at MIT in 1969. A display turtle preceded the physical floor turtle. Modern Logo has not changed too much from the basic concepts before the first turtle. The first turtle was a tethered floor roamer, not radio-controlled or wireless. Later, BBN developed a turtle named "Irving" that had touch sensors and could move forwards, backwards, rotate, and ding its bell. The earliest year-long school users of Logo were in 1968-69 at Muzzey Jr High, Lexington MA. The virtual and physical turtles were first used by fifth graders at the Bridge School in Lexington, MA in 1970-71.
Implementations
As of February 2007 there were over 170 implementations and dialects of Logo, each with its own strengths. Most of those 170 are no longer in wide use, but many are still under active development.
As yet there is no single agreed-upon Logo language definition or standard, though there is a broad consensus on core aspects of the language. There are substantial differences between the many dialects of Logo. The situation is confused by the regular appearance of turtle graphics programs that mistakenly call themselves "Logo".
The most broadly used and prevalent early implementation of Logo was Apple Logo, developed by LCSI for the Apple II computer and popular in the 1980s.
The closest thing to a de facto Logo standard today is UCBLogo, also known as Berkeley Logo. It is free and cross-platform. UCBLogo has only a rudimentary graphical user interface, so several projects exist that provide a better interface. MSWLogo, and its successor FMSLogo, for Windows, are commonly used in schools in the United Kingdom.
Commercial Logos that are still widely used in schools include MicroWorlds Logo and Imagine Logo.
Some modern derivatives of Logo allow thousands of independently moving turtles. There are two popular implementations: MIT StarLogo and NetLogo. They allow for the exploration of emergent phenomena and come with many experiments in social studies, biology, physics, and other areas.
Most Logos are 2D, but the Elica interpreter is notable for supporting 3D graphics. Most Logo implementations are interpreted, but some compilers have been built, including the Lhogho compiler, by the same author as Elica.
Although most often used for graphics, Logo can also control robots. It was interfaced with LEGO bricks, although Lego decided later to use another language in the commercial LEGO Mindstorms products. The Mindstorms GUI interface is based on LabVIEW by National Instruments. An interface also exists for Cricket robots.
Influence
Logo was a primary influence on the Smalltalk programming language. It is also the main influence on the Etoys educational programming environment and language, which is essentially a Logo written in Squeak (a variant of Smalltalk).
Programming
Template:Howto Template:Seealso
Logo's best-known feature is the "turtle", which is an on-screen cursor (derived originally from a robot of the same name) which can be given movement and drawing instructions, and is used to programmatically produce line graphics. It is traditionally and most often represented pictorially either as a triangle or a turtle icon (though it can be represented by any icon). Turtle graphics were added to the Logo language by Seymour Papert in the late 60s to support Papert's version of the turtle robot, a simple robot controlled from the user's workstation that is designed to carry out the drawing functions assigned to it using a small retractable pen set into or attached to the robot's body.
As a practical matter, the use of turtle geometry instead of a more traditional model mimics the actual movement logic of the turtle robot. Turtle geometry works somewhat differently from (x,y) addressed Cartesian geometry, being primarily vector-based (i.e. relative direction and distance from a starting point) in comparison to coordinate-addressed systems such as PostScript. The turtle moves with commands that are relative to its own position, "LEFT 90" meant rotate left by 90 degrees. A student could understand (and predict and reason about) the turtle's motion by imagining what they would do if they were the turtle. Papert called this "body syntonic" reasoning.
Some Logo implementations, particularly those that allow the use of concurrency and multiple turtles, support collision detection and allow the user to redefine the appearance of the turtle cursor, essentially allowing the Logo turtles to function as sprites.
Turtle geometry is also sometimes used in environments other than Logo as an alternative to a strictly coordinate-addressed graphics system. For instance, the idea of turtle graphics is also useful for example in Lindenmayer system for generating fractals.
Syntax
Commands may be written on one line, or more. Many commands have mnemonic short forms; for example FORWARD and RIGHT are coded FD and RT respectively. This makes the input less onerous. Anything written after the ; (semicolon) is ignored, allowing the coder to insert comments.
FORWARD 100 ; draws a square with sides 100 units long LEFT 90 FORWARD 100 LEFT 90 FORWARD 100 LEFT 90 FORWARD 100 LEFT 90
FD 100 RT 120 FD 100 RT 120; draws a triangle FD 100 RT 120
The pen
The analogy of a turtle with a pen attached to its tail is often used. The turtle's pen can be lifted and lowered, thus drawing a rudimentary dotted line.
FD 20 ; drawing a line and moving PENUP ; lifting the pen so it won't draw anything FD 20 ; not drawing but moving PENDOWN ; lowering the pen so it draws again FD 20 ; drawing a line and moving PENUP FD 20 PENDOWN FD 20
Loops
There are three loop (repeat) commands; REPEAT is one. This draws the a box.
REPEAT 4 [FD 100 LEFT 90]
The command "FD 100 LEFT 90" is executed four times.
An approximation of a circle can be constructed easily with 360 small rotations and a step forward: REPEAT 360 [FD 1 RIGHT 1]. Loops may be embedded, giving spectacular results with little effort.
REPEAT 36[ RT 10 REPEAT 360 [FD 1 RT 1]]
Defining procedures, the need for an editor
Procedures can be defined on the command line, using the TO END pair:
TO CHAIR REPEAT 4 [FD 100 RT 90] FD 200 END
However, the procedure is limited to the physical line length of the input device.
All Logos can invoke an Editor, usually by EDALL. In the editor, procedures may be written over many lines, as nothing is interpreted until the edit is complete.
EDALL TO CHAIR REPEAT 4 [FD 100 RT 90] FD 200 END
The new word is saved into the available vocabulary, but the definition will be lost once the Logo session is over. Internally procedures are words and in this case, any time CHAIR is entered, the sequence REPEAT 4 [FD 100 LEFT 90] FD 200 will be executed. The word CHAIR can be used as a command; for example, REPEAT 4 [CHAIR] would repeat the CHAIR operation four times.
Animation
Logo was designed in spirit of "low threshold and no ceiling," that enables easy entry by novices and yet meet the needs of high powered users. Animations require both the ability to draw shapes and to erase shapes. The process is the same, except that in the former a line is deposited on the display device and in the latter a line is removed, so using the turtle analogy: the turtles pen must paint, and the turtles pen must erase.
In UCBLogo, the turtle can be set to erase using the command PENERASE (PE).
Now any future FD movements will erase anything beneath them. The pen can be restored with the command PENPAINT (PPT).
EDALL;(to enter the editor mode, then the actual procedure)TO ERASECHAIR PE BK 200 REPEAT 4 [FD 100 RT 90] PPT END
CS CHAIR WAIT 200 ERASECHAIR
A WAIT delay between the drawing and the erasing introduces the illusion of motion.
CS REPEAT 20 [CHAIR WAIT 200 ERASECHAIR FD 20]
Logo can pass extra information to its words, and return information. The procedure, (word) is instructed to expect something and give that something a name. The colon is used for this purpose. It passes the information 'by value' and the colon is pronounced as 'the value of'. When the procedure is run with a command like CHAIR 200, the word :thesize takes the value 200 so when FD :thesize is executed, the interpreter understands 'FD the value of 200'.
EDALL ;(to enter the editor mode, then the actual procedure)
TO CHAIR :thesize
REPEAT 4 [FD :thesize RT 90] FD :thesize FD :thesize
END
CS REPEAT 9 [CHAIR 50 RT 20 CHAIR 100 WAIT 50 RT 20]
The language
Logo is generally known as an interpreted language, although recently there have been developed compiled Logo dialects - like Lhogho or Liogo. Logo is not case dependent, but retains the case used for formatting. It is written in lines. It is a compromise between a sequential programming language with block structures, and a functional programming language. There is no 'standard' LOGO, but UCBLogo is highly regarded. It is a teaching language but its list handling facilities make it remarkably useful for producing useful scripts.
Functions and procedures
Each line is made up of "function calls", or subroutines in programming terminology, of which there are two types:
- commands (which do something—effects—but don't return a value) like
print. - operations (which just return a value, its output) like
sum,firstorreadlist.
A command is similar to a Pascal procedure, and an operation is similar to a Pascal function. (See also: command-query separation, where a "query" is an "operation" in Logo). A special subset of operations, called predicates, which just output the word true or false, are conventionally written with a final p. Examples include emptyp, wordp, and listp.
- Expressions can be primitives, or can be defined by the user.
- Expressions can take zero, one or more parameters.
Mathematics in Logo uses prefix notation, like: sum :x :y, product :x :y, difference :x :y, quotient :x :y. Infix is also available.
help "keyword ;(will bring up a full description of the expression).
Logo allows for recursion, the process where a procedure calls itself.
Example 8: A spiral drawn using recursion
to spiral :size if :size > 30 [stop] ; an exit condition fd :size rt 15 ; many lines of action spiral :size *1.02 ; the tailend recursive call end
spiral 10
Data
There are three datatypes in UCBLogo,
- the word,
- the list,
- the array.
A number is a special case of word.
There is no static typing. The interpreter detects the datatype by context.
There are two important symbols
- The colon
:- this means 'the contents of'
This is an extremely useful symbol that keeps reminding students that a variable is really some 'place' in memory.
- The quote- this means '"the word is evaluated as itself"', or '"its value after evaluation is the same as it was before"'. This is important.
A number is a special case of self evaluation- it really could be written with a quote 2 is really "2
Variable assignment (eg. x := y + 3) is handled in Logo with the make command:
make "x sum :y 3
or
make "x sum :y "3
make takes 2 parameters, the second of which here is sum :y "3. sum takes two 'parameters' and is an 'operation', thus the calculation is possible. "3 evaluates to 3, and :y takes the contents of the thing called y, these are summed giving a number.
The effect of make is to place the result into the first parameter. From a programmatical perspective, the first argument to make is passed "by reference", while the second is passed "by value".
Scoping
Variables don't have to be declared before use; their scope is then global.
A variable may be declared local, then its scope is limited to that procedure and any procedures that it calls (a.k.a. dynamic scope). Calling a procedure with "inputs" (the name usually used for arguments in the Logo literature) also creates local variables that hold the argument values.
Lists
Logo inherits lists from Lisp, and they are its primary method of storing "vectors". Arrays are also provided.
- Operators exist to convert words into lists, and lists into arrays and back again.
- This data type has the advantage over arrays that it is infinitely expandable. Data are extracted using the operations first, butfirst, last, butlast, butmember, member and item. Data elements are added using sentence fput and lput.
- A list can be considered to be a queue with the operators queue and dequeue, or a stack with the operations push and pop.
- Recursion rather than iteration is the natural method to process lists.
Example 9: using list primitives to extract the first five members of a list
One way would be to use iteration.
to firstfive :alist ifelse lessp count :alist 6 [ op :alist ][make "olist []] repeat 2 [ make "olist lput first :alist :olist make "alist bf :alist ] output :olist end show firstfive [1 2 3 4 5 6 7 8 9 ] [1 2 3 4 5] foreach firstfive [1 2 3 4 5 6 7 8 9 ] [show 10 - ?] 9 8 7 6 5
Another, more elegant way would be
to firstn :num :list if :num = 0 [output []] output fput (first :list) (firstn :num-1 butfirst :list) end to firstfive :list output firstn 5 :list end
This method uses recursion, and is an example of a 'functional' rather than an 'imperative' programming approach.
And a more general way would be
to tail :num :alist if or not numberp :num not listp :alist [print [Error: Bad argument(s)] stop] if not equalp 0 :num - int :num [make "num int :num] if :num=0 [output []] if equalp count :alist abs :num [op :alist] if lessp count :alist abs :num [output :alist] if :num>0 [output tail.left :num :alist] if :num<0 [output tail.right abs :num :alist] end to tail.left :num :list output fput (first :list) (tail.left :num-1 butfirst :list) end to tail.right :num :list output lput (last :list) (tail.right :num-1 butlast :list) end show tail 5 [1 2 3 4 5 6 7 8 9] [1 2 3 4 5] show tail -5 [1 2 3 4 5 6 7 8 9] [5 6 7 8 9]
Control structure commands
Logo provides several common control structures.
- ifelse test [ do_if_true list ] [do_if_false list]
There are iteration commands
- while condition [instruction list]
- until condition [instruction list ]
- repeat number [instruction list]
Recursion is Logo's preferred processing paradigm.
Template iteration
Logo also provides list-based control structures. The basic idea is that you have two lists
OPERATION [ a list of commands ] [ many data items ]
each of the commands is applied in turn to each of the data items. There are several of these template commands with names like MAP, APPLY, FILTER, FOREACH, REDUCE and CASCADE. They repesent four flavours of template iteration, known as explicit-slot, named-procedure, named-slot (or Lambda) and procedure-text.
show map [? * ? ] [ 5 6 7 ] [25 36 49 ] show filter [ (count ?) > 4 ] [ the quick brown fox jumps over the lazy dog ] [quick brown jumps] show foreach [1 2 3 4 5] [ ? * 10 ] [10 20 30 40 50]
RUN [ list of commands ] ;run a list of commands (or programs) from in a program.
Property lists
A property list is a special list where the odd number items are property names, and the even are property values. There are three commands to process property list.
pprop :listname :name :value ;to add a new pair to the list remprop :listname :name :value ;to remove a pair to the list show gprop :listname :name ;to get the matching value from the list
I/O Commands
Text may be written to the command window (output stream) using print, show and to the graphics window using label
The standard commands are readlist readword readchar with the normal input stream being the keyboard. In Unix tradition the input stream can be changed, so input can come from a disk file. Similarly, output can be redirected.
openread [filename] setread[filename] setreadpos nn readchar setread[] close [filename].
There are equivalent commands to change the output stream, openwrite, openappend, setwrite, setwritepos nn.
dribble [filename]
Creates a transcript of everything that is typed in or outputted to the command window.
nodribble
This turns it off.
I/O commands can be applied to generate text to resemble a known bitmap, also seen in ASCII art conversion programs. An example of this, a set of crosses resembling the Mandelbrot set.
Graphics
Turtle graphics is a powerful method of introducing thinking but LOGO also has a few useful Cartesian commands
home ;returns the turtle to (0,0) setx xx sety yy ; sends the turtle, still drawing to (xx,yy) seth nn ; sets the turtle on a heading or compass bearing of (nn)
Example 10: calculating and drawing a sundial for a given latitude
This is a typical garden dial. The graphic can be printed and transferred to wood or brass to make an accurate garden timepiece.
to dial
cs show [Type in your latitude as a whole number]
make "latitude readword ;uses keyboard input
for [i 0 6 1][
make "ang arctan product sin :latitude tan product :i 15 ;the calculation
rt :ang fd 200 bk 200 lt :ang ;draw the morning line
lt :ang fd 200 bk 200 rt :ang ;use symmetry to draw the afternoon line
]
pu setx -300 sety -300 seth 90 pd ;send the turtle to the bottom
fd 300 seth 270 rt 90 - :latitude fd 300 ;draw the [[style]] or [[gnomon]]
pu home pd ;tidy it up
end
A sundial plate must be adjusted by latitude using the formula
x= arctan( sin(latitude)*tan(HourDiff * 15) )
The Gnomon Angle = latitude.
This dial above is set for 38N, the latitude of Berkeley, California. A small correction should also be made for longitude.
MSWLogo extensions
MSWLogo supports multiple turtles, and 3D Graphics. MSWLogo allows input from COM ports and LPT ports and also 'hardware' ports. MSWLogo also supports a windows interface thus I/O is available through this GUI- and keyboard and mouse events can trigger interrupts.
GIF animations
Simple GIF animations may also be produced on MSWlogo version 6.5 with the "gifsave" command. An example of the result of this - an animation of a sabot separating from its shell - is given here. Another example, of an oscillating polar rose, is given here. Below is an example of code to generate a simple animation.
to squareani :number
setactivearea [-5 -5 105 105] ;we do not want to save the entire screen
local "col
setpensize [3 3] ;make it a noticeable square
make "append "false ;signify that we want to start a new animation
repeat :number [
cs
make "col 255*(repcount-1)/(:number-1)
setpc (list :col :col :col) ;change the square's color
repeat 4 [ ;
fd 100 rt 90 ;draw the square
] ;
(gifsave "squareani.gif 5 :append 0) ;save to squareani.gif
make "append "true ;from now on, we want to keep adding frames to squareani.gif
]
end
Thus, with a :number variable of 15 frames, the result is given below, along with a slightly more complex example (note that this gifsave feature does not yield the same quality color gradients as Logo would save in bitmap form):
| Image:Squareani.gif | |
| A square fading from black to white in 8 bits per pixel (default for gifsave). |
Save/Load Functions
MSWLogo and FMSLogo support saving and loading of LOGO procedures and files.
to clone make "generation :generation + 1 make "newfilename (word "reproducer :generation ".lgo) save :newfilename load :newfilename end Make "generation 0 Make "newname "reproducer1.lgo Make "startup [clone]
Hello World Loading a file will include all its defined procedures into the currently open file. If the file being opened has commands that are not in a defined procedure they will be ran on startup and will be removed from the workspace (except for variable assignments), so if the file is then saved it becomes blank. For example, one could have a helloworld.lgo which prints Hello World and becomes blank:
print [Hello World]
It is however a better practice generally to put everything into a procedure of some sort and then define the entry point using the startup veriable:
to main print [Hello World!] end make "startup [main]
This ensures that after being run the file is not changed if later saved. For one-time run scripts it is not necessary to do this.
Bibliography
- Computer Science Logo Style, Brian Harvey, MIT Press (3 volumes) ISBN 0-262-58148-5, ISBN 0-262-58149-3, ISBN 0-262-58150-7. Available online
- The Great Logo Adventure, Jim Muller, Doone Publications ISBN 0-9651934-6-2 (Now out of print but downloadable free of charge in pdf form from The MSWLogo website - from where you can also download the freeware MSWLogo program)
- Turtle Geometry Abelson and diSessa
- Practical logo for the Atari ST (Paperback), Martin Sims, Glentop ISBN 1851810307 ,ISBN 978-1851810307. Available online
- TO ARTIFICIAL 'INTELLIGENCE (1976) Early AI textbook where LOGO is used extensively. (Using the Edinburgh University dialect, AI2LOGO)
External links
Template:Commonscat Template:Linkfarm
- Template:Dmoz
- Berkeley Logo (UCBLogo)
- Gary Stager's Logo Resources
- Logo Computer Systems, Inc. maker of Microworlds, a commercial Logo
- MSWLogo
- FMSLogo
- Elica a 3D Logo
- Wiki history of Logo covering the very early days
- A Logo Tutorial for the OLPC project
- Lhogho a Logo compiler for Linux and Windowsar:لغة اللوجو
bs:LOGO bg:Лого (програмиране) ca:Llenguatge de programació Logo cs:Logo (programovací jazyk) de:Logo (Programmiersprache) es:Logo (Lenguaje de programación) fa:زبان برنامهنویسی لوگو fr:Logo (langage) hr:Logo (programski jezik) it:Logo (informatica) he:לוגו (שפת תכנות) hu:Logo (programozási nyelv) nl:Logo (programmeertaal) ja:LOGO pl:Język programowania Logo pt:Logo ru:Logo (язык программирования) simple:Logo (programming language) sk:Logo (programovací jazyk) sl:Logo (programski jezik) fi:Logo (ohjelmointikieli) th:ภาษาโลโก tg:Лого (забони барномасозӣ) zh:Logo语言
Categories: Dynamically-typed programming languages | Educational programming languages | Functional languages | Lisp programming language family | Programming languages | 1960s software | Robotics