In summary:
Reactive: code executes in reactions to events
Synchronous: reactions run to completion, i.e., there's no implicit preemption or real parallelism (this avoids explicit synchronization: locks, queues, etc)
Structured: programs use structured control mechanisms, such as "await" (to suspend a line of execution), and "par" (to combine multiple awaiting lines of execution)
Structured programming avoids deep nesting of callbacks letting you write programs in direct/sequential style. In addition, when a line of execution is aborted, all allocated resources are safely released.
In comparison to FRP/dataflow, it is more imperative supporting sequences/loops/conditionals/parallels. The notion of (multiple) program counter is explicit. Also, everything is lexically scoped, there's no GC involved.
In comparison to promises/futures, it provides lexical parallel constructs, allowing the branches to share local variables and, more importantly, supporting safe abortion of code (with the "par/or").
Does this mean a program will hang if e.g. disk or network access takes too long?
Neither truly does, of course, but the idea is that for the vast majority of situations where either type of language is used, that's a good enough approximation, letting you vastly simplify the problem that you're solving.
Also, at some point in the code (e.g., after you include your libraries), one can disable these calls with a directive.
But typically, one will use bindings for asynchronous libraries, such as libuv (https://github.com/fsantanna/ceu-libuv).
That's pretty cool!
- LPeg support [1]. PEGs are great!
- The creator of Lua was my advisor since undergrad. :) (Which means that I program in Lua for a long time...)
The compiler is slow, but not the final binary.
We wrote a paper [1] that compares flash,RAM,CPU usage from Céu vs hand-written event-driven code in C. The differences are negligible.
- C is more portable
- C is easier to generate
We also take the syntax from Pascal/Lua and the basic types and expressions from C (due to source compatibility).
May I ask you if you have some favorite references/papers about the subject ?
- Gérard Berry: "Real time programming: Special purpose or general purpose languages"
For the semantics, I like this paper focusing on abortion (for me, the most expressive construct of synchronous languages):
- Gérard Berry: "Preemption in Concurrent Systems"
There's also a well-known survey:
- Albert Benveniste: "The synchronous languages 12 years later"
This one is about bridging the gap between synchronous and asynchronous, something like Esterel+CSP:
- Gérard Berry: "Communicating reactive processes"
For a modern take (besides Céu), check ReactiveML:
- Louis Mandel: "ReactiveML: a reactive extension to ML"
You can also search for papers from professors Stephen A. Edwards and Reinhard von Hanxleden which still work actively on the subject.
http://www.college-de-france.fr/site/gerard-berry/course-201...
http://www.college-de-france.fr/site/gerard-berry/course-201...
(In 2014 - 2016 he moved on to program proofs, which may also interest some of you.)
Although Céu is about 5 years now, this is the first time I post to "Show HN".
In this new version, we are trying to surpass the academic fences with a more polished work (docs, build, etc).
All feedback is welcome.
Francisco