CFSIM: A concurrent compiled-code functional simulator for hopCP

Journal ArticleControl intensive ICs pose a significant challenge to the users of formal methods in designing hardware. These ICs have to support a wide variety of requirements including synchronous and asynchronous operations, polling and interrupt-driven modes of operation, multiple concurrent threads of execution, complex computations, and programmability. In this paper, we illustrate the use of formal methods in the design of a control intensive IC called the "Intel 8251" Universal Synchronous/Asynchronous Receiver/Transmitter (USART), using our formal hardware description language 'hopCP'. A feature of hopCP is that it supports communication via asynchronous ports (distributed shared variables writable by exactly one process), in addition to synchronous message passing. We show the usefulness of this combination of communication constructs. We outline static analysis algorithms to determine safe usages of asynchronous ports, and also to discover other static properties of the specification. We discuss a compiled-code concurrent functional simulator called CFSIM, as well as the use of concurrent testers for driving CFSIM. The use of a semantically well specified and simple language, and the associated analysis/simulation tools helps conquer the complexity of specifying and validating control intensive ICs

Programming Languages for Distributed Computing Systems

When distributed systems first appeared, they were programmed in traditional sequential languages, usually with the addition of a few library procedures for sending and receiving messages. As distributed applications became more commonplace and more sophisticated, this ad hoc approach became less satisfactory. Researchers all over the world began designing new programming languages specifically for implementing distributed applications. These languages and their history, their underlying principles, their design, and their use are the subject of this paper. We begin by giving our view of what a distributed system is, illustrating with examples to avoid confusion on this important and controversial point. We then describe the three main characteristics that distinguish distributed programming languages from traditional sequential languages, namely, how they deal with parallelism, communication, and partial failures. Finally, we discuss 15 representative distributed languages to give the flavor of each. These examples include languages based on message passing, rendezvous, remote procedure call, objects, and atomic transactions, as well as functional languages, logic languages, and distributed data structure languages. The paper concludes with a comprehensive bibliography listing over 200 papers on nearly 100 distributed programming languages

Composing graphical user interfaces in a purely functional language

This thesis is about building interactive graphical user interfaces in a compositional manner. Graphical user interface application hold out the promise of providing users with an interactive, graphical medium by which they can carry out tasks more effectively and conveniently. The application aids the user to solve some task. Conceptually, the user is in charge of the graphical medium, controlling the order and the rate at which individual actions are performed. This user-centred nature of graphical user interfaces has considerable ramifications for how software is structured. Since the application now services the user rather than the other way around, it has to be capable of responding to the user's actions when and in whatever order they might occur. This transfer of overall control towards the user places heavy burden on programming systems, a burden that many systems don't support too well. Why? Because the application now has to be structured so that it is responsive to whatever action the user may perform at any time. The main contribution of this thesis is to present a compositional approach to constructing graphical user interface applications in a purely functional programming language The thesis is concerned with the software techniques used to program graphical user interface applications, and not directly with their design. A starting point for the work presented here was to examine whether an approach based on functional programming could improve how graphical user interfaces are built. Functional programming languages, and Haskell in particular, contain a number of distinctive features such as higher-order functions, polymorphic type systems, lazy evaluation, and systematic overloading, that together pack quite a punch, at least according to proponents of these languages. A secondary contribution of this thesis is to present a compositional user interface framework called Haggis, which makes good use of current functional programming techniques. The thesis evaluates the properties of this framework by comparing it to existing systems

Computer-Assisted Lighting Design and Control

