
Meme (Multitasking Extensible Messaging Environment): Multiuser Forth VR (1994) - DonHopkins
https://web.archive.org/web/19990125100147/http://www.immersive.com/
======
sedachv
I remember reading about Marc de Groot (author of this software) in Douglas
Rushkoff's _Cyberia_. Unfortunately he passed away in 2004.

[https://www.sfgate.com/news/article/DE-GROOT-
Marc-2732584.ph...](https://www.sfgate.com/news/article/DE-GROOT-
Marc-2732584.php)

~~~
stallmanite
Likewise. Stumbled upon a copy of Cyberia as a 15 year old and it made a huge
impression.

------
DonHopkins
Interesting criticism from David Cake and Gavin Bell. Fortunately now we
benefit from nice IDEs and other tools for editing popular programming
languages (but none I know of for FORTH or PostScript, but there are lots of
applications that edit or write out JavaScript and JSON and WebAssembly, even
built into every browser ;).

Before JavaScript was released on December 4, 1995, there actually was some
disagreement about not just about which language to use, but whether a browser
should include a Turing-complete programming language at all. Sun was pushing
TCL as a contender, then RMS issued his fatwa against it, and Sun switched
over to pushing Java (not because of RMS though ;).

[http://1997.webhistory.org/www.lists/www-
vrml.1994/0268.html](http://1997.webhistory.org/www.lists/www-
vrml.1994/0268.html)

    
    
        From: "Gavin Bell" <%20(fwd)"gavin@krypton.engr.sgi.com>
        Date: Fri, 24 Jun 1994 09:41:24 -0700
        To: %20(fwd)"www-vrml@wired.com
        Subject: Re: Meme
    
        >Marc de Groot wrote:
        >>Meme has certain features that I would want to see in any specification for
        >>VRML. In particular, Meme allows the world designer to specify platform-
        >>independent executable code for the object's behavior. Without this
        >>ability, objects have relatively rigid, uninteresting behavior.
    
        David Cake replied:
        > Basically VRML browsers need to be basically include much of the function
        > of a simple interpretive language, and hopefully both a basically object
        > oriented one (personal preference, I guess), and one that is not too
        > verbose (for efficient use of low bandwidth). In this it would function
        > like most existing cross platform packages of various kinds (many database
        > packages, for example).
    
        [Gavin Bell replied:]
    
        One of the things I really like about HTML is that it is reasonably
        easy to write an editor that allows you to read in and then modify any
        HTML file.
    
        One of the things I really hate about PostScript is that is is really
        hard to write an editor that can edit an arbitrary PostScript file.
        Meme strikes me as more PostScript-like than HTML-like; it looks like
        it would be easy to write applications that wrote out Meme files, but
        it looks very difficult to write applications that provide a
        user-friendly interface for editing Meme files.

~~~
DonHopkins
"Why you should not use Tcl": Richard Stallman kicks off The Great TCL War.

