• support for shared object and message passing inter-process communication paradigms;
• 100% race-condition free (and other safety issues);
  
• automatic synchronization of shared and remote objects;
• support for the three required aspects of object synchronization: internal, conditional and external;
• automatic realization of many synchronization schemes: (exclusion) Monitors, Read-Write Exclusion, Read-Write Concurrent (one writer limit), Copy-on-Write, Object Transactions, exclusion and concurrent mixed schemes;
• although currently external synchronization of shared objects is restricted to exclusion locks (automatic realizations of transactional schemes will hopefully appear in the future, though probably in the context of another base language [Java]), such limitation does not restrict internal synchronization schemes due to one of my PhD proposals of using a group exclusion scheme to integrate both schemes (both compatible with automatic support for conditional synchronization).  So it is perfectly possible to have a working shared object with a transactional internal synchronization, combined with an external exclusion lock (mutex) scheme (meaning that an unbound number of processors can concurrently access the shared object, if no external access is active);
  
• another of my thesis proposals was the automatic expression of conditional and external synchronization of shared objects. The former through the presence of concurrent assertions (though a more restrict application of this idea can also be traced to the previous SCOOP proposal of separate preconditions), and the latter through the meaning of structured code selection mechanisms (conditionals, routines, ...);
• since the synchronization is automatically implemented by the compiler, a sequential program can be easily converted to a concurrent one:

The following example sequential code (of several working processors [threads] that sequentially draw different signals):

Is easily transformed to a concurrent program (in which all signal drawing takes place concurrently):

Please note that in red are the only changes the programmer was required to do!
A sequential class (RESULT_DATA), is immediately reusable as a shared object (all is required is a proper shared type annotation). 

Miguel Oliveira e Silva, «Metodologias e Mecanismos para Linguagens de Programação Concorrente Orientadas por Objectos» (Methodologies and Mechanisms for Concurrent Object-Oriented Languages), Ph.D thesis, University of Aveiro, Portugal, 2007. [PDF]

	MP-Eiffel prototype compiler (version alpha0): To install is enough (in Linux) to copy to following five files to a new directory and execute the command install-all.sh (it is necessary that csh, X11 and Curses  libraries are installed in Linux).  Note that this compiler was made only as a proof of concept for my PhD's proposals, so it is still in a very preliminary (and crude) state (hence its alpha0 status). mp-eiffel_alpha0.tgz INSTALL-ALL.txt install-all.sh thread-safe-se_beta5.tgz se-0.74.tgz
	lockfree-testing.tgz: This package contains the tests (always in Linux) done towards automatic realization of lock-free synchronization schemes of shared objects.
	Thread-safe SmallEiffel