[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Swarm 2.0 Available

From: Marcus G. Daniels
Subject: Swarm 2.0 Available
Date: 29 Aug 1999 01:07:16 -0700
User-agent: Gnus/5.070084 (Pterodactyl Gnus v0.84) Emacs/20.4

To the collectively evolving,

The Swarm team at the Santa Fe Institute is pleased to announce
that Swarm 2.0 is ready.


The primary feature of Swarm 2.0 is support for the Java programming
language.  Swarm models may now be implemented using Objective C,
Java, or both.

The primary advantage of using Java to implement a model is practical:
Java is a mainstream language and there are polished development
tools, more books, and more libraries available for it than for
Objective C.

Technically, there are advantages and disadvantages to Java.
It is harder to compile an incorrect program in Java.  Values are typed
in Java, whereas in Objective C is common to leave values untyped,
relying on the runtime to redirect calls as appropriate.  New users of
Swarm may find that the stricter typing of Java helps to clarify
the boundaries between the different features of Swarm, and how the
pieces of a model need to fit together.  Traditionally, in Objective C
Swarm models, the consequences of coding mistakes have been delayed
until the last possible moment when miscoded agents do something
fatal and a core dump occurs or an exception is raised.

Some experienced users may also opt to use the Java layer in common
situations.  In principle, a statically typed language is easier for a
compiler to optimize than a dynamically typed language where there is
little or no fixed information about component behavior.  Freezing
stable agent components should, in the long run, result in models that
are more reliable and faster than leaving all components untyped (as
is common in Objective C Swarm models).  In the near term, the
performance of Objective C models will be faster than models
implemented in Java.  This is mainly because we do not yet support
tight integration with a native code Java compiler.  (We'll be working
on Java performance, as a function of user interest.)

However, dynamic typing and access to runtime metadata have proven to
be very useful for model prototyping.  Features in Swarm like probing
and runtime assembly of behavior (e.g. phases) come from the tradition
of dynamic languages -- we fully intend to keep these capabilities.
For example, the ability to inspect and perturb agents (either
manually or programatically) while they run is a capability we will
always preserve.

This first release of Java support for Swarm exposes a subset of the
Objective C Swarm interfaces in Java.  It is a subset for two reasons:
First of all, only type safe interfaces are revealed.  There are no
pointers.  Common Swarm tricks like coercion of integers to objects
(e.g. to serve as Map keys) are not possible with the Java Swarm
layer.  The only pointer type that is supported is the "const char *",
meaning "java.lang.String".

Secondly, we have deliberately hidden most of the `gui' interfaces.
It really makes more sense in Java to use its Swing GUI library and
the inspectors/editors that popular integrated development
environments (IDEs) provide for building Java GUI interfaces.
[However, for folks that are prepared to rebuild Swarm from source, it
is easy to reconfigure and get an interface to all the well-typed
parts of the Swarm gui features.]

Besides Java support and the usual array of bug fixes, Swarm 2.0 has
improved serialization capabilities, 64 bit portability, and across-the-board
support for shared libraries.  Objective C Windows users, in
particular, should observe much faster linking.  (See the `NEWS' on the
release page or in the distribution for the nitty gritty.)

Swarm 2.0 supports JDK 1.1, JDK 1.2, and Kaffe.  2.0 has been tested in
various JDK configurations on Debian 2, Redhat 6, Solaris 7, HPUX 9¹,
10, and 11, Irix 6.5, Digital Unix for Alpha, Windows 98 and NT 4.0.

The Windows version comes with DLLs for either Kaffe or JDK.  To use
the JDK version in a Windows Java IDE, ensure that `javaswarm.dll' is
visible in the PATH and `swarmjdk.jar' is a visible as a library to
your IDE (e.g. in CLASSPATH).  JBuilder3 is known to work and Visual Age
is known not to work.

Sans IDE, the scripts `javaswarm' and `javacswarm' can be used from
the command line (or Emacs/JDE) for running and compiling Java Swarm
things.  (We are distributing Kaffe as part of the stock development
kit because it has a compatible license to Swarm itself, and is a
public development software project just like Swarm.)

So far, we have just one demo application for Java: Mousetrap. 
(This should be remedied in the the next minor release of Swarm.)

To try Java mousetrap, use this sequence of commands:
  $ gzip -dc jmousetrap-2.0.tar.gz | tar xf -
  $ cd jmousetrap-2.0
  $ make
  $ javaswarm StartMousetrap

¹ Kaffe is required on HPUX 9 -- AFAIK there's no standard JDK
  distribution for HPUX9. 

reply via email to

[Prev in Thread] Current Thread [Next in Thread]