[https://vanderburg.org/old_pages/Tcl/war/](https://vanderburg.org/old_pages/Tcl/war/)

[https://vanderburg.org/old_pages/Tcl/war/0000.html](https://vanderburg.org/old_pages/Tcl/war/0000.html)

Richard Stallman (rms@gnu.ai.mit.edu)

Fri, 23 Sep 94 19:14:52 -0400

Why you should not use Tcl. Richard Stallman, GNU Project.

As interest builds in extensible application programs and tools, and some
programmers are tempted to use Tcl, we should not forget the lessons learned
from the first widely used extensible text editor--Emacs.

The principal lesson of Emacs is that a language for extensions should not be
a mere "extension language". It should be a real programming language,
designed for writing and maintaining substantial programs. Because people will
want to do that!

Extensions are often large, complex programs in their own right, and the
people who write them deserve the same facilities that other programmers rely
on.

The first Emacs used a string-processing language, TECO, which was inadequate.
We made it serve, but it kept getting in our way. It made maintenance harder,
and it made extensions harder to write. Later Emacs implementations have used
more powerful languages because implementors learned from the problems of the
first one.

Another lesson from Emacs is that the way to make sure an extension facility
is really flexible is to use it to write a large portion of the ordinary
released system. If you try to do that with Tcl, you will encounter its
limitations.

Tcl was not designed to be a serious programming language. It was designed to
be a "scripting language", on the assumption that a "scripting language" need
not try to be a real programming language. So Tcl doesn't have the
capabilities of one. It lacks arrays; it lacks structures from which you can
make linked lists. It fakes having numbers, which works, but has to be slow.
Tcl is ok for writing small programs, but when you push it beyond that, it
becomes insufficient.

Tcl has a peculiar syntax that appeals to hackers because of its simplicity.
But Tcl syntax seems strange to most users. If Tcl does become the "standard
scripting language", users will curse it for years--the way people curse
Fortran, MSDOS, Unix shell syntax, and other de facto standards they feel
stuck with.

For these reasons, the GNU project is not going to use Tcl in GNU software.
Instead we want to provide two languages, similar in semantics but with
different syntaxes. One will be Lisp-like, and one will have a more
traditional algebraic syntax. Both will provide useful data types such as
structures and arrays. The former will provide a simple syntax that hackers
like; the latter will offer non-hackers a syntax that they are more
comfortable with.

Some people plan to use Tcl because they want to use Tk. Thankfully, it is
possible to use Tk without Tcl. A Scheme interpreter called STk is already
available. Please, if you want to use Tk, use it with STk, not with Tcl. One
place to get STk is from ftp.cs.indiana.edu:pub/scheme-
repository/imp/STk-2.1.tar.Z

~~~
kick
Stallman was really seeing with clarity back then. It's kind of crazy that he
doesn't get credit for the things he _did_ unambiguously get right.

~~~
hjek
When considering how much of the web currently depends on non-free JavaScript,
perhaps in hindsight it would have been better in terms of freedom to have
gone with a less capable language?

~~~
kick
Until Javascript became fully-capable, Java and Flash applets ruled the WWW.

------
DonHopkins
I forgot to mention: this was from 1994!

And for reference: This was more than a year before JavaScript was released on
December 4, 1995. And a few months before RMS started The Great TCL War on
September 23, 1994. The title of Official Scripting Language of the Web was
still up for grabs.

[https://news.ycombinator.com/item?id=12025218](https://news.ycombinator.com/item?id=12025218)

[https://vanderburg.org/old_pages/Tcl/war/](https://vanderburg.org/old_pages/Tcl/war/)

I dug up this treasure from last century by looking up urls from old saved
favorite emails with the Internet Archive:

Marc de Groot made a brilliant multi-user networked VR system programmed in
multitasking FORTH, called “MEME"!

Here's his announcement that Brian Behlendorf forwarded to the www-vrml
mailing list:

[http://1997.webhistory.org/www.lists/www-
vrml.1994/0255.html](http://1997.webhistory.org/www.lists/www-
vrml.1994/0255.html)

    
    
        From: marc@kg6kf.ampr.org (Marc de Groot - KG6KF)
        Subject: Meme
        To: www-vrml@wired.com
        Date: Wed, 22 Jun 94 11:26:25 PDT
    
        Hello. It's about time I introduced myself. I'm Marc de Groot, the founder
        of Immersive Systems, Inc. in San Francisco.
    
        I started ISI to sell Meme, which is a virtual world development
        system. Meme is intended to create a single shared virtual universe on
        the net.
    
        ISI released the alpha version of Meme last month.
    
        Meme stands for Multitasking Extensible Messaging Environment. Meme started
        life as a programming language. Some "OS-level services" were added to the
        system, and finally the messaging mechanism was added to allow virtual objects
        to communicate. At this point, Meme is evolving into a communications
        protocol.
    
        I heartily agree with the statements that have been made on this mailing
        list about net software: make something proprietary, and the net hackers will
        write a free replacement which everyone will use.
    
        I intended to make the protocol public later this year, after ISI had fulfilled
        higher priority obligations, however the establishment of this list has
        prompted me to put some preliminary information on the net at this time.
        I have put up a WWW page for Immersive Systems. The URL is
    
        http://remarque.berkeley.edu/~marc/home.html
    
        >From the home page, you can read an overview of Meme, look at the programming
        manual, and download a demo world to try on your own PC.
    
        Meme has certain features that I would want to see in any specification for
        VRML. In particular, Meme allows the world designer to specify platform-
        independent executable code for the object's behavior. Without this
        ability, objects have relatively rigid, uninteresting behavior.
    
        That platform-independent code needs to load over the net with a minimum
        of overhead, and needs to execute efficiently. Meme satisfies both of
        these requirements.
    
        That completes my thoughts for now. I will post in the future, as time
        permits.
    
        Marc de Groot
        Immersive Systems, Inc.
        immersive@kg6kf.ampr.org

------
DonHopkins
Immersive Systems Inc:

[https://web.archive.org/web/19990125100147/http://www.immers...](https://web.archive.org/web/19990125100147/http://www.immersive.com/)

[I'll quote some of the page here for people with sensitive eyes]

>Meme tm: Real VR for the Net!

>"A brilliant idea..." -Andries van Dam

>Meme tm was designed from the ground up for multi-user networked virtual
worlds.

>Meme tm is a platform-independent standard for networked virtual reality.

>High performance. Self-contained. FAST real-time 3D. Easily customized for
use with head-mounted displays, data gloves, and other VR peripherals.

>Meme tm is designed so it can run on memory-limited machines such as settop
boxes and game consoles. Meme tm can also take full advantage of the most
advanced graphics hardware.

>"This is what VRML 3.0 hopes to be." -Tony Parisi, VRML co-inventor

>Meme tm enables the construction of virtual worlds on the Internet.

>Fully interactive. Inhabitable by many users. Quickly constructed. Complex
lifelike behavior. Easy to deploy.

>"Marc de Groot is a brilliant programmer." -Mark Pesce, VRML co-inventor

>Highly efficient virtual machine used by NASA and the aerospace industry.
Will run on any system that has a 3D rendering engine. Portable to platforms
with primitive or non-existent operating systems. Really works identically on
all platforms. Runs in less than 500 kilobytes of memory. Upwards of a million
context switches per second on current-generation processors.

>"How the hell did you do that?" -unknown attendee, Web Interactive '96

[Click through for more praise for Meme, colorful images, and awesome 1994 web
site design!]

An Overview of Meme:

[https://web.archive.org/web/19990504200616/http://www.immers...](https://web.archive.org/web/19990504200616/http://www.immersive.com/overview.htm)

>Meme TM--The Multitasking Extensible Messaging Environment Meme TM is a
software package for the development of virtual world applications.

>Worlds built with Meme TM can be inhabited by multiple users who are
connected to a computer network. Meme TM virtual worlds distinguish themselves
by providing rich object behavior, unlike menu-driven systems that offer a
fixed set of choices.

>Meme TM is designed to be interoperable, that is, Meme TM worlds and objects
will behave identically on any computer running Meme TM, irrespective of
differences in the underlying hardware.

>Meme TM was conceived to enable the construction of a shared virtual universe
for everyone on the Internet.

>what kind of software package is Meme TM?

>Meme TM does not easily fit into a well-known category. It incorporates
elements of an operating system, an interactive development environment, and a
programming language.

>Meme TM is an operating system [...]

>Meme TM is an interactive development environment [...]

>Meme TM is a programming language [...]

Meme Development System for Windows Product Specification:

[https://web.archive.org/web/19990422114909/http://www.immers...](https://web.archive.org/web/19990422114909/http://www.immersive.com/mdswin.htm)

>Required hardware: PC, 80386 or better with math coprocessor, 8 MB RAM, VGA,
mouse, Ethernet or 10BaseT card or modem (for network connection.)

Meme Demos:

[https://web.archive.org/web/19990504193428/http://www.immers...](https://web.archive.org/web/19990504193428/http://www.immersive.com/memedemo.htm)

Meme Programming Guide:

[https://web.archive.org/web/19980110220614/http://www.immers...](https://web.archive.org/web/19980110220614/http://www.immersive.com/pgmguide.htm)

[It's totally programmable in FORTH! What more is there to say? ;) So here's
some code! ]

>Writing Meme TM code

>Writing code for use in a multi-user universe is an undertaking that requires
some sophistication. Often, the programmer wants to try out an idea quickly,
without concern for the demands of multi-user distributed programming.

>For instance, let's assume the programmer would like to spin a ball, all
alone, in the virtual world. Meme TM makes it easy to animate such a scene.
The following text is the actual code that implements a spinning ball, and is
very similar to the spinning ball demonstration on the demo page. The
backslash character (\\) is used to delimit a comment to end-of-line.

>The comments assume that each line is being typed by hand at Meme TM's
command prompt, with pauses between the lines to observe the effect on the
displayed scene.

    
    
        \ First we create an eyepoint with which we view the scene.
        \ The eyepoint is initially positioned at the origin, looking down the
        \ negative Z axis (away from the user).
        Eye: eyepoint
    
        \ Let's put the eyepoint at +20 on the Z axis.  This moves the camera
        \ away from the origin, towards the user.
        10e0 eyepoint z!
    
        \ We put a ball in the scene.  It is created at the origin.
        " sphere.rwx" Shape: ball
    
        \ Up until now, the display has remained blank.  To draw a single frame
        \ on the display, we execute the meme "render".
        render
    
        \ There is now a ball on the display.  Rather than type "render" each time
        \ we want to draw a frame, let's start a background task that redisplays the
        \ scene continuously.
    
        background r                    \ Define a new task called "r".
                begin                   \ Start of a looping structure
                        render          \ Draw one frame
                        pause           \ Switch to the next task
                again                   \ Loop forever
        ;                               \ End definition
    
        r wake                          \ Start execution of the rendering task.
    
        \ Let's define another background task to make the ball spin.
    
        background spin                 \ Define a new task called "spin".
                begin                   \ Start of a looping structure
                        1e0 ball yaw+!  \ Increment the yaw angle by one degree
                        pause           \ Switch to the next task
                again                   \ Loop forever
        ;                               \ End definition
    
        spin wake                       \ Start execution of the spinning task

~~~
fouc
Would be interesting to take this same codebase and increase the rendering
resolution since computers are so much more powerful 26 years later.

~~~
DonHopkins
I just found this!

[http://metatopia.sourceforge.net/](http://metatopia.sourceforge.net/)

