This ebook is the first authorized digital version of Kernighan and Ritchie's 1988 classic, The C Programming Language (2nd Ed.). One of the best-selling programming books published in the last fifty years, "K&R" has been called everything from the "bible" to "a landmark in computer science" and it has influenced generations of programmers. Available now for all leading ebook platforms, this concise and beautifully written text is a "must-have" reference for every serious programmers digital library.

As modestly described by the authors in the Preface to the First Edition, this "is not an introductory programming manual; it assumes some familiarity with basic programming concepts like variables, assignment statements, loops, and functions. Nonetheless, a novice programmer should be able to read along and pick up the language, although access to a more knowledgeable colleague will help."

The C programming language

Monads have become very popular for structuring functional programs since Wadler introduced their use in 1990. In particular, libraries of combinators are often based on a monadic type. Such libraries share (in part) a common interface, from which numerous benefits flow, such as the possibility to write generic code which works together with any library. But, several interesting and useful libraries are fundamentally incompatible with the monadic interface. In this paper I propose a generalisation of monads, which I call arrows, with significantly wider applicability. The paper shows how many of the techniques of monadic programming generalise to the new setting, and gives examples to show that the greater generality is useful. In particular, three non-monadic libraries for efficient parsing, building graphical user interfaces, and programming active web pages fit naturally into the new framework.

Generalising monads to arrows

We present unikernels, a new approach to deploying cloud services via applications written in high-level source code. Unikernels are single-purpose appliances that are compile-time specialised into standalone kernels, and sealed against modification when deployed to a cloud platform. In return they offer significant reduction in image sizes, improved efficiency and security, and should reduce operational costs. Our Mirage prototype compiles OCaml code into unikernels that run on commodity clouds and offer an order of magnitude reduction in code size without significant performance penalty. The architecture combines static type-safety with a single address-space layout that can be made immutable via a hypervisor extension. Mirage contributes a suite of type-safe protocol libraries, and our results demonstrate that the hypervisor is a platform that overcomes the hardware compatibility issues that have made past library operating systems impractical to deploy in the real-world.

/pdf/unikernels-library-operating-systems-for-the-cloud-2g23pju8w2.pdf

Unikernels: library operating systems for the cloud

We have designed and implemented a type-based analysis for proving some basic properties of reactive systems. The analysis manipulates rich type expressions that contain information about the sizes of recursively defined data structures. Sized types are useful for detecting deadlocks, nontermination, and other errors in embedded programs. To establish the soundness of the analysis we have developed an appropriate semantic model of sized types.

Proving the correctness of reactive systems using sized types

This paper describes the history of Haskell, including its genesis and principles, technical contributions, implementations and tools, and applications and impact.

/pdf/a-history-of-haskell-being-lazy-with-class-18v2l48ari.pdf

A history of Haskell: being lazy with class

This paper describes an implementation of a small windowbased graphical user interface toolkit for X Windows written in the lazy functional language LML. By using this toolkit, a H askell or LML programmer can crest e a user interface with menus, buttons and other graphical interface objects, without conforming to more or less imperative programming paradigms imposed if she were to use a traditional (imperative) toolkit. Instead, the power of the abstraction methods provided by Haskell or LML are used. The main abstraction we use is the fr.dget. Fudgets are combined in a hierarchical structure, and they interact by message passing, The current implementation is baaed on a sequential evaluator, but by using non-determinism and oracles, we suggest how the fudgets can evaluate in parallel. We believe that the toolkit can be extended to a full-feathered and practically useful high level graphical toolkit.

FUDGETS: a graphical user interface in a lazy functional language

We describe a monadic interface to low-level hardware features that is a suitable basis for building operating systems in Haskell. The interface includes primitives for controlling memory management hardware, user-mode process execution, and low-level device I/O. The interface enforces memory safety in nearly all circumstances. Its behavior is specified in part by formal assertions written in a programming logic called P-Logic. The interface has been implemented on bare IA32 hardware using the Glasgow Haskell Compiler (GHC) runtime system. We show how a variety of simple O/S kernels can be constructed on top of the interface, including a simple separation kernel and a demonstration system in which the kernel, window system, and all device drivers are written in Haskell.

