Functional Programming

Recent functional logic languages such as Curry and Toy combine lazy functional programming with logic programming features including logic variables, non-determinism, unification, narrowing, fair search, concurrency, and residuation. In this paper, we show how to extend a conventional interpreter for a lazy functional language to handle these features by adding support for reference cells, process-like and thread-like concurrency mechanisms, and a novel form of multi-versioned store. Our interpretation scheme is practical, and can be easily extended to perform compilation. The language specified by our interpreter is designed so that programs are deterministic in a novel and useful sense.

The parallelization of sequential programs is an adequate approach for the easy use of architectural features provided on parallel computers. We propose to enhance this technique with the notion of semantic parallelization. The principle is to consider the transformations of programs induced by parallelization as non-standard denotational semantics of the source programming language. We show how to apply this concept to detect, in a toy language ALL, parallelixable complex commands and to deal with some type of programs using indirections. Thanks to results in domain theory and abstract interpretation, we give correctness proofs for these transformations with respect to ALL standard semantic. A byproduct of our approach is that a &notational specification is also an executable prototype ; hence, we were able to implement a semantic parallel&r in the ML functional language.

Block cipher (BC) is a type of symmetric cipher used to encrypt data. Despite its advantages, it faces a substantial challenge. Writing the script code for the BC scheme accurately using General-Purpose Programming Languages (GPPLs) poses a significant challenge for programmers. The aim of this paper is to present the first graphical domain-specific modeling language (DSML) for designing and implementing BC algorithms, called BCLang. It is an extension to our previous DSML that was developed for Stream cipher. Programming efficiency and expressiveness were increased by reducing grammar and runtime errors and providing a high level of abstraction. BCLang provides the fundamental components of the BC three structures, which enable the programmer to design and implement BC algorithms in a graphical manner. Two keystream generation methods, performance analysis, and tests of the National Institute of Standards and Technology (NIST) for randomness analysis were provided. The presented language was evaluated based on five subjective metrics specific to graphical DSML evaluation. The design, evaluation details, and properties are explained in depth in this paper.

This paper presents a compiler for interaction nets, which, just like term rewriting systems, are user-definable rewrite systems which offer the ability to specify and program. In the same way that the lambda-calculus is the foundation for functional programming, or horn clauses are the foundation for logic programming, we give in this paper an overview of a substantial software system that is currently under development to support interaction based computation, and in particular the compilation of interaction nets.

Vector programming is an important topic in many Introduction to Computer Science courses. Despite the importance of vectors, learning vector programming is a source of frustration for many students. Much of the frustration is rooted in discovering the source of bugs that are manifested as out-of-bounds indexing. The problem is that such bugs are, sometimes, rooted in incorrectly computing an index. Other times, however, these errors are rooted in mistaken reasoning about how to correctly process a vector. Unfortunately, either way, all too often beginners are left adrift to resolve indexing errors on their own. This article extends the work done on vector programming using vector intervals and structural recursion to using generative recursion. As for problems solved using structural recursion, vector intervals provide beginners with a useful framework for designing code that properly indexes vectors. This article presents the methodology and concrete examples that others may use to build their own CS1 modules involving vector programming using any programming language.

We show that two A-calculus terms can be observationally congruent (i.e., agree in all contexts) but their continuation-passing transforms may not be. We also show that two terms may be congruent in all untyped contexts but fail to be congruent in a language with call/cc operators, and that two terms may have the same meaning in a direct semantics but not in a continuation semantics. Hence, familiar reasoning about terms may be unsound in a setting with continuations, demonstrating the need for a theory of continuations.

Copy elimination is an important optimization for compiling functional languages. Copies arise because these languages lack the concepts of state and variable; hence updating an object involves a copy in a naive implementation. Copies are also possible if proper targeting has not been carried out inside functions and across function calls. Targeting is the proper selection of a storage area for evaluating an expression. By abstracting a collection of functions by a target operator, we compute targets of function bodies that can then be used to define an optimized interpreter to eliminate copies due to updates and copies across function calls. The language we consider is typed lambda calculus with higherorder functions and special constructs for array operations. Our approach can eliminate copies in divide and conquer problems like quicksort and bitonic sort that previous approaches could not handle. Using abstract interpretation, a technique that was pie neered by Cousot and Cousot[l2] for deriving properties of programs, Mycroft[lO] considered the problem of detecting when a call-by-need argument can be turned into a call-byvalue argument in the interests of efficiency. Hudak[7] has also used the technique of abstract interpretation successfully to detect updates that can be done in-place by reference counting when call-by-value arguments are used. However, his approach does not extend naturally to divide and conquer problems. We also present some results of implementing a compiler for a single assignment language called SAL on some small but tough programs. Our results indicate that it is possible to approach a performance comparable to imperative languages like Pascal.

