SALSA 2.0.3 "salsa_lite" (11/10/2009)
- Fixed bug of addressbook example.

SALSA 2.0.2 "salsa_lite" (11/08/2009)
- Fixed bug of addressbook example.

SALSA 2.0.1 "salsa_lite" (11/04/2009)
- Updated some usages in examples

SALSA 2.0 "salsa lite" (10/22/2007)

--SALSA 2.0 can be compiled with garbage collection:
	java salsa_lite.core.compiler.SalsaCompiler <files.salsa>
  or without garbage collection:
	java -Dnogc salsa_lite.core.compiler.SalsaCompiler <files.salsa>

--There are new parameters which can be specified when running a theater:
	-Dlocal	will start the program up only using local services (from the salsa_lite/local) package, and not start up any
		sockets,etc.

	-Dnstages determines the size of the thread pool (number of threads being used by the program).  each theater has N
		stages, which perform message invocation on actors in salsa_lite, which are now only objects, not threads
		themselves. this provides significant improvement in performance and memory overhead

	-Dport specifies the port the reception service will listen on (if the theater/program is not run with -Dlocal)

	-Dtsthreads specifies the number of transport service threads that will be created to send messages remotely
		(again only if -Dlocal is not specified).

	-Dnidgens specifies the number of id generators salsa_lite uses to create unique message and actor ids.  in the previous
		version of salsa (1.1.2), there was a single synchronized and static method call that was used to create message
		and actor ids - so even if threads were running concurrently - they would still have to call this method
		sequentially! the new setup allows for unique ids to be generated concurrently which really allows for a lot more
		scalability and performance increase on multi-processor/core machines.

--Currently, in salsa_lite there are three implemented runtime packages:
	salsa_lite/local
	salsa_lite/local_gc
	salsa_lite/wwc
	salsa_lite/wwc_gc is currently under development

	the local package doesn't allow any remote communication, while the wwc package contains a theater, and the naming,
	reception and transport services.

	You'll notice that when salsa_lite compiles an actor, it creates two files: <ActorName>.java and <ActorName>State.java
	instead of a single encapsulated file.

	Additionally, each actor state has an invoke method which performs message invocation - in this there's no reflection,
	the compiler determines what messages can be invoked and creates the invoke method.  This also is a big improvement in
	performance because it doesn't use any reflection and is also a big improvement in meory usage because instead of each
	actor having a hashtable of all the methods that could be invoked on it, there is just this invoke method.

	Also the java code for message passing has been cleaned up quite a bit, it now looks like (for example):
		// token y = fib2<-compute()
		{
		       Message __message = new Message( self, fib2, "compute", new Object[]{  }, null, y);
			__messages.add( __message );
		}

	Also, making a remote reference is different in salsa_lite, previously this was done like:
		<ActorType> a = (<ActorType>)ActorType.getReferenceByName(uan);
	now this looks like:
		<ActorType> a = reference <ActorType>(uan);
	or
		<ActorType> a = reference <ActorType>(identifier, host, port);
	UALs are no longer explicitly used by the programmer, only UANs, or an identifier, host and port.


	In general, message passing works as follows, the actor creates new messages while processing a message, after the method
	has completed, and all the tokens have been updated, the state that the actor is located at will send the messages (this
	is done in the salsa_lite.wwc.stage.StageActor.java class or salsa_lite.local.StageActor.java class). This calls the
	StageService.sendMessageFromLocal method, which determines if the message is for a local actor or a remote actor.  In
	general, there are 4 methods that a stage has to implement:
		handleSendFromLocal - this handles a message send from another stage at this theater
		handleSendFromRemote - this handles a message send from a remote theater
		handleActorMigration - this handles an incoming actor from migration
		handleActorCreation - this handles actors created at this theater (which may need to be created remotely)

	salsa_lite.local.StageActor only implements handleSendFromlocal and handleActorCreation because it doesn't do any remote
		communication.

	The StageService determines which stage a message or actor is at (or should go to) using simple modulo math:  each actor
	has a unique id, so the stage the actor is at is just the uniqueid (or hashcode) % nstages.  The nice thing about this is it
	doens't require synchronization so it can be done concurrently (where in the previous version of salsa, determining what message
	went to what actor was done in the NamingService in a synchronized method call).

	Another interesting thing to note is that salsa_lite basically practices what we preach - instead of using threads with
	lots of different synchronized areas, the StageActors, Reception and Transport services are set up as actors.  Each
	consists of threads with put methods, and repeatedly process whatever has been put in their mailboxes.  Between this and
	using modulo to calculate the target thread/stage for messages and actors, this allows for there to no single points of
	synchronization which make the previous version of salsa mostly sequential as opposed to concurrent. This also basically
	removes the chance for race conditions - the only synchronization points are the put methods.

SALSA 1.1.6 (9/27/2021)
- Fixed bug of name server staying in an active infinite loop upon client disconnections. 

SALSA 1.1.5 (7/18/2011)
- Support -Dnetif=<NetworkInterface> option for Theater, RTheater, and WWCNamingServer.
    * Use the address bound to the interface eth0 when listening theater requests.
      java -Dnetif=eth0 wwc.messaging.Theater
    * Use the address bound to the interface wlan0 when listening naming requests.
      java -Dnetif=wlan0 wwc.naming.WWCNamingServer
    * Available network interfaces can be confirmed with 'ifconfig' command for Unix-based systems and 'ipconfig' for Windows.

SALSA 1.1.4 (6/11/2010)
- Fixed bug of possible deadlock situations caused by background garbage-collection message delivery. 

SALSA 1.1.2 (2/17/2007)
- Refactored salsa.language.UniversalActor$State.migrate () methods to be cleaner.
- Removed unnecessary visualization hooks.

