Roadmap
From Reia
Contents |
Reia 0.1: Complete Feature Parity with Erlang
The original implementation of Reia never reached feature parity with Erlang. There were various parts of Erlang that were missing, both syntactically and semantically. This is bad.
The new Reia will focus on creating a minimalistic, lightweight wrapper which provides a largely Ruby-like syntax for developing applications on the Erlang VM. The initial goal is not to add new features with complex implementations, but instead keep things as simple and as close to Erlang as possible.
By keeping the semantics of the core language closer to Erlang, the implementation is simplified. We can avoid problems down the road which might arise from a semantic gap between Reia and Erlang. Interfacing between Reia and Erlang is greatly simplified, as no translation layer is needed. Core Reia is becoming a new syntax for Erlang itself.
One of the biggest complaints about Erlang is its syntax. The new core Reia provides an alternative syntax, closer to Ruby, which might be appreciated in communities where Erlang has had trouble taking root.
Another one of the biggest complaints about Erlang is single assignment. If destructive assignment was one of your favorite features of Reia, don't worry, it's not going away. Core Reia will continue to feature destructive assignment. Destructive assignment is easily added without major changes to the core semantics of Erlang.
This milestone will also introduce a mechanism for user-defined types, which will take the form of immutable objects. Reia's core types will all be implemented as immutable objects.
This milestone will most certainly include wrapping up the concurrency primitives of Erlang, namely the *spawn*, *receive*, and *link*/*unlink* operations.
Reia 0.2 - 0.x: Testing and Debugging
After Reia attains complete feature parity with Erlang: it's feature freeze time!
Forget about syntactic sugar. Forget about concurrent objects. Those are unimportant in the light of language stability.
The 0.x releases will focus on developing a complete test suite for all core language features written in Reia itself.
Reia 1.0: Make it Rock Solid
Reia 1.0 will be released when it is fully tested and ready for production use. This version will *only* feature an alternative syntax for Erlang, not any of the novel features which differentiate Reia from Erlang. Aside from destructive assignment, the semantic gap between Reia and Erlang will remain small, and hopefully easy to debug.
Reia 1.1: Sugar
This version will focus on adding syntactic sugar to the language. Some of the features to be added: late binding, sugar for core functions, default arguments, and potentially keyword arguments.
Various imperative features (such as for/while) loops may also be included in this milestone.
Reia 1.2: Speed
After all of the core language features of Reia are in place, it's time to focus on optimization. This may include rewriting certain self-hosted parts of the language in Erlang to improve performance. This version will also focus on developing a comprehensive benchmark suite so the performance of the language can be empirically evaluated and tuned.
Reia 2.0: Concurrent Object Model
Concurrent objects are to be Reia's crowning achievement. The end goal is to wrap up Erlang's concurrency model in a way which is easily usable by programmers familiar with OOP, particularly in languages like Ruby and Python.
There are many considerations to be made in creating concurrent objects. The previous implementation of Reia implemented them somewhat haphazardly, to the point that they worked but had many caveats. This milestone will focus on creating a rock-solid concurrent object model on top of Erlang's underlying concurrency primitives.
Apologies if this was the main feature you wanted out of Reia, but it is by far the hardest to implement and the one which needs the greatest consideration and debate.
Then What?
Have any ideas for where you'd like Reia to go after 2.0? Post them in the discussion section.