Copy elimination is an important optimization for compiling functional languages. Copies arise because these languages lack the concepts of state and variable; hence updating an object involves a copy in a naive implementation. Copies are also possible if proper targeting has not been carried out inside functions and across function calls. Targeting is the proper selection of a storage area for evaluating an expression. By abstracting a collection of functions by a target operator, we compute targets of function bodies that can then be used to define an optimized interpreter to eliminate copies due to updates and copies across function calls. The language we consider is typed lambda calculus with higherorder functions and special constructs for array operations. Our approach can eliminate copies in divide and conquer problems like quicksort and bitonic sort that previous approaches could not handle. Using abstract interpretation, a technique that was pie neered by Cousot and Cousot[l2] for deriving properties of programs, Mycroft[lO] considered the problem of detecting when a call-by-need argument can be turned into a call-byvalue argument in the interests of efficiency. Hudak[7] has also used the technique of abstract interpretation successfully to detect updates that can be done in-place by reference counting when call-by-value arguments are used. However, his approach does not extend naturally to divide and conquer problems. We also present some results of implementing a compiler for a single assignment language called SAL on some small but tough programs. Our results indicate that it is possible to approach a performance comparable to imperative languages like Pascal.

Session types are a well-established approach to ensuring protocol conformance and the absence of communication errors such as deadlocks in message passing systems. Implicit parameters, introduced by Haskell and popularised in Scala, are a mechanism to improve program readability and conciseness by allowing the programmer to omit function call arguments, and have the compiler insert them in a principled manner at compile-time. Scala recently gave implicit types first-class status (implicit functions), yielding an expressive tool for handling context dependency in a type-safe manner. DOT (Dependent Object Types) is an object calculus with path-dependent types and abstract type members, developed to serve as a theoretical foundation for the Scala programming language. As yet, DOT does not model all of Scala’s features, but a small subset. Among those features of Scala not yet modelled by DOT are implicit functions. We ask: can type-safe implicit functions be generalised from Scala’s s...

This document contains a description of a Common Lisp extension that allows a programmer to write functional programs that use normal order evaluation, as in non-strict languages like Haskell. The extension is relatively straightforward, and it appears to be the first one such that is integrated in the overall Common Lisp framework 1 .

The category of open games, which provides a strongly compositional foundation of economic game theory, is intermediate between symmetric monoidal and compact closed. More precisely it has counits with no corresponding units, and a partially defined duality. There exist open games with the same types as unit maps, given by agents with the strategic goal of predicting a future value. Such agents appear in earlier work on selection functions. We explore the algebraic properties of these agents via the symmetric monoidal bicategory whose 2-cells are morphisms between open games, and show how the resulting structure approximates a compact closed category with a family of lax commutative bialgebras.

This paper introduces CλaSH, a novel hardware specification environment, by discussing several non-trivial examples. CλaSH is based on the functional language Haskell, and exploits many of its powerful abstraction mechanisms such as higher order functions, polymorphism, lambda abstraction, pattern matching, type derivation. As a result, specifications in CλaSH are concise and semantically clear, and simulations can be directly executed within a Haskell evaluation environment. CλaSH generates synthesizable low-level VHDL code by applying several transformation rules to a functional specification of a digital circuit.

Stencil computations are array based algorithms that apply a computation to all array elements in a fixed regular pattern and can be found in many scientific and engineering applications. Parallelization of these applications becomes more and more important in order to keep up with the demand for computing power. FPGAs offer a lot of computing power but are considered hard to program. In this paper, a design methodology based on transformations of higher-order functions is introduced to facilitate this parallelization process. Using this methodology, efficient FPGA hardware is derived achieving good performance. Two architectures for heat flow computations are synthesized for an FPGA and evaluated. To show the general applicability of the design methodology, several applications have been implemented.

