PhD student at Vrije Universiteit Brussel.
Conducting research in reactive programming language design for the Internet of Things.
MSc in Computer Science at VUB. Excited about Unix, language design, and good music.
PhD student at Vrije Universiteit Brussel.
Conducting research in reactive programming language design for the Internet of Things.
MSc in Computer Science at VUB. Excited about Unix, language design, and good music.
📮 
📱 
During my PhD I investigated what the best programming paradigm for data-intensive Internet of Things systems is, and proposed stream-based programming as a foundation for these systems. I designed a stream-based framework called Potato. Potato represents an IoT system as a network of distributed data streams and offers the programmer a toolset to easily compose, consume, and manipulate these streams. To deal with the heterogeneous devices in the system I designed a meta-level architecture for stream DSLs that allows the separation of concerns and makes it easier to integrate heterogeneous devices.
In my thesis: »Combining the Actor model with Software Transactional Memory«, I extensively studied the viability of integrating the actor model with software transactional memory and vice versa. Created proof of concept implementation in Clojure. Created operational semantics.
Teaching lab sessions, as well as giving exams.
Teaching lab sessions, as well as giving exams.
Teaching lab sessions, as well as giving exams.
Built a real estate website using the Umbraco CMS (.NET), and connected that to the legacy back-end.
Assemble and repair desktop computers.
Gave a short technical talk by invitation on the Elixir/OTP framework.
»slides«
On the requirements for the implementation of practical session types in contemporary languages.
»slides«
Cyber-Physical Systems (CPS) are comprised of a network of devices that vary widely in complexity, ranging from
simple sensors to autonomous robots. Traditionally, controlling and sensing these devices happens through API
communication, in either push or pull-based fashion. We argue that the computational power of these devices is
converging to the point where they can do autonomous computations. This allows application programmers to run
programs locally on the sensors, thereby reducing the communication and workload of more central command and
control entities. This work introduces the Potato framework that aims to make programming CPS systems intuitively
easy and fast. Potato is based on three essential mechanisms: failure handling by means of leasing, distribution
by means of first-class reactive programs, and intentional retroactive designation of the network by means of
capabilities and dynamic properties. In this paper we focus on the reactive capabilities of our framework. Potato
enables programmers to create and deploy first-class reactive programs on CPS devices at run time, abstracting
away from the API approach. Each node in the network is equipped with a minimal actor-based middleware that can
execute first-class reactive programs. We have implemented Potato as a library in Elixir and have used it to
implement several small examples.
»pdf«
The rise of streaming libraries such as Akka Stream, Reactive Extensions, and LINQ popularized the declarative
functional style of data processing. The stream paradigm offers concise syntax to write down processing pipelines
to consume the vast amounts of real-time data available today. These libraries offer the programmer a domain
specific language (DSL) embedded in the host language to describe data streams. These libraries however, all
suffer from extensibility issues. The semantics of a stream is hard-coded into the DSL language and cannot be
changed by the user of the library. We introduce an approach to modify the semantics of a streaming library by
means of meta-programming at both the run-time and compile-time level, and showcase its generality. We show that
the expressiveness of the meta-facilities is strong enough to enable push and pull semantics, error handling,
parallelism, and operator fusion. We evaluate our work by implementing the identified shortcomings in terms of a
novel stream meta-architecture and show that its design and architecture adhere to the design principles of a
meta-level architecture. The state of the art offers plenty of choice to programmers regarding reactive stream
processing libraries. Expressing reactive systems is otherwise difficult to do in general purpose languages.
Extensibility and fine-tuning should be possible in these libraries to ensure a broad variety of applications can
be expressed within this single DSL.
»pdf«
Cyber-Physical Systems (CPS) are comprised of a network of devices that vary widely in complexity, ranging from
simple sensors to autonomous robots. Traditionally, controlling and sensing these devices happens through API
communication, in either push or pull-based fashion. We argue that the computational power of these devices is
converging to the point where they can do autonomous computations. This allows application programmers to run
programs locally on the sensors, thereby reducing the communication and workload of more central command and
control entities. This work introduces the Potato framework that aims to make programming CPS systems intuitively
easy and fast. Potato is based on three essential mechanisms: failure handling by means of leasing, distribution
by means of first-class reactive programs, and intentional retroactive designation of the network by means of
capabilities and dynamic properties. In this paper we focus on the reactive capabilities of our framework. Potato
enables programmers to create and deploy first-class reactive programs on CPS devices at run time, abstracting
away from the API approach. Each node in the network is equipped with a minimal actor-based middleware that can
execute first-class reactive programs. We have implemented Potato as a library in Elixir and have used it to
implement several small examples.
»pdf«
The Internet of Things (IoT) requires us to rethink the way distributed event-driven applications are programmed.
IoT applications differ from traditional distributed applications on a number of points. First, they are comprised
of an order of magnitude more devices that operate within a dynamic network. Second, failure in large dynamic
networks is no longer an exceptional state but a given and thus needs to be part of the core semantics when
programming such networks. Third, the hardware in these networks is not homogeneous so that a common software
stack is impossible. We believe that contemporary event-driven languages do not offer appropriate abstractions to
write IoT applications. We propose a novel computational model for programming IoT applications by identifying
four key abstractions for designating network nodes and handle failures that facilitate writing large-scale IoT
applications.
»pdf«
Jef Jacobs, Jens Nicolay, Christophe De Troyer, Wolfgang De Meuter
We present PrintTalk, a DSL to "program" 3D objects, called "gadgets". PrintTalk also features "topologies",
which are predefined spacial arrangements of gadgets. Gadgets are composed by executing a gadget script (possibly
consisting of subscripts) that 'draws' the gadget in the 3D scene. However, executing the script also returns a
number of constraint variables. These variables can be constrained inside the gadget and can also be bound outside
the gadget in order to constrain the produced gadgets after the facts. This is the essence of the gadget
composition mechanism of PrintTalk. PrintTalk is implemented in DrRacket. Running a PrintTalk program generates a
file that is sent to the 3D printer. We validate PrintTalk qualitatively by comparing the code for complex gadgets
with the code needed to print those gadgets in existing languages.
PDF-Version