The Synchronous Blog

A blog about reactive programming languages.

Archive for the ‘News’ Category

Slides for “Dynamic Organisms in Céu” at the Strange Loop

with one comment

Here are the slides for my talk at Strange Loop’2014 in the Future of Programming Workshop.

Written by francisco

September 25, 2014 at 1:05 am

Posted in News

Tagged with , ,

REBLS’14 accepted paper: “Structured Reactive Programming with Céu”

leave a comment »

Our new paper, “Structured Reactive Programming with Céu”, will appear in the Workshop on Reactive and Event-based Languages & Systems (REBLS’14) at SPLASH.

REBLS succeeds REM as the new “reactive workshop” inside SPLASH.

The paper discusses our proposal for “organisms” as an abstraction mechanism for “Structured (Synchronous) Reactive Programming (SSRP)”. It is the textual version of the talk at the Strange Loop.

The preprint version of the paper can be downloaded here.


Written by francisco

September 25, 2014 at 12:58 am

Posted in News, Reactive Languages

Tagged with , , , ,

Céu at Future Programming Workshop (StrangeLoop and SPLASH)

leave a comment »

I’ll present the last advances in Céu at the Future Programming Workshop in two events:

I’m specially excited about the StrangeLoop event, as it will be the first non-academic demonstration of the language in a prestigious conference.

Here’s the abstract:

Francisco Sant’Anna “Dynamic Organisms in Céu”
We propose a new abstraction mechanism for a synchronous reactive programming language: Organisms reconcile objects and threads into a single concept. We enforce lexical scope for dynamic instances and also restrict the use of explicit references to organisms. This way, we can eliminate typical issues in dynamic allocation, such as memory leaks, danging pointers, and garbage collection.


Written by francisco

July 18, 2014 at 2:29 am

Céu v0.7

leave a comment »

The new version of Céu is released!

What’s new in v0.7:

  • Added support for functions and class methods (we relied on C for defining new functions).
  • Experimental support for interrupt service routines.
  • Experimental microkernel for Arduino.
  • Experimental `input/output´ requests.

Céu in a Box (CiB) is a Linux-based distribution that comes pre-installed with the Céu Programming Language environment:

The distribution contains the compiler together with bindings for the Arduino, TinyOS, and SDL platforms.

CiB is distributed as a single .ova file to be used with VirtualBox.

Written by francisco

April 3, 2014 at 5:30 pm

Céu on “Arduino Day”

with 2 comments

Last Saturday I gave a talk on the Arduino Day, “a worldwide event bringing together Arduino people and projects”.arduino-day

[ Slides for the talk in portuguese. ]

I talked about the synchronous microkernel based on Céu and presented a small demo of it up and running.

The feedback was very positive and enthusiastic, and I hope people got enough interest to try it on their projects.

I’m now working on the next release of Céu (including the microkernel for Arduino) for the next days.

(Follow me on twitter: @fsantanna_puc)


Written by francisco

March 31, 2014 at 6:05 pm

A Synchronous Micro Kernel for Embedded Systems

with 2 comments

I’m working on a new operating system that follows the synchronous execution model of Céu.
In reality, the term micro kernel would be more accurate: I’m only concerned with scheduling and inter-process communication mechanisms.

Why a new micro kernel?

Many reasons. :)

General frustrations

(Accumulated over the years of using UNIX-based systems.)


We are still using select or threads to communicate with multiple applications at the same time:

  • select: multiplex all communication in a single point and deal with state explicitly (e.g., switch (state) {…}).
  • threads: decentralize the communication in multiple threads and deal with synchronization explicitly (e.g., locks, semaphores).

Both approaches are complex and error prone (threads, select/events).


It is difficult, if not impossible, to reproduce the behavior of a set of interacting applications (even of a single application):

  • Preemptive schedulers are highly sensitive to small timing variations.
  • Most programming languages offer non-deterministic concurrency models only (e.g. threads, actors).

OS/Language integration:

I’m not sure if the “everything is a file”  philosophy of UNIX-based systems is too generalist and language agnostic.
Maybe operating systems and programming languages should be designed in conjunction, with the latter offering first-class OS-level IPC mechanisms.

Particular demands

I also have particular demands related to ongoing projects in our research group.

Micro platforms:

We work with highly-constrained embedded platforms (e.g., 16MHz, 64Kb FLASH, 4Kb RAM).

With such little resources, we can take advantage of the synchronous concurrency model to be more economic:

  • Processes share the same event queue.
  • Processes share the same stack.
  • Cooperative scheduling instead of preemptive (together with language guarantees that processes do cooperate).

Distributed WSNs:

Wireless Sensor Networks demand more functionality from operating systems:

  • Processes that communicate might not be on the same network node.
  • Applications need to be replaced remotely.


The video that follows shows a working demo of the OS:

(To see the texts in the video, please use a resolution of at least 480p in the “settings” icon.)

Together with the kernel, the microcontroller is preloaded with three processes:

  • An USART driver.
  • A shell that allows us to start/stop applications.
  • An USART<=>shell bridge that stores received bytes from the serial line until the command is complete.

These processes have no special rights, they are only preloaded so that we can command the microcontroller remotely.

In the first demo (0s-35s), after booting the microcontroller, we issue a sequence of commands through the terminal:

  • Upload a blinking application to address 0xF000.
  • Load address 0xF000 as process 0.
  • Start process 0.
  • Stop process 0 after some time.

Then, with the OS still up and running, we upload a similar application (it only blinks a different LED) to the same address and repeat the sequence of commands. The visual result is to see the blinking LED to change from red to yellow.

The second demo (35s-1min14s) issues another sequence of commands to upload and start three other applications:

  • A GPIO driver.
  • Two blinking applications [code1,code2].

Now, while the first application executes and blinks the yellow LED, we upload another application to blink the red LED.

Both applications rely on the the GPIO driver and avoid to duplicate the GPIO functions (as happens in the first demo).

The link command connects the applications with the GPIO driver. For example, to link the output call PIN_MODE of application 1 with the input call PIN_MODE of the driver (application 0), we write <link 1 1 0 243> (i.e., link app 1 / output 1 => app 0 / input 243).

(Sorry, event identifiers must be “hardcoded” as numbers instead of names.)

Check also the code for the USART driver, shell, USART<=>shell bridge, and GPIO driver.

Details in another post to come.

Written by francisco

March 11, 2014 at 2:50 pm

REM’13 accepted paper: “Advanced Control Reactivity for Embedded Systems”

with 3 comments

Our paper entitled “Advanced Control Reactivity for Embedded Systems” has been accepted in the Workshop on Reactivity, Events and Modularity (REM) this year in Indianapolis!

REM is a workshop inside the SPLASH/OOPSLA conference.

The preprint version for the paper can be downloaded here.

This is a more theoretical paper in comparison to our previous for SenSys.

We discuss how to build advanced control mechanisms on top of the reactive primitives of Céu and present a formal specification of the language.

Written by francisco

October 12, 2013 at 1:51 pm

Posted in News, Reactive Languages

Tagged with , , , , ,