This paper introduces the hardware specification system CλaSH by elaborating on a few non-trivial examples. CλaSH is a compiling system that translates a subset of Haskell into synthesizable VHDL by a rewriting technique. This subset of Haskell includes higher order functions, polymorphism, lambda abstraction, pattern matching, and choice constructs.

Performing accurate Named Entity (NE) classification (NEC) has recently become a central issue in many NLP applications, such as Information Extraction and Question Answering, among others. Most state-of-the-art NEC systems use coarse-grained MUC-style datasets for ...

In this article we present the implementation of an environment supporting Lévy's optimal reduction for the λ-calculus [Lév78] on parallel (or distributed) computing systems. In a similar approach to Lamping's one in [Lam90], we base our work on a graph reduction technique known as directed virtual reduction [DPR97] which is actually a restriction of Danos-Regnier virtual reduction . The environment, which we refer to as PELCR (Parallel Environment for optimal Lambda-Calculus Reduction) relies on a strategy for directed virtual reduction, namely half combustion. While developing PELCR we have adopted both a message aggregation technique, allowing a reduction of the communication overhead, and a fair policy for distributing dynamically originated load among processors. Additionally, we have used a set of other optimizations, e.g. allowing the maintenance of relatively low size for the manipulated data structures so not to incur problems related to their management at the application level or due to the management of large process memory images at the operating system level. We also present an experimental study demonstrating the ability of PELCR to definitely exploit parallelism intrinsic to λ-terms while performing the reduction. We show how PELCR allows achieving up to 70/80% of the ideal speedup on last generation multiprocessor computing systems. As a last note, the software modules have been developed with the C language and using a standard interface for message passing, i.e. MPI, thus making PELCR itself a highly portable software package.

Kilim: A Server Framework with Lightweight Actors, Isolation Types & Zero-copy Messaging Sriram Srinivasan Internet services are implemented as hierarchical aggregates of communicating components: networks of data centers, networks of clusters in a data center, connected servers in a cluster, and multiple virtual machines on a server machine, each containing several operating systems processes. This dissertation argues for extending this structure to the intra-process level, with networks of communicating actors. An actor is a single-threaded state machine with a private heap and a thread of its own. It communicates with other actors using well-defined and explicit messaging protocols. Actors must be light enough to comfortably match the inherent concurrency in the problem space, and to exploit all available parallelism. Our aims are two-fold: (a) treat SMP systems as they really are: distributed systems with eventual consistency, and (b) recognize from the outset that a server is always part of a larger collection of communicating components, thus eliminating the mindset mismatch between concurrent programming and distributed programming. Although the actor paradigm is by no means new, our design points are informed by drawing parallels between the macro and micro levels. As with components in a distributed system, we expect that actors must be isolatable in a number of ways: memory isolation, fault isolation, upgrade isolation, and execution isolation. The application should be able to have a say in actor placement and scheduling, and actors must be easily monitorable. To Alka, my dearest. Life's a wonderful journey, and I have the best travel companion. To Amma and Appa, for the easy laughter, love and encouragement, and the early mornings and late nights they have lavished on me. This dissertation is dedicated to Amma. She would have exclaimed "hai"! To my parents-in-law, for being an additional set of parents. One should be so lucky. To my advisors. Prof. Jean Bacon, for making this excursion possible, for allowing me to gradually discover my interests and strengths without pressure, and for her gentle and selfless guidance to collaborate with other groups. To Prof. Alan Mycroft, for setting distant Bézier control points that so significantly influenced the arc of my learning, for his exhortations and for his unwavering belief that I would get there. To Dr. Ken Moody, for his critical reading of my papers and this document, for his cheerful and enthusiastic cross-pollination of ideas, and tours of beers and wines. To Reto Kramer, for his friendship, guidance, technical knowledge, and a brain the size of a planet. There are a few dissertations lurking in there. To Lauri Pesonen and David Pearce, for the critical reviews, for the long coffee sessions packed with techie talk, and for sharing my enthusiasm for programming languages. To Eiko Yoneki, Pedro Brandão, David Eyers, Dave Evans, Minor Gordon and Niko Matsakis for sharing their impressive knowledge, opinions and good humor, for challenging my biases and assumptions, and for the gentle prodding to get on with it. To Boris Feigin and Kathryn Gray for introducing me to the world of types and semantics, and holding me accountable to rigor.

