Haskino: A Remote Monad for Programming the Arduino

  title={Haskino: A Remote Monad for Programming the Arduino},
  author={Mark Grebe and Andy Gill},
The Haskino library provides a mechanism for programming the Arduino microcontroller boards in high level, strongly typed Haskell instead of the low level C language normally used. Haskino builds on previous libraries for Haskell based Arduino programming by utilizing the recently developed remote monad design pattern. This paper presents the design and implementation of the two-level Haskino library. This first level of Haskino requires communication from the host running the Haskell program… 

Threading the Arduino with Haskell

The Haskino library is extended to translate monadic Haskell code to multi-threaded code executing on Arduino boards, allowing programmers to develop code for Arduino-based microcontrollers usingmonadic Haskell program fragments.

Declarative Programming for Microcontrollers - Datalog on Arduino

This paper uses an approach that is based on the Dedalus language augmented with operations that allow for side-effects and takes the limited resources of a microcontroller into account, and allows to run Datalog programs on Arduino-based systems.

Programming microcontrollers through high-level abstractions

This paper provides various abstraction layers (abstraction of the microcontroller, of the electronic components of the circuit, and of concurrency) which, while being adapted to the scarce resources of the hardware, offer high-level programming traits for the development of embedded applications.

Domain Specific Languages for Small Embedded Systems

This work provides a method for combining the best aspects of shallow and deep EDSLs, and shows that an embedded domain specific language is able to be used to program them, and provides a user friendly environment for both prototyping and full development.

A Task-Based DSL for Microcomputers

This paper presents a functional task-based domain specific language for these IoT devices and shows that it yields concise control programs that fit within the restrictions of microcontrollers.

Rewriting a shallow DSL using a GHC compiler extension

This work uses Haskino, an EDSL designed for small embedded systems based on the Arduino line of microcontrollers, and a compiler plugin for the Haskell GHC compiler, to show a method for combining the best aspects of shallow and deep E DSLs.

Interpreting task oriented programs on tiny computers

This paper shows that for dynamic IOT applications, tasks must be sent at runtime to the devices for interpretation, and describes in detail how to compile specialized IOT TOP tasks to bytecode and how to interpret them on devices with very little memory.

Task Oriented Programming and the Internet of Things

This paper shows how IoT tasks can be seemlessly integrated with a Task Oriented Programming (TOP) server such as iTasks, which allows the specification on a high level of abstraction of arbitrary collaborations between human beings, large systems, and now also IoT devices.

Composable network stacks and remote monads

This paper investigates using monads and applicative functors to bundle remote effectful primitives to amortize the cost of remote communications using bundling, and finds that monadic fragments can be efficiently bundled into packets when given a user-supplied packet transportation mechanism.

Proceedings of the 30th Symposium on Implementation and Application of Functional Languages

Using the SIR model of epidemiology, it is demonstrated how to use pure Functional Reactive Programming to implement ABS and found that the representation in a purely functional format is conceptually quite elegant and opens the way to formally reason about ABS.



Firmata: Towards Making Microcontrollers Act Like Extensions of the Computer

Firmata is a generic protocol for communicating with microcontrollers from software on a host computer that was designed to be open and flexible so that any programming environment can support it, and simple to implement both on the microcontroller and the host computer to ensure a wide range of implementations.

The Design and Implementation of Feldspar - An Embedded Language for Digital Signal Processing

The initial conclusion is that the Feldspar language implemented as a minimal, deeply embedded core language, with shallow extensions built upon it works well in the domain, although much work remains.

Feldspar: A domain specific language for digital signal processing algorithms

  • E. AxelssonK. Claessen A. Vajda
  • Computer Science
    Eighth ACM/IEEE International Conference on Formal Methods and Models for Codesign (MEMOCODE 2010)
  • 2010
A new language, Feldspar, is presented, enabling high-level and platform-independent description of digital signal processing (DSP) algorithms, based on a low-level, functional core language which has a relatively small semantic gap to machine-oriented languages like C.

The remote monad design pattern

This paper demonstrates how to reduce the cost of calling remote procedures from Haskell by using the remote monad design pattern, which amortizes the cost, at a surprisingly inexpensive cost.

Compiling embedded languages

An implemented technique for producing optimizing compilers forDSELs, based on Kamin's idea of DSELs for program generation, using a data type of syntax for basic types, a set of smart constructors that perform rewriting over those types, some code motion transformations, and a back-end code generator.

Guilt free ivory

The main contributions of the paper are to demonstrate how to embed the type-system of a safe-C language into the type extensions of GHC, and to describe Ivory, a language that enforces memory safety and avoids most undefined behaviors while providing low-level control of memory- manipulation.

The constrained-monad problem

It is shown that a monadic computation can be restructured into a normal form such that the standard monad class can be used, and how this technique can be applied to other structures, such as applicative functors.

Reasoning with the HERMIT: tool support for equational reasoning on GHC core programs

HerMIT's recently developed support for equational reasoning is described, and two case studies of HERMIT usage are presented: checking that type-class laws hold for specific instance declarations, and mechanising textbook equational Reasoning.

Simple and compositional reification of monadic embedded languages

A solution to the monad reification problem is presented and illustrated with a small robot control language in order to demonstrate its directness, simplicity and compositionality.

Generic Monadic Constructs for Embedded Languages

A library of generic monadic constructs for embedded languages, an extension of Syntactic, a Haskell library for defining and processing generic abstract syntax, that allows the pure expressions to also contain controlled side effects, enabling the representation of expressions that rely on destructive updates for efficiency.