[e-lang] Introducing Emily, a High Performance Language For Secure Cooperation

[marcs]

For over a year, a festering irritation has been growing in my mind because
all the object capability languages we are working on are slow. Even if all
our dreams were fulfilled this afternoon, with Joe-E and E on Common Lisp
and Oz-E and Mont-E, none can compete for performance against C++. Alas,
there are important applications for which you really need the performance
of C++. The particular example that has driven me to distraction is
rendering engines, like gecko in FireFox, which must run at lightspeed or
they will harm the user experience. Such engines must be fast as fast can
be; yet they must also be secure, otherwise you are simply leaving a breach
the size of Texas in the middle of your system.

markm recently compelled me to learn an ML-family language. I chose OCaml,
which has benchmark performance properties similar to C++. In the process of
learning OCaml, I realized that the language was so clean that it would only
take a few weeks to tweak the libraries and the syntax to create an
object-capability language based on it. Emily is the result. 

Find the pdf of the powerpoint presentation+notes at 
http://www.skyhunter.com/marcs/emily.pdf

As markm and alan keep pointing out to me, having gotten Emily 80% finished,
I only have the other 80% to finish before there is a version 1.0. I think
they are only kinda correct, however: if someone actually needs a
high-performance object-capability language today, you can start using Emily
as it exists right now, and it will immediately be better than anything else
you could do. As a worst case, you would have all the performance and memory
safety of OCaml, which is a better blend for some applications than anything
else I have seen available today.

Emily is an object-cap language, but it is not a promise pipeline language.
Promise pipelining will be must harder to implement for Emily. I would call
that a version 2 feature, however :-)

If anyone would like to actually use Emily, email me. I fear it is not
documented well enough for anyone to use without some personal help :-)

I can already hear the first question: are OCaml and Emily funky weird
looking languages like Scheme? Is it impossible for an imperative programmer
from the C/Java tradition to learn? There is good news and bad news. Good
news: The language itself embraces imperative programming as an important
part of life. Bad news: the people who wrote all the standard OCaml
documentation look down their noses at imperative programmers, and demand
that the reader embrace functional style programming before leaving the
introduction and digging into the first chapter. If it turns out that there
would be some serious interest in Emily, I can see the following book
showing up on my web site: "Emily in a Walnut for the Java and C Programmer"
:-) The second example in the book would be the standard factorial program
example, but done with iteration rather than recursion :-) 

--marcs