/pdf/a-principled-approach-to-operating-system-construction-in-23mczl8wdq.pdf

A principled approach to operating system construction in Haskell

The paper presents an extension of the proof editor Alfa with natural-language input and output. The basis of the new functionality is an automatic translation to syntactic structures that are closer to natural language than the type-theoretical syntax of Alfa. These syntactic structures are mapped into texts in languages such as English, French, and Swedish. In this way, every theory, definition, proposition, and proof in Alfa can be translated into a text in any of these languages. The translation is defined for incomplete proof objects as well, so that a text with "holes" (i.e. metavariables) in it can be viewed simultaneously with a formal proof constructed. The mappings into natural language also work in the parsing direction, so that input can be given to the proof editor in a natural language.

The natural-language interface is implemented using the Grammatical Framework GF, so that it is possible to change and extend the interface without recompiling the proof editor. Such extensions can be made on two dimensions: by adding new target languages, and by adding theory-specific grammatical annotations to make texts more idiomatic.

An extensible proof text editor

The main result of this thesis is a method for writing programs with graphical user interfaces in purely functional languages The method is based on a new abstraction called the fudget The method makes good use of key abstraction powers of functional languages, such as higher order functions and parametric polymorphism The Fudget concept is defined in terms of the simpler concept of stream processors, which can be seen as a simple, but practically useful incarnation of the process concept Programs based on fudgets and stream processors are networks of communicating processes that are built hierarchically, using combinators Communication is type safe The basic combinators provide serial compositions, parallel compositions, and loops A key difference between previous work on stream processing functions and our approach is that we deliberately abstract away from the streams We obtain a system that can be implemented deterministically, entirely within a purely functional language, but which also makes it possible to take advantage of parallel evaluation and indeterminism, where such is available within the functional language The purely functional approach makes processes first class values and makes it easy to express process cloning and process migration The practical viability of the approach is demonstrated by the Fudget library, which is an implementation of a graphical user interface toolkit in the purely functional language Haskell, together with a number of small an large applications that have been implemented on top of the library In addition to GUI programming, fudgets are suitable for other forms of concurrent I/O programming We demonstrate how client/server based applications can be we written, with type safe communication between client and server We show a web browser as an example where GUI programming and network communication come together We view fudgets as one example of a more general combinator-based approach to promote the idea that a functional language together with combinator libraries is a good alternative to using less expressive languages propped by application-specific tools We describe a set of combinators, reminiscent of parsing combinators, for building syntax-directed editors

Fudgets - Purely Functional Processes with applications to Graphical User Interfaces

One of the goals of the Programatica Project is to develop tool support for high-assurance programming in Haskell [21]. We have extended Haskell with syntax for property assertions, and envision the use of various techniques to provide evidence for the validity of assertions. We expect our tools to assist the programmer with evidence management, using certificates to record evidence, and to provide whatever translation of Haskell code needed to enable the use of theorem provers and other tools that can serve as sources of evidence. The Programatica Tools, while still work in progress, can manipulate Haskell programs in various ways and have some support for evidence management. In Section 2, we describe a selection of the functionality provided by the tools, starting with functionality that might be of interest to Haskell programmers in general, and ending with functionality more directly aimed at supporting the goals of the Programatica Project. Section 3 contains some notes on the implementation.

/pdf/haskell-tools-from-the-programatica-project-2y3tjiifi7.pdf

Thomas Hallgren

Papers

FUDGETS: a graphical user interface in a lazy functional language

A principled approach to operating system construction in Haskell

An extensible proof text editor

Fudgets - Purely Functional Processes with applications to Graphical User Interfaces

Haskell tools from the programatica project