This paper presents a novel gate sizing methodology to minimize the leakage power in the presence of process variations. The leakage and delay are modeled as posynomials functions to formulate a geometric programming problem. The existing statistical leakage model of is extended to include the variations in gate sizes as well as systematic variations. We propose techniques to efficiently evaluate constraints on the α-percentile of the path delays without enumerating the paths in the circuit. The complexity of evaluating the objective function is O(|N | 2 ) and that of evaluating the delay constraints is O(|N | + |E|) for a circuit with |N | gates and |E| wires. The optimization problem is then solved using a convex optimization algorithm that gives an exact solution.

We describe a computer program that proves theorems using mathematical induction. It is used to prove properties of computer programs. Helpful tips guide the program's search for a proof. These tips are used to form proof plans, which describe the structure of proofs at multiple levels. We are attempting to discover general-purpose proof plans which describe the common structure in families of similar proofs. This study constitutes a new science of reasoning in which mathematical proofs are the objects of analysis.

Many analysis problems can be cast in the form of evaluating minimal models of a logic program. Although such formulations are appealing due to their simplicity and declarativeness, they have not been widely used in practice because, either existing logic programming systems do not guarantee completeness, or those that do have been viewed as too inefficient for integration into a compiler. The objective of this paper is to re-examine this issue in the context of recent advances in implementation technologies of logic programming systems. We find that such declarative formulations can indeed be used in practical systems, when combined with the appropriate tool for evaluation. We use ezisting formulations of analysis problems -groundless analysis of logic programs, and strictness analysis of functional programs -in this case study, and the XSB system, a table-baaed logic programming system, as the evaluation tool of choice. We give experimental evidence that the resultant groundless and strictness analysis systems are practical in terms of both time and space. In terms of implementation effort, the analyzers took less than 2 man-weeks (in total), to develop, optimize and evaluate. The analyzer itself consists of about 100 lines of tabled Prolog code and the entire system, including the components to read and preprocess input programs and to collect the analysis results, consists of about 500 lines of code.

HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers. L'archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Nested datatypes have been widely studied in the past 25 years, both theoretically using category theory, and practically in programming languages such as HASKELL. They consist in recursive polymorphic datatypes where the type parameter changes throughout the recursion. They have a variety of applications such as modelling memory or modelling constraints over regular datatypes without relying on dependent types. In this work, we focus on a specific subset of nested datatypes which we call Linked Nested DataTypes (LNDT). We show that some usual datatypes such has List and Maybe, as well as some well-known nested datatypes such as Nest and even Bush can be built as various instances of LNDT. We proceed by presenting LIBNDT, a library, developed both in AGDA and COQ, which focuses on the set of constructs that can be spread directly from the parameter on which a LNDT is built, to the LNDT itself. These spreadable elements are of two kinds, functions, such as folds and map, and properties, such as the congruence of map or the satisfaction of a given predicate for at least one, or all, elements of the structure. We make use of the dependent type system of both COQ and AGDA to model the latter. This paper ends with a discussion about various interesting topics that were raised throughout our development such as the issue of termination, the comparison of our tools and the proof effort required to extend LIBNDT with additional elements.

HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers. L'archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

In this paper we introduce Chisel, a new hardware construction language that supports advanced hardware design using highly parameterized generators and layered domain-specific hardware languages. By embedding Chisel in the Scala programming language, we raise the level of hardware design abstraction by providing concepts including object orientation, functional programming, parameterized types, and type inference. Chisel can generate a high-speed C++-based cycleaccurate software simulator, or low-level Verilog designed to map to either FPGAs or to a standard ASIC flow for synthesis. This paper presents Chisel, its embedding in Scala, hardware examples, and results for C++ simulation, Verilog emulation and ASIC synthesis.