SALSA 1.1.1 (11/6/2006)
- Fixed bug of early termination of the dynamically created theater.
- Fixed bug of UAN and UAL resolution.

SALSA 1.1.0 (9/25/2006)
- Support "String standardInput<-readLine()" 
- Support "migrate(String hostname)". 
	self<-migrate("rmsp://remote.cs.rpi.edu:4040");
- Support "delayWaitfor" property.
	self<-message():delayWaitfor(time_to_wait_in_ms,token1,token2,...);
- Support "UAN generateUAN(String nameserver)", which automatically generates a UAN. 
	UAN new_uan=this.generateUAN("namesvc.cs.rpi.edu:3030");
- Temporary networking fault tolerance.
- No more join directors.
- Prototype of active garbage collection in a sandbox environment.

SALSA 1.0.2 (10/24/2005)
- Fixed bug of compiling the if-else statement.
- Fixed bug of "delay property" of messages.

SALSA 1.0.1 (4/21/2005)
- Fixed bug of compiling "((Type) Name) PrimarySuffix"  

SALSA 1.0 (3/29/2005)
- Support local and distributed garbage collection.
	* -Dgcverbose to observe GC behavior
	* -Dnogc for running a theater without local garbage collection
	* -Dnodie to make a theater alive running a stand-alone salsa program.
	* Running distributed garbage collection service once by
	    java gc.serverGC.SServerPRID -1 <host1> <host2> ......
	  Running it every n seconds:
            java gc.serverGC.SServerPRID n <host1> <host2> ......
	  Since it is now poorly implemented, n must be large enough.
- Support different types of actors:
	* Service: An actor never dies if it implements ActorService
	* Normal actor: An actor gets collected if no other actor knows it. 
- Call (pass) by reference for actors and Call (pass) by value for other types.
- Fixed bug of inconsistency caused by migration to the same host.
- Fixed bug of join continuation with no messages inside it.
- Fixed bug of join continuation with currentContinuation.

SALSA 0.7.1 (4/19/2004)
- Theaters would always be created at port 4040, even when created on the fly.  Theaters now
  only start at a given port if it is specified at command line, or through the -Dport=<port>
  system property.

SALSA 0.7.0 (03/22/2004)
- The bind method was deprectated. Actors are now created using the new construct: new A(...) at (uan,ual)
- Support Remote actors creation
- re-implementation of actors as interfaces 
- To get actor references two static methods are provided:
	* getReferenceByName(new UAN("uan string")) or getReferenceByName("uan string")
	* getReferenceByLocation(new UAL("ual string")) or getReferenceByLocation("ual string")
- Major changes to the messaging services to support a pool of sockets

SALSA 0.6.5 (11/30/2003)
- Fixed bug that caused concurrent actor migrations to corrupt socket streams.

SALSA 0.6.4 (11/30/2003)
- Internal release.

SALSA 0.6.3 (11/19/2003)
- Fixed bug that caused premature JVM termination.

SALSA 0.6.2 (11/18/2003)
- Added access control in SALSA.  An actor's methods may be private or protected.
- Messages may be sent with the following properties (more to come in 0.7.0), ie:
  - actor<-message(arguments) : priority;
    When message reaches actor, it will be placed at the front of the actors mailbox, instead of the end.

  - actor<-message(arguments) : delay( new Integer ( milliseconds ) );
    Message will not be sent until milliseconds has elasped. This will not block the actor from finishing
    processing its current method.

SALSA 0.6.1 (10/10/2003)
- Support of persistent sockets.

SALSA 0.6.0 (9/11/2003)
Changes in the SALSA grammar:
- Support of Named tokens
- Support of Sequential tokens
- Join continuations have been changed to Join blocks

SALSA 0.5.5 (7/17/2003)
- Fixed a bug with the references of standardOutput and standardError. They get unpdated correctly now when migration happens.
- The bug of duplicate message sending has been fixed.

SALSA 0.5.4 (5/9/2003)
- Actors may now be sent die() and setPriority(int priority) messages:
  - An actor sent a die() message will be terminated after its mailbox becomes empty.
  - An actor sent a setPriority(int priority) message will process messages with the given priority.
    The java constants MIN_PRIORITY and MAX_PRIORITY may be used, 
    but first must be classed as an Integer: actor<-setPriority(new Integer(MIN_PRIORITY));

SALSA 0.5.3 (4/16/2003)
- Fixed a bug in getLocation() where the protocol returned was http.
  Now it returns the appropriate protocol (rmsp or uan).

SALSA 0.5.2 (04/10/2003)
- Added a public getLocation() method to URL and UAL. 
- Allows a user to easily get the address of a theater or nameserver, so an identifier can be appended to it for easy UAN 
  and UAL creation.

SALSA 0.5.1 (04/09/2003)
- Changes made to get reference by name and get reference by location.
  These are now called as constructors:
  - a.getReferenceByName(UAN uan) is now <ActorType> a = new <ActorType>(UAN)
  - a.getReferenceByLocation(UAL ual)  is now <ActorType> a = new <ActorType>(UAL) 
- Major improvements to anonymous actor handling and on-the-fly theater creation. 
  Actors may be bound to their current anonymous theater by bind(UAN).

SALSA 0.5.0 (03/24/2003)
- First class continuation support.
- Stand-alone theater startup. 
- ServiceFactory for pluggable services. 
- Major internal changes. 

SALSA 0.4.1 (10/20/2002)
- getReferenceByName and getReferenceByLocation bug fix.
- Thread termination bug fixes.
- Small internal changes.

SALSA 0.4 (8/25/2002)
- Runtime memory requirements minimized.
- Internal reorganization.
- Compiler & Runtime bug fixes.
- Multi-threaded theater.

SALSA 0.3.3
- Legacy Code.