This thesis presents and justifies a framework for programming real-time signal processing systems. The framework extends the existing "block-diagram" programming model; it has three components: a very high-level textual language, a visual language, and the dataflow process network model of computation. The dataflow process network model, although widely-used, lacks a formal description, and I provide a semantics for it. The formal work leads into a new form of actor. Having established the semantics of dataflow processes, the functional language Haskell is layered above this model, providing powerful features---notably polymorphism, higher-order functions, and algebraic program transformation---absent in block-diagram systems. A visual equivalent notation for Haskell, Visual Haskell, ensures that this power does not exclude the "intuitive" appeal of visual interfaces; with some intelligent layout and suggestive icons, a Visual Haskell program can be made to look very like a block dia...

Some extensions of the basic formalism of stream processing functions are useful to specify complex structures such as operating systems.

I/O mechanisms are needed if functional languages are to be suitable for general purpose programming and several implementations exist. But little is known about semantic methods for specifying and proving properties of lazy functional programs engaged in I/O. As a step towards formal methods of reasoning about realistic I/O we investigate three widely implemented mechanisms in the setting of teletype I/O: synchronised-stream (primitive in Haskell), continuationpassing (derived in Haskell) and Landin-stream I/O (where programs map an input stream to an output stream of characters) . Using methods from Milner's CCS we give a labelled transition semantics for the three mechanisms. We adopt bisimulation equivalence as equality on programs engaged in I/O and give functions to map between the three kinds of I/O. The main result is the first formal proof of semantic equivalence of the three mechanisms, generalising an informal argument of the Haskell committee. 1 Introduction and motivation...

Abstract. We define representations of continuous functions on infinite streams of discrete values, both in the case of discrete-valued functions, and in the case of stream-valued functions. We define also an operation on the representations of two continuous functions between streams that yields a representation of their composite. In the case of discrete-valued functions, the representatives are well-founded (finitepath) trees of a certain kind. The underlying idea can be traced back to Brouwer’s justification of bar-induction, or to Kreisel and Troelstra’s elimination of choice-sequences. In the case of stream-valued functions, the representatives are non-wellfounded trees pieced together in a coinductive fashion from well-founded trees. The definition requires an alternating fixpoint construction of some ubiquity.

This paper describes such a model, its implementation by extension to the Gofer programming system, and examples of its use. Performance results indicate that even this prototype interpretive system is adequate for small applications. The major gain of using a functional language is the ease with which abstraction can be layered over low-level detail, improving both the readability of code and its tractability

Existing functional languages appear not to be suitable for implementing systems which are inherently concurrent, such as operating system environments. Adaptations to functional languages developed to support such applications have in the past always involved the introduction of non-determinism.

This thesis presents and justi es a framework for programming real-time signal process-ing systems. The framework extends the existing \block-diagram " programming model� it has three components: a very high-level textual language, a visual language, and the data ow process network model of computation. The data ow process network model, although widely-used, lacks a formal description, and I provide a semantics for it. The formal work leads into a new form of actor. Having established the semantics of data ow processes, the functional language Haskell is layered above this model, providing powerful features|notably polymorphism, higher-order func-tions, and algebraic program transformation|absent in block-diagram systems. A visual equivalent notation for Haskell, Visual Haskell, ensures that this power does not exclude the \intuitive " appeal of visual interfaces � with some intelligent layout and suggestive icons, a Visual Haskell program can be made to look very like ablock diagram program. Finally, the functional language is used to further extend data ow process networks, by simulating timed and dynamically-varying networks.

control structures................................................................. 3 3.2. Lazy data structures .......................................................................................... 4 3.2.1. Non-strict CONS cells ....................................................................... 4 3.2.2. Streams ............................................................................................. 5 4. Why lazy evaluation is not implemented in imperative languages ....................................... 8 4.1. Referential transparency.................................................................................... 9 4.2. Implementation ................................................................................................. 9 5. The signal processing model in an imperative language...................................................... 10 5.1. Code framework................................................................................................ 11 5.2....

This thesis presents the Brisk Machine #54#, a machine for executing functional languages, designed to be simple and #exible to support a number of run-time execution models for the Brisk compiler. Design considerations have been made to support dynamic loading, deterministic concurrency #23,51#, distribution, debugging tools and logic programming #76#. To achieve this, the compiler's intermediate language, the Brisk Kernel Language BKL is simpler than the STG language #100#, as evaluation, extension and optimisation issues are relegated to special built-in functions. Moreover, function calls are saturated, as any function has an known arity and in every call to it, is applied to the rightnumber of arguments, which makes the machine dynamic and supports dynamic loading.

The original aim of the work that led to this dissertation was to extend an existing, purely functional language with facilities for input/output and modular programming. The language is based on an untyped -calculus, i.e., program execution is defined as program transformation according to a fixed set of reduction rules including fi-reduction. Consistently, the implementation comprises an interactive reduction system which is integrated with a syntax-oriented editor: any sub-expression or program result can be submitted for (stepwise) reduction. There is no distinguished main program, no `global' environment and no explicit static part of the language -- in particular, there is no static type system. It is therefore not clear how to add one of the known solutions for input/output or modular programming to such a programming environment. Furthermore, simply adding features to the language would lead to a complex language design with weakly integrated parts, thus losing much of the appe...