In order to develop portable parallel software a. reasonable abstraction from parallel hardware is necessary. Over the last few years, such abstractions have become available in the form of communication libraries. In this paper we first look at the mapping of parallel programs onto networks and we show how this can be generalized into a small but powerful communication library. The focus of the discussion is on the derivation of the processes implementing the library. During the design, efficiency is a key issue. In particular, we pursue a low latency for communications by avoiding buffering as much as possible. 1 An important reason to construct parallel programs is that a high performance may be achieved when such a program is executed by a parallel machine. With this prospect of increased performance as a driving force, programs were often designed for a particular target architecture. Since many different architectures have become available this resulted in special-purpose solutions. It has been recognized that this frustrates the development of portable software, i.e., of software that can be used on a new . architecture after only minor modifications. Another approach to parallel programming is to develop programs for some idealized model of a parallel computer, e.g., for a PRAM ([9]). Although this has lead to important results in complexity analysis it has not lead to practical methods to develop parallel programs, partly because these idealized models cannot be implemented realistically. These developments have lead to the definition of models that are both general and admit an efficient implementation on a variety of architectures. One such model is the Bulk Synchronous Computer (BSP, [12]). In this model, the parallel machine consists of a set of processors, each having a local memory. Each processor has access to all non-local memories in a uniform and efficient way. Each processor executes the same program, acting on local data. Such a program consists of a sequence of computation and communication steps. Each communication step is basically a rearrangement of information in the local memories. The importance of such a model is that it admits a reasonably simple performance analysis and that it can be implemented straightforwardly as we show in this paper. Other models are the

In this paper we develop an algorithm to compute explicit robust MPC solutions for constrained MIMO systems with internal uncertainties and external disturbances. The approach is based on a rewinding prediction strategy to realize the finite horizon robust MPC regulator, which has the feature that only one-step state prediction is sufficient to realize robust MPC with an arbitrary predictive horizon. The paper defines a set of sub-optimization problems as multiple-parametric subquadratic programming (mp-SQP), and shows that the optimal solution to the mp-SQP problem is piece-wise affine functions of states, associated with piece objectives and state critical regions. Asymptotic closed-loop stability can be guaranteed by a terminal weighting and a terminal feedback gain; also by introducing two tuning variables, the algorithm is capable of adjusting the tradeoff between system performance and robustness.

We give a presentation of a trace-based semantics of Core ELLA, a covering subset of the commercial hardware description language ELLA, using a synchronous process algebra called ELLA PROCESS ALGEBRA (EPA). This report is a semantics reference manual for ELLA, giving a detailed definition of the behaviour of ELLA expressions on a construct by construct basis. EPA is an instantiation of a generic Process Algebra Framework (PAF). It supports parameterised process calls, and has highly structured actions representing pairs of input/output maps labelling its transitions. The EPA process terms reprsenting ELLA are constructed compositionally following the structure of ELLA expressions. Primitive terms, corresponding to atomic operations in ELLA, are assembled using a small set of process operators. In particular the parallel composition operator models synchronous communication between components and is effected by a special product operation on actions. The EPA terms resulting from the compilation of ELLA expressions can be translated into a special normal form, which is essentially a symbolic state machine representation. This forms the basis for semi-automated high-level symbolic manipulation and reasoning tools. The work has been conducted as part of a collaborative project sponsored by the DTI and SERC, involving Manchester, DRA (Malvern) and Harlequin Ltd. (Cambridge), with GEC Plessey Semiconductors (Swindon) as evaluators. The aim of the project has been to provide formal verification support tools which are amenable to the industrial hardware designer. Using the formal semantics as a basis, software tools for ELLA compilation, normalisation, (ground-term/symbolic) simulation, (enumerated/symbolic) verification and ELLA-to-ELLA rewriting have been implemented by the project partners, and embedded into an integrated ELLA Design and Verification Environment.

Nested datatypes have been widely studied in the past 25 years, both theoretically using category theory, and practically in programming languages such as HASKELL. They consist in recursive polymorphic datatypes where the type parameter changes throughout the recursion. They have a variety of applications such as modelling memory or modelling constraints over regular datatypes without relying on dependent types. In this work, we focus on a specific subset of nested datatypes which we call Linked Nested DataTypes (LNDT). We show that some usual datatypes such has List and Maybe, as well as some well-known nested datatypes such as Nest and even Bush can be built as various instances of LNDT. We proceed by presenting LIBNDT, a library, developed both in AGDA and COQ, which focuses on the set of constructs that can be spread directly from the parameter on which a LNDT is built, to the LNDT itself. These spreadable elements are of two kinds, functions, such as folds and map, and properties, such as the congruence of map or the satisfaction of a given predicate for at least one, or all, elements of the structure. We make use of the dependent type system of both COQ and AGDA to model the latter. This paper ends with a discussion about various interesting topics that were raised throughout our development such as the issue of termination, the comparison of our tools and the proof effort required to extend LIBNDT with additional elements.

