MicroWorlds is a dialect of LOGO. It’s made by LCSI (LOGO Computing Systems Incorporated), and replaced LOGOWRITER in their product lineup in the early 1990s. The best way of explaining it is that it’s a programming language designed not only to teach children the basics of programming quickly and without frustrating them, but also to make it easy to create fun, graphical games very quickly. MicroWorlds projects can be embedded in websites, or run using a freeware interpreter if programmers want to show off their work to others.

The organization of the program is somewhere between Macromedia Flash and Dr. Scheme. In the main project window, pictures can be drawn and objects inserted. There’s a “Command Center” for quickly running commands, and a “flipside” for coding procedures.

As with other LOGO variants, all of the action happens with turtles. Turtles are something like objects: they have a number of properties, which can be set through key commands. Unlike objects, however, they do not have methods: they are addressed by name (or through more complex, powerful commands) and are given commands like “fd 20” (jump forward 20 pixels) “lt 71” (turn counterclockwise by 71 degrees) or “setsh 13” (change appearance to shape #13). There can be many turtles at once, addressed individually or in groups. Each can have their own color (for drawing), different shapes (for more traditional sprite-based projects) or any number of other properties, both default and user-defined.

Because so much of MicroWorlds’ influence comes from LISP, it derives a great deal of its power from list-based work. All commands really are just interpreted strings (in fact, interpreted sets of strings). After a student has been working with MicroWorlds for a while, an instructor can tell him or her that the reason that some commands (like if) are passed instructions in brackets is that brackets define an on-the-fly list. Many commands return lists containing project data, including window size, lists of objects, properties, and others. There are commands to convert strings into lists of “words” and back, to run lists as data, to join and filter lists, and many more. Consider this procedure:

to tellgroup :groupName :commandList
		if member? :groupName who
			run :commandList

What you’ve just read is a procedure to pass a set of commands to every turtle on the current project page that contains a certain string in their name (id est, If your name contains ship, do this.). I’ve helped kids to use similar techniques to make games where all that’s required to make a new level is to draw the background, drop in turtles, give them appropriate names, and type in a setup command. Can you do that with C and a group of ten-year-olds in under a week?

High on the list of other plusses for MicroWorlds are consistency (there are no keywords in the C sense — only a base set of predefined commands), its ability to make both traditional one-line recursive LISP programs and standard procedural programs, the fact that, like with many high-level languages, it is to make generating complex, cerebral programs a breeze, and the fact that it uses turtles.

There are several versions of the program, including the standard issue MicroWorlds Pro, the science-focused MicroWorlds EX, and my personal favorite just for the coolness factor, MicroWorlds EX Robotics, which is used to program LEGO robots. Most of these are expensive — see if you can find an abandonware copy of MicroWorlds 2.0. For some inexplicable reason, it performs slightly worse under Windows XP than other versions, but not enough to actually impede using it. The Mac version is different enough that I can't honestly recommend it, having not had enough experience. (I've spend more time at work with the program than at home.)

I’ve seen MicroWorlds used to make basic AI programs, complex randomly-generated platformers, a program that converts ASCII text to colorized pixels and can export and import bitmaps (a favorite of mine), any data structure you could make in LISP, and a whole lot more. The next time you think about picking up a wacky fun programming language, consider MicroWorlds.

A brief summary of why MicroWorlds rules:

  1. It's procedural.

    Just like in any good procedural language, functions can be defined. Just like they should, they can have inputs and output. This may sound like a given, but it’s possible to write MicroWorlds programs that run just fine and use no variables of less than global scope (although it does have a variety of scoping possibilities, including global variables that are saved between program sessions). Seven-year-olds are capable of many things, but understanding the niceties of scope isn’t always one of them.

  2. It can do list processing.

    I was shocked at first to discover that MicroWorlds has almost all of the list-processing primitives that it should to be a miniature LISP or Scheme. It has versions of car (first), cdr (butfirst), cons (fput), and a whole bunch of others, including some string-processing functions that basic LISP lacks.

  3. It's object oriented.

    The turtles in MicroWorlds basically count as objects. They have a number of class variables, and new ones can be defined at any point. All of the turtles' properties (position, orientation, color, etc) are controlled by public variables within the turtle.

  4. It's designed for Web embedding.

    Possibly the coolest part about MicroWorlds is that after you've made your silly, highly graphical game (or any other project), you can embed it in a website and other people can come and play it, as long as they have the plugin (which is available for free).

  5. It's easy to learn.

    This is why MicroWorlds was made. This language is ridiculously easy to learn. I've taught six-year-olds to use it, and anybody who works with that age group will testify that they're not the most programming-prone group of youngsters you'll encounter. Because the language was designed with education in mind, everything is in (relatively) plain English and doesn't have that "What the hell is this jargon?" aspect of other programming languages (which is more readable — contents of the address register, or first? void walk(), or to walk?). Any one of you could learn LOGO in about half an hour.

  6. MicroWorlds is the coolest.

    Put this all together, and add in the fact that LCSI makes a version that can control robots, and you have one nifty programming language. Give it a try.

Log in or register to write something here or to contact authors.