In our research, we have developed and are developing several software systems. A portion of these systems, those deemed most useful anyways, are to be released as open-source software (although it will take some more time to get that part ready).
This is a development platform aimed at prototyping distributed algorithms and as a support for teaching such algorithms. The platform is written in the Scala programming language and allows to write distributed algorithms in a very concise yet easily readable way.
ScalaNeko is based on the Neko toolkit; a project originally developed at EPFL by Péter Urbán, Xavier Défago, and several other contributors. The Neko toolkit was written in the Java language and allowed, without changing its code, to execute a distributed program either in a simulated network or on a real network. The purpose was to support the lifecycle of a distributed algorithm from design to performance evaluation, under the premise that a change in writing style between simulation and execution would be an undesirable factor affecting performance measurements.
While ScalaNeko does not retain the ability to execute on a real network (i.e., it supports simulation-only), its purpose is exclusively aimed at teaching. With this in mind, great efforts where directed at simplifying the way distributed algorithms would be expressed in that model. ScalaNeko was successfully used as programming support for Xavier Défago's lectures on distributed systems at JAIST.
The purpose of Ocelot is to build upon the lessons learned from both Neko and ScalaNeko, and provide a development platform that would support teaching, prototyping, and performance evaluation.
Whereas ScalaNeko has been written in a different language, it retain much of the Neko internal. In particular, the processes of the distributed system are all modeled as Java threads. As a result, these two platforms can support about the simulation of about 1000–2000 processes on a regular laptop computer. In contrast, Ocelot is a redesign of the execution engine such that concurrency is handled by actors and futures instead of Java threads. The intent is to provide a much lighter-weight execution engine that would be able to simulate the execution of at least a million processes on the same kind of laptop.
In addition, Ocelot is designed to provide support for a syntax simpler than ScalaNeko's, arbitrary network topologies, verifiable algorithms composition, mobile networks, and visualization tools. The first two items are already implemented and will be included from the first release. The other items are still under design and it will take more time until they can be deemed stable enough.