Despite several architectural advantages for the challenges of future manufacturing systems, the IEC 61499 standard is currently not widely accepted by industry. One advantage of the IEC 61499 is the concept of downtimeless system evolution. An extension of this, dynamic software updating, which allows switching out running processes and deal with unplanned changes, is readily available in the programming language Erlang. This paper investigates the real-time performance of an asynchronous, parallel IEC 61499 basic function block implementation in Erlang, a functional programming language with a soft real-time, concurrent runtime environment. As a result, although hard real-time performance is not guaranteed and the runtime environment is executed on top of a regular operating system, the performance is consistent and promising for future implementations and extensions.

Programs which perform partial evaluation, beta-expansion, and certain optimizations on programs, are studied with respect to implementation and application. Two implementations are described, one "'interpretive" partial evaluator, which operates directly on the program to be partially evaluated, and a "compi/ing" system, where the program to be partially evaluated is used to generate a specialized program, which in its turn is executed to do the partial evaluation. Three applications with different requirements on these programs are described. Proofs are given for the equivalence of the use of the interpretive system and the compili.,:g system in two of the three cases. The general use of the partial evaluator as a tool for the programmer in conjunction with certain programming techniques is discussed. Partial evaluation has traditionally been considered as a toy, to be used only as a subroutine in very experimental research programs. The present paper argues that if properly developed and utilized, partial evaluation can also be very useful as a practical working tool for the serious programmer. The paper describes a set of programs for partial evaluation (Sections 3 and 8), and experiments which have been done with them (Sections 4-6), as well as of how such programs can be put to use (the remaining sections). Some figures from the experiments are to be found in the appendix. In the simplest case, a partial evaluation program is a progra~ which takes a procedure P of some arguments (xl, xy,..., xn) together with values (cl,..., c,) for the first m of these n arguments, and which generates a new procedure P' such that P' (xm+~,..., xn) = P(ct,..., c,, xm+l,..., xn) for all x. In doing so, it

Insertion Sort is a simple and intuitive sorting algorithm that works similarly to the way you might sort playing cards in your hands. It builds the sorted array one element at a time by repeatedly taking an element from the unsorted portion and inserting it into its correct position in the sorted portion.

Resumen En este trabajo presentamos una propuesta para apoyar la enseñanza de métodos formales en una currícula de grado, usando el asistente de pruebas Coq y conceptos del área de Teoría de Tipos. Proponemos un curso/taller de especificación, ...

Strategisches Management ist häufig extern orientiert: Organisationen wollen Einfluss auf Stakeholder wie Kunden, Lieferanten oder Politik nehmen, um günstige Umfeldbedingungen zu schaffen. Doch in Märkten, die von den Aktivitäten zahlreicher Akteure geprägt sind, ergeben sich vielfältige Wechselwirkungen und daraus eine Dynamik, die nur begrenzt von einzelnen Playern gesteuert werden kann. Als Alternative zur klassischen inside-out-Perspektive fokussiert die outside-in-Perspektive auf die Steuerungspotenziale der eigenen Organisation. Die von Stefan Kühl entwickelte Strukturmatrix bietet dafür eine wertvolle Grundlage – ein Konzept, das ich in diesem improve Praxisletter kompakt darstelle.

