UCBLogo

Last updated
UCBLogo
Ubclogo spiral.png
UCBLogo allows for recursion, the process where a procedure calls itself. On the image, a spiral is produced by a recursive script.
Paradigms multi-paradigm:functional educational, procedural, reflective
Family Lisp
Designed by Brian Harvey
Developers Dan van Blerkom, Michael Katz, Doug Orleans.
Substantial contributions: Freeman Deutsch, Khang Dao, Fred Gilham, Yehuda Katz, George Mills, Sanford Owings, Randy Sargent [1]
First appeared1992;31 years ago (1992)
Stable release
6.2.1 / 31 December 2020;2 years ago (2020-12-31)
Typing discipline dynamic
Scope Dynamic
Implementation language C
Platform IA-32, x86-64
OS Windows, macOS, Linux
License GPL
Website people.eecs.berkeley.edu/~bh/logo.html
Influenced by
Lisp
Influenced
Smalltalk, Etoys, Scratch, NetLogo, KTurtle, Rebol

UCBLogo, also termed Berkeley Logo, is a programming language, a dialect of Logo, which derived from Lisp. It is a dialect of Logo intended to be a "minimum Logo standard". [2]

Contents

It has the best facilities for handling lists, files, input/output (I/O), and recursion. [3]

It can be used to teach most computer science concepts, as University of California, Berkeley lecturer Brian Harvey [4] did in his Computer Science Logo Style trilogy. [5] [6] [7] It is free and open-source software released under a GNU General Public License (GPL). [8]

Design

Logo was designed in spirit of low threshold and no ceiling, which enables easy entry by novices and yet meet the needs of high-powered users. UCBLogo has a rudimentary graphical user interface (GUI), so several projects exist that provide a better interface. MSWLogo and its successor FMSLogo , for Microsoft Windows, are commonly used in schools in the United Kingdom and Australia.[ citation needed ] For input/output (I/O), text may be written to the command window (output stream) using print and to the graphics window using label.

Animations require both the ability to draw 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. Using the turtle analogy, the turtle's pen must paint, and the turtle's pen must erase. The turtle can be set to erase anything below it, using the command PENERASE (PE), while the pen can be set to start drawing again with the command PENPAINT (PPT), in UCBLogo.

The pen

Turtle drawing a dotted line Ubclogo drawing dash.png
Turtle drawing a dotted line

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.

An example code:

FD20; draw a line and movePENUP; lift the pen so it draws nothingFD20; move and not drawPENDOWN; lower the pen so it draws againFD20; draw a line and movePENUP; lift the pen so it draws nothingFD40; move and not drawPENDOWN; lower the pen so it draws againRT20; rotate right (clockwise) 20 degrees

Data

There are three data types in UCBLogo: the word, the list, and the array (a number is a special case of word). The interpreter detects the datatype by context; there is no static typing.

