The Synchronous Blog

A blog about reactive programming languages.

Archive for the ‘Reactive Languages’ Category

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 , , , ,

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 , , , , ,

SenSys’13 accepted paper: “Safe System-Level Concurrency on Resource-Constrained Nodes”

with 3 comments

Our paper entitled “Safe System-Level Concurrency on Resource-Constrained Nodes” has been accepted in SenSys this year in Rome!

The preprint version for the paper can be downloaded here.

I’m happy that Céu has been accepted in such a prestigious conference.

More information can be found here.

 

Written by francisco

September 16, 2013 at 11:30 am

Posted in News, Reactive Languages

Tagged with , , ,

PhD thesis preprint: “Safe System-level Concurrency on Resource-Constrained Nodes with Céu”

with 2 comments

I’m about to reach the day of my PhD defense.

The preprint for my thesis, entitled “Safe System-level Concurrency on Resource-Constrained Nodes with Céu”, can be downloaded here.

(BTW, we had a paper accepted for SenSys this year in Rome! :)

Written by francisco

August 24, 2013 at 12:12 pm

Posted in News, Reactive Languages

Tagged with , ,

“Céu: Embedded, Safe, and Reactive Programming”

with one comment

We have published a technical report entitled “Céu: Embedded, Safe, and Reactive Programming”.

Enjoy the reading!

Abstract:

Céu is a programming language that unifies the features found in dataflow and imperative synchronous reactive languages, offering a high-level and safe alternative to event-driven and multithreaded systems for embedded systems.

Céu supports concurrent lines of execution that run in time steps and are allowed to share variables. However, the synchronous and static nature of Céu enables a compile time analysis that can enforce deterministic and memory-safe programs.

Céu also introduces first-class support for “wall-clock” time (i.e. time from the real world), and offers seamless integration with C and simulation of programs in the language itself.

The Céu compiler generates single-threaded code comparable to handcrafted C programs in terms of size and portability.

Table of Contents:

  1. Introduction
  2. The Language Céu
    1. Parallel compositions
    2. Internal events & Dataflow support
    3. Wall-clock time
    4. Integration with C
    5. Bounded execution
    6. Determinism
    7. Asynchronous execution
    8. Simulation in Céu
    9. GALS execution
  3. Demo applications
    1. WSN ring
    2. Arduino ship game
    3. SDL game simulation
  4. Implementation of Céu
    1. Temporal analysis
    2. Memory layout
    3. Gate allocation
    4. Code generation
    5. Reactive execution
    6. Evaluation
  5. Related work
    1. Synchronous model
    2. Asynchronous model
  6. Conclusion

Céu is born!

leave a comment »

Céu is a reactive language targeted at embedded systems, aiming to offer a higher-level and safer alternative to C.

Céu can be described as a reactive, imperative, concurrent, synchronous, and deterministic language.

Céu has a memory footprint of around 3Kb of ROM and 100b of RAM (on a 16bits platform).

Currently, Céu is restricted to static-only applications.

(See also the two previous blog posts.)

Website: http://ceu-lang.org (you can try Céu online!)

Git project: http://github.com/fsantanna/ceu

I’m looking for embedded systems developers interested in using Céu.

I can help with all support (i.e. coding) to integrate Céu with your platform.

The distribution of Céu already provides support for Arduino:

http://www.ceu-lang.org/wiki/index.php?title=Arduino

*** UPDATE (1): Looks like dreamhost (where ceu-lang is hosted) is in trouble.

*** UPDATE (2): Dreamhost is up again!

Written by francisco

January 30, 2012 at 3:10 am

A “down to earth” reactive language: Céu

leave a comment »

It has been more than one year since my last blog post. The reason is the direction I took two years ago, in the beginning of my PhD, switching from LuaGravity to something more grounded.

LuaGravity was very fun to work with, it showed how reactive languages are expressive, allowing complex dependency patterns to be written with simple expressions. It also showed how easily Lua can be hacked in runtime to provide a completely different semantics.

However, LuaGravity is overly powerful as a research artifact. In this context, what really matters is to understand the motivations, goals, and what is needed  and not needed in a reactive language. The border between Lua and LuaGravity was unclear and Lua is too dynamic, what complicates the deterministic execution enforcement we wanted to provide.

The development of a new language—Céu—is the process to answer and pose research questions related to reactive languages.

Céu can be defined in keywords as a reactive, imperative, concurrent, synchronous, and deterministic language. The syntax is very compact (resembling CSP or Pi-calculus), what is great for writing papers and discussing programs, but not necessarily for developing applications.

Currently, Céu is targeted at Wireless Sensor Networks, but any constrained embedded platform is of our interest. Follows a “Hello World!” program in Céu  that blinks three leds, each with a different frequency, forever:

(
    ( ~250ms  ; ~>Leds_led0Toggle)*
||
    ( ~500ms  ; ~>Leds_led1Toggle)*
||
    ( ~1000ms ; ~>Leds_led2Toggle)*
)

.

I presented Céu in the Doctoral Colloquium [1] at Sensys’11 last week. The 3-page summary submitted to the conference can be reached here.

[1] http://www.cse.ust.hk/~lingu/SenSys11DC/

Written by francisco

November 15, 2011 at 11:24 pm