There has been a lot of interest recently in the problem of building object-oriented applications by somehow combining other application fragments that provide their own overlapping definitions or expectations of the same domain objects. We propose an approach based on the split objects model of prototype languages whereby an application object is represented by a varying set of instances--called views--that implement different parts of its domain behavior but that delegate its core functionalities to a core instance: an object's response to a message depends on the views currently attached to its core instance. Our approach is not purely prototype-based in the sense that core instances and views are members of classes. Further, we recognize that the behavior inherent in views (classes) is often an adaptation of a generic behavior to the domain object at hand, and define viewpoints as parameterized class-like algebraic structures to embody such a generic behavior. In this paper, we first describe view programming from the perspective of the developer. Next, we sketch a semi-formal model of view programming, and describe the steps needed to implement it in a class-based statically typed language, for instance, C++. Third, we look at the challenges and opportunities provided by view programming to support safe, robust, and efficient distributed applications.

Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary. Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language that is flexible enough to support most of the major programming paradigms in use today. Scheme was one of the first programming languages to incorporate first-class procedures as in the lambda calculus, thereby proving the usefulness of static scope rules and block structure in a dynamically typed language. Scheme was the first major dialect of Lisp to distinguish procedures from lambda expressions and symbols, to use a single lexical environment for all variables, and to evaluate the operator position of a procedure call in the same way as an operand position. By relying entirely on procedure calls to express iteration, Scheme emphasized the fact that tail-recursive procedure calls are essentially gotos that pass arguments. Scheme was the first widely used programming language to embrace first-class escape procedures, from which all previously known sequential control structures can be synthesized. A subsequent version of Scheme introduced the concept of exact and inexact SRFIs that served as direct input to the report. Casey Klein found and fixed several bugs in the formal semantics.

The integration of functional and logic programming languages has been a topic of great interest in the last decade. Many proposals have been made, yet none is completely satisfactory especially in the context of higher order functions and lazy evaluation. This paper addresses these shortcomings via a new approach:domain theoryas a common basis for functional and logic programming. Our integrated language remains essentially within the functional paradigm. The logic programming capability is provided byset abstraction(via Zermelo-Frankel set notation), using the Herbrand universe as a set abstraction generator, but for efficiency reasons our proposed evaluation procedure treats this generator's enumeration parameter as a logical variable. The language is defined in terms of (computable) domain-theoretic constructions and primitives, using the lower (or angelic) powerdomain to model the set abstraction facility. The result is a simple, elegant and purely declarative language that...

The software industry has identified, in a vast proportion, the object-oriented programming paradigm with the variant based in classes and single inheritance. Particularly, design patterns and their best-known implementations are largely conceived for this traditional object model. However, the last years have witnessed a steady growth of the popularity of several alternative models, which allow for different ways to organise the definition of object behavior. This paper shows non-standard implementations of the decorator design pattern, which exploit behavior sharing and refining features unique to alternative models. We claim that these features allow for more natural renderings of the pattern and avoid a well-known flaw of the classical implementation, i.e. the loss of object identity.

The preprocessor of the C language provides a standard way to generate code at compile time. However, writing and understanding these macros is difficult. Lack of typing, statelessness and uncommon syntax are the main reasons of this difficulty. Haskell is a high-level purely functional language with expressive type system, algebraic data types and many useful language extensions. These suggest that Haskell code can be written and maintained easier than preprocessor macros. Functional languages have certain similarities to macro languages. By using these similarities this paper describes a transformation that translates lambda expressions into preprocessor macros. Existing compilers for functional languages generate lambda expressions from the source code as an intermediate representation. As a result it is possible to write Haskell code that will be translated into preprocessor macros that manipulate source code. This may result in faster development and maintenance of complex macr...

We present ert , a type theory supporting refinement types with explicit proofs. Instead of solving refinement constraints with an SMT solver like DML and Liquid Haskell, our system requires and permits programmers to embed proofs of properties within the program text, letting us support a rich logic of properties including quantifiers and induction. We show that the type system is sound by showing that every refined program erases to a simply-typed program, and by means of a denotational semantics, we show that every erased program has all of the properties demanded by its refined type. All of our proofs are formalised in Lean 4.

In the early stages of the building design process, during the programming and the proposal stages, both user activities and the building are in focus for the designer. In spite of this, today's CAD programs give no support for management of information about user activities in the building. This paper discusses the requirements on modelling user activities in the context of building design and presents a prototype software. The prototype is developed as an add-on to the architectural design software ArchiCAD.

Motivated by the search for a body of mathematical theory to support the semantics of computational effects, we first recall the relationship between Lawvere theories and monads on Set. We generalise that relationship from Set to an arbitrary locally presentable category such as Poset and ωCpo or functor categories such as [Inj, Set] and [Inj, ωCpo]. That involves allowing the arities of Lawvere theories to be extended to being size-restricted objects of the locally presentable category. We develop a body of theory at this level of generality, in particular explaining how the relationship between generalised Lawvere theories and monads extends Gabriel-Ulmer duality.