Prefixing a variable with a colon (:) means the contents of, passing a variable by reference. The double quote symbol (") means the word is evaluated as itself: it is not paired as opening and closing quotes as happens in many other languages. A number is a special case of self-evaluation and can be used with or without a preceding quote.

Variable assignment is handled with the make command:

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.

Variables do not 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, which is termed 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.

Logo inherits lists from Lisp, and they are its main method to store vectors. A list has the advantage over an array that it is infinitely expandable. A list can be considered to be a queue with the operators queue and dequeue, or a stack with the operations push and pop. A property list is a special list where the odd number items are property names, and the even are property values.

Logo provides several common control structures. There is one conditional structure, ifelse test [ do_if_true list ] [do_if_false list]. There are three iteration commands (while, until, and repeat). Recursion, rather than iteration, is Logo's preferred processing paradigm.

Logo also provides list-based control structures. The basic idea is of two lists:

OPERATION[alistofcommands][manydataitems]

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 represent four flavours of template iteration, known as explicit-slot, named-procedure, named-slot (or Lambda), and procedure-text.

Syntax

Basic Chair Ucblogo.png
Basic Chair
Pattern Ubclogo function call.png
Pattern

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.

; draws a square with sides 100 units longFORWARD100LEFT90FORWARD100LEFT90FORWARD100LEFT90FORWARD100LEFT90
FD100RT120FD100RT120; draws a triangleFD100RT120

The Hello World program in Logo looks like this:

 print [Hello World] 

Mathematics in Logo uses prefix or Polish notation , like: sum :x :y, product :x :y, difference :x :y, quotient :x :y. Infix is also available.

Each line is made up of function calls, of which there are two types: commands (which usually do something—effects—but do not return a value) like print, and operations (which just return a value, its output) like sum, first or readlist.

A command is similar to a Pascal procedure, and an operation is similar to a Pascal function.. 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.

Procedures can be defined on the command line, using the TO ... END pair:

TO CHAIR REPEAT 4 [FD 100 RT 90]  FD 200 END

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.

See also

Related Research Articles

A "Hello, World!" program is generally a simple computer program which outputs to the screen a message similar to "Hello, World!" while ignoring any user input. A small piece of code in most general-purpose programming languages, this program is used to illustrate a language's basic syntax. A "Hello, World!" program is often the first written by a student of a new programming language, but such a program can also be used as a sanity check to ensure that the computer software intended to compile or run source code is correctly installed, and that its operator understands how to use it.

<span class="mw-page-title-main">Logo (programming language)</span> Computer programming language

Logo is an educational programming language, designed in 1967 by Wally Feurzeig, Seymour Papert, and Cynthia Solomon. Logo is not an acronym: the name was coined by Feurzeig while he was at Bolt, Beranek and Newman, and derives from the Greek logos, meaning word or thought.

<span class="mw-page-title-main">Plotter</span> Computer output device that draws lines on paper by moving a pen

A plotter is a machine that produces vector graphics drawings. Plotters draw lines on paper using a pen, or in some applications, use a knife to cut a material like vinyl or leather. In the latter case, they are sometimes known as a cutting plotter.

Procedural programming is a programming paradigm, derived from imperative programming, based on the concept of the procedure call. Procedures simply contain a series of computational steps to be carried out. Any given procedure might be called at any point during a program's execution, including by other procedures or itself. The first major procedural programming languages appeared c. 1957–1964, including Fortran, ALGOL, COBOL, PL/I and BASIC. Pascal and C were published c. 1970–1972.

<span class="mw-page-title-main">Scheme (programming language)</span> Dialect of Lisp

Scheme is a dialect of the Lisp family of programming languages. Scheme was created during the 1970s at the MIT Computer Science and Artificial Intelligence Laboratory and released by its developers, Guy L. Steele and Gerald Jay Sussman, via a series of memos now known as the Lambda Papers. It was the first dialect of Lisp to choose lexical scope and the first to require implementations to perform tail-call optimization, giving stronger support for functional programming and associated techniques such as recursive algorithms. It was also one of the first programming languages to support first-class continuations. It had a significant influence on the effort that led to the development of Common Lisp.

Metafont is a description language used to define raster fonts. It is also the name of the interpreter that executes Metafont code, generating the bitmap fonts that can be embedded into e.g. PostScript. Metafont was devised by Donald Knuth as a companion to his TeX typesetting system.

<span class="mw-page-title-main">L-system</span> Rewriting system and type of formal grammar

An L-system or Lindenmayer system is a parallel rewriting system and a type of formal grammar. An L-system consists of an alphabet of symbols that can be used to make strings, a collection of production rules that expand each symbol into some larger string of symbols, an initial "axiom" string from which to begin construction, and a mechanism for translating the generated strings into geometric structures. L-systems were introduced and developed in 1968 by Aristid Lindenmayer, a Hungarian theoretical biologist and botanist at the University of Utrecht. Lindenmayer used L-systems to describe the behaviour of plant cells and to model the growth processes of plant development. L-systems have also been used to model the morphology of a variety of organisms and can be used to generate self-similar fractals.

Programmed Inquiry, Learning, or Teaching (PILOT) is a simple high-level programming language developed in the 1960s. Like its younger sibling LOGO, it was an early foray into the technology of computer-assisted instruction.

GRASS is a programming language created to script 2D vector graphics animations. GRASS was similar to BASIC in syntax, but added numerous instructions for specifying 2D object animation, including scaling, translation and rotation over time. These functions were directly supported by the Vector General 3D graphics terminal GRASS was written for. It quickly became a hit with the artistic community who were experimenting with the new medium of computer graphics, and is most famous for its use by Larry Cuba to create the original "attacking the Death Star will not be easy" animation in Star Wars (1977).

In computer graphics, turtle graphics are vector graphics using a relative cursor upon a Cartesian plane. Turtle graphics is a key feature of the Logo programming language.

In computer programming, a parameter or a formal argument is a special kind of variable used in a subroutine to refer to one of the pieces of data provided as input to the subroutine. These pieces of data are the values of the arguments with which the subroutine is going to be called/invoked. An ordered list of parameters is usually included in the definition of a subroutine, so that, each time the subroutine is called, its arguments for that call are evaluated, and the resulting values can be assigned to the corresponding parameters.

A read–eval–print loop (REPL), also termed an interactive toplevel or language shell, is a simple interactive computer programming environment that takes single user inputs, executes them, and returns the result to the user; a program written in a REPL environment is executed piecewise. The term usually refers to programming interfaces similar to the classic Lisp machine interactive environment. Common examples include command-line shells and similar environments for programming languages, and the technique is very characteristic of scripting languages.

In computing, tee is a command in command-line interpreters (shells) using standard streams which reads standard input and writes it to both standard output and one or more files, effectively duplicating its input. It is primarily used in conjunction with pipes and filters. The command is named after the T-splitter used in plumbing.

MicroWorlds JR is a computer program using a simplified version of the Logo programming language to teach non-readers or early readers to program in Logo. It was first launched in 2004 by Logo Computer Systems, Inc. (LCSI), and as in their original line of MicroWorlds programs, the object on the screen begins as a turtle and can be controlled with basic commands to make it move. Differing from the Logo syntax developed by Seymour Papert and teams at MIT, MicroWorlds JR uses images to replace the command names, which are selected by the child to create turtle graphics. The turtle object can be given a variety of shapes that act as a costume for the turtle, and therefore lends itself to a variety of animations and creative stories and projects for younger students.

<span class="mw-page-title-main">MSWLogo</span> Programming language

MSWLogo is a programming language which is interpreted, based on the computer language Logo, with a graphical user interface (GUI) front end. It was developed by George Mills at the Massachusetts Institute of Technology (MIT). Its core is the same as UCBLogo by Brian Harvey. It is free and open-source software, with source code available, in Borland C++.

ReGIS, short for Remote Graphic Instruction Set, is a vector graphics markup language developed by Digital Equipment Corporation (DEC) for later models of their famous VT series of computer terminals. ReGIS supports rudimentary vector graphics consisting of lines, circular arcs, and similar shapes. Terminals supporting ReGIS generally allow graphics and text to be mixed on-screen, which makes construction of graphs and charts relatively easy.

<span class="mw-page-title-main">Brian Harvey (lecturer)</span> American computer scientist

Brian Keith Harvey is a former Lecturer SOE of computer science at University of California, Berkeley. He and his students developed an educational programming language named UCBLogo which is free and open-source software, a dialect of the language Logo, as an interpreter, for learners.

Snap<i>!</i> (programming language) Block-based programming language

Snap! is a free block-based educational graphical programming language and online community allowing students to explore, create, and remix interactive animations, games, stories, and more, while learning about mathematical and computational ideas. While inspired by Scratch, Snap! has many advanced features. The Snap! editor, and programs created in it, are web applications that run in the browser without requiring installation. It is built on top of Morphic.js, a Morphic GUI, written by Jens Mönig as 'middle layer' between Snap! itself and 'bare' JavaScript.

BASIC 1.0 is the standard BASIC language for Thomson computers, which is the reference for the entire range. This is an implementation of Microsoft BASIC (BASIC-69). It was used to introduce children from France to programming in the 1980s. Three languages were mainly taught: LSE, BASIC and LOGO. School textbooks programs were given in BASIC 1.0 for Thomson and sometimes in ExelBasic for the Exelvision EXL 100.

Wang BASIC is a series of BASIC programming languages for computers from Wang Laboratories. The term can be used to refer to the BASIC on any Wang machine, but is mostly associated with the versions on the Wang 2200 minicomputer series of the early 1970s. When these machines were updated to the VP series in 1976, BASIC-2 was introduced and remained the pattern for future machines in the 2200 series. A planned BASIC-3 was never released.

References

  1. Harvey, Brian (1997). Volume 1: Symbolic Computing: Acknowledgments. Computer Science Logo Style. Vol. 1. MIT Press. ISBN   0-262-58148-5 . Retrieved 2019-05-06.{{cite book}}: |website= ignored (help)
  2. Solomon, Cynthia; Harvey, Brian; Kahn, Ken; Lieberman, Henry; Miller, Mark; Minsky, Margaret; Papert, Artemis; Silverman, Brian (June 2020). "History of Logo". Proc. ACM Program. Lang. 4: 1–66. doi:10.1145/3386329. hdl: 1721.1/133952 . S2CID   219012246.
  3. "Logo Programming Language". Logo Foundation. 2012. Archived from the original on 2013-08-15. Retrieved 2019-05-06.
  4. Harvey, Brian. "Brian Harvey". Electrical Engineering and Computer Sciences. University of California, Berkeley. Retrieved 2019-05-06.
  5. Harvey, Brian (1997). Volume 1: Symbolic Computing. Computer Science Logo Style. Vol. 1. MIT Press. ISBN   0-262-58148-5 . Retrieved 2019-05-06.{{cite book}}: |website= ignored (help)
  6. Harvey, Brian (1997). Volume 2: Advanced Techniques. Computer Science Logo Style. Vol. 2. MIT Press. ISBN   0-262-58149-3 . Retrieved 2019-05-06.{{cite book}}: |website= ignored (help)
  7. Harvey, Brian (1997). Volume 3: Beyond Programming. Computer Science Logo Style. Vol. 3. MIT Press. ISBN   0-262-58150-7 . Retrieved 2019-05-06.{{cite book}}: |website= ignored (help)
  8. Harvey, Brian (2008-09-14). "Release 6.0 of Berkeley Logo is now available by anonymous FTP or Web". Electrical Engineering and Computer Sciences. University of California, Berkeley. Retrieved 2019-05-09.