2 research outputs found
Terrier: an embedded operating system using advanced types for safety
Operating systems software is fundamental to modern computer
systems: all other applications are dependent upon the correct and
timely provision of basic system services. At the same time,
advances in programming languages and type theory have lead to the
creation of functional programming languages with type systems that
are designed to combine theorem proving with practical systems
programming. The Terrier operating system project focuses on
low-level systems programming in the context of a multi-core,
real-time, embedded system, while taking advantage of a dependently
typed programming language named ATS to improve
reliability. Terrier is a new point in the design space for an
operating system, one that leans heavily on an associated
programming language, ATS, to provide safety that has traditionally
been in the scope of hardware protection and kernel
privilege. Terrier tries to have far fewer abstractions between
program and hardware. The purpose of Terrier is to put programs as
much in contact with the real hardware, real memory, and real timing
constraints as possible, while still retaining the ability to
multiplex programs and provide for a reasonable level of safety
through static analysis
Using Lightweight Theorem Proving in an Asynchronous Systems Context
Abstract. As part of the development of a new real-time operating system, an asynchronous communication mechanism, for use between applications, has been implemented in a programming language with an advanced static type system. This mechanism is designed to provide desired properties of asynchronicity, coherency and freshness. We used the features of the type system, including linear and dependent types, to represent and partially prove that the implementation safely upheld coherency and freshness. We believe that the resulting program code forms a good example of how easily linear and dependent types can be applied in practice to prove useful properties of low-level concurrent systems programming, while leaving no traces of runtime overhead.