The choice of the programming language impacts the efficiency of the application and the robustness of the code. The characteristics of Erlang as a functional programming language supported distributed real time computing allowed us to propose eDDS: an Erlang based middleware compliant to the Data Distribution Service (DDS) standard that providing a strong Quality of Service (QoS) support. When the performance and the compliance to the norm have been easy achieved in particular on defining and setting QoS parameters, the lack of efficient and user-friendly support for data type management has been noticed. In this paper, we will explain this type checking problem and how we solved it.

The Centers for Disease Control and Prevention began funding a Smoke Alarm Installation and Fire Safety Education (SAIFE) program in 1998. This program involves the installation of lithium-powered ''10-year'' smoke alarms in homes at high risk for fires and injuries. This study aimed to (1) determine among original SAIFE homes if the lithium-powered alarms were still present and functional 8-10 years after installation and (2) understand factors related to smoke alarm presence and functionality. Data on a total of 384 homes and 601 smoke alarms in five states were collected and analyzed. Only one-third of alarms were still functional; 37% of installed alarms were missing; and 30% of alarms were present, but not functioning. Alarms were less likely to be functioning if they were installed in the kitchen and if homes had a different resident at follow-up. Of the 351 alarms that were present and had a battery at the time of the evaluation, only 21% contained lithium-powered batteries. Of these, 78% were still functioning. Programs that install lithium-powered alarms should use units that have sealed-in batteries and ''hush'' buttons. Additionally, education should be given on smoke alarm maintenance that includes a message that batteries in these alarms should not be replaced. Lithiumpowered smoke alarms should last up to 10 years if maintained properly.

Development of the methodology of designing of electronic textbooks with an opportunity of individual learning strategy's identification is considered in the article. In this regard a formal approach aimed at research of knowledge testing results is suggested on the basis of the hierarchical structures. Analytical decision of the objective has been elaborated and realised in practice in Common Lisp language.

is a Research and Training Centre of the United Nations University (UNU). It is based in Macau, and was founded in 1991. It started operations in July 1992. UNU-IIST is jointly funded by the Governor of Macau and the governments of the People's Republic of China and Portugal through a contribution to the UNU Endownment Fund. As well as providing twothirds of the endownment fund, the Macau authorities also supply UNU-IIST with its office premises and furniture and subsidise fellow accommodation. The mission of UNU-IIST is to assist developing countries in the application and development of software technology. UNU-IIST contributes through its programmatic activities: 1. Advanced development projects, in which software techniques supported by tools are applied, 2. Research projects, in which new techniques for software development are investigated, 3. Curriculum development projects, in which courses of software technology for universities in developing countries are developed, 4. University development projects, which complement the curriculum development projects by aiming to strengthen all aspects of computer science teaching in universities in developing countries, 5. Schools and Courses, which typically teach advanced software development techniques, 6. Events, in which conferences and workshops are organised or supported by UNU-IIST, and 7. Dissemination, in which UNU-IIST regularly distributes to developing countries information on international progress of software technology. Fellows, who are young scientists and engineers from developing countries, are invited to actively participate in all these projects. By doing the projects they are trained. At present, the technical focus of UNU-IIST is on formal methods for software development. UNU-IIST is an internationally recognised center in the area of formal methods. However, no software technique is universally applicable. We are prepared to choose complementary techniques for our projects, if necessary. UNU-IIST produces a report series. Reports are either Research R , Technical T , Compendia C or Administrative A. They are records of UNU-IIST activities and research and development achievements. Many of the reports are also published in conference proceedings and journals. Please write to UNU-IIST at P.O. Box 3058, Macau or visit UNU-IIST's home page: http://www.iist.unu.edu, if you would like to know more about UNU-IIST and its report series.

The idea of using unfolding as a way of computing a program semantics has been applied successfully to logic programs and has shown itself a powerful tool that provides concrete, implementable results, as its outcome is actually source code. Thus, it can be used for characterizing not-so-declarative constructs in mostly declarative languages, or for static analysis. However, unfolding-based semantics has not yet been applied to higher-order, lazy functional programs, perhaps because some functional features absent in logic programs make the correspondence between execution and unfolding not as straightforward. This work presents an unfolding semantics for higher-order, lazy functional programs and proves its adequacy with respect to a given operational semantics. Finally, we introduce some applications of our semantics.