This dissertation shows that computer-based lighting control systems can support the lighting design process considerably better than traditional consoles. It describes the Lula Project, a new software package for lighting design and control, that implements this level of support. Lula's focus is on the conceptual ideas behind a lighting design rather than the concrete lighting fixtures used to put it on stage. Among the innovative aspects of the system are its model for designing static lighting looks and its subsystem for programmable continuous animated lighting. Lula's application design is centered around the idea of componential lighting design that allows the user to express a lighting design as a hierarchy of components. Lula is a result of the rigorous application of high-level software engineering techniques and implementation technology from the general realm of functional programming. The high-level structure of the application rests upon stratified design, algebraic modelling, and domain-specific languages. Among the implementation techniques instrumental to Lula are automatic memory management, higher-order programming, functional data structures, data-directed programming, parametric inheritance, and concurrent programming.Computer-basierte Systeme für Beleuchtungssteuerung sind in der Lage, den Lichtdesigner weitaus besser zu unterstützen als es derzeit marktübliche Steuerkonsolen tun. Das Thema dieser Dissertation ist ein solches System, das Projekt Lula. Lula ist eine neue Software für Lichtregie und Beleuchtungssteuerung, welche die Modellierung der konzeptuellen Elemente eines Lichtdesigns ermöglicht, unabhängig von der konkreten Realisierung auf der Bühne. Unter den innovativen Aspekten des Systems ist das Modell für den Entwurf statischer Beleuchtungsszenen sowie das Subsystem für programmierbare, stetig animierte Beleuchtung. Das übergeordnete Prinzip bei Lula ist komponentenbasierte Lichtregie, die es dem Benutzer erlaubt, ein Lichtdesign als eine Hierarchie von Komponenten auszudrücken. Lula ist das Resultat konsequenter Anwendung von Entwurfs- und Implementierungs-Techniken aus dem Bereich der funktionalen Programmierung. Die High-Level-Struktur des Systems baut auf stratifiziertes Design, algebraische Modellierung und anwendungsspezifische Programmiersprachen. Unter den Implementationstechniken, die entscheidend bei der Entwicklung von Lula waren, befinden sich automatische Speicherverwaltung, Higher-Order-Programmierung, funktionale Datenstrukturen, datengesteuerte Programmierung, parametrische Vererbung und nebenläufige Programmierung

Higher-Order Concurrency for Microcontrollers

Programming microcontrollers involves low-level interfacing with hardware and peripherals that are concurrent and reactive. Such programs are typically written in a mixture of C and assembly using concurrent language extensions (like FreeRTOS tasks and semaphores), resulting in unsafe, callback-driven, error-prone and difficult-to-maintain code.We address this challenge by introducing SenseVM - a bytecode-interpreted virtual machine that provides a message-passing based higher-order concurrency model, originally introduced by Reppy, for microcontroller programming. This model treats synchronous operations as first-class values (called Events) akin to the treatment of first-class functions in functional languages. This primarily allows the programmer to compose and tailor their own concurrency abstractions and additionally, abstracts away unsafe memory operations, common in shared-memory concurrency models, thereby making microcontroller programs safer, composable and easier-to-maintain.Our VM is made portable via a low-level bridge interface, built atop the embedded OS - Zephyr. The bridge is implemented by all drivers and designed such that programming in response to a software message or a hardware interrupt remains uniform and indistinguishable. In this paper we demonstrate the features of our VM through an example, written in a Caml-like functional language, running on the nRF52840 and STM32F4 microcontrollers

1 Summary

EXene is a multi-threaded X window system toolkit that we have been developing on top of Con-current ML [Rep91a, Rep90] (CML). This paper describes a snapshot of eXene’s development, as pre-sented in two talks at the ML workshop at CMU. 2 CML overview Both the implementation and the user’s view of eXene rely heavily on the concurrency model pro-vided by CML ¡. CML is based on the sequential language SML [MTH90, MT91] and inherits the fol-lowing good features of SML: functions as first-class values, strong static typing, polymorphism, datatypes and pattern matching, lexical scoping, exception handling and a state-of-the-art module facility. The sequential performance of CML benefits from the quality of the SML/NJ compiler. In addition CML has the following properties: CML provides a high-level model of concurrency with dynamic creation of threads and typed channels, and rendezvous-style communication. This distributed-memory model fits well with the mostly applicative style of SML. CML is a higher-order concurrent language. Just as SML supports functions as first-class values, CML supports synchronous operations as first-class values. These values, called events, provide the tools for building new synchronization abstractions, which are tailored to the application