83 research outputs found
Exploring C++
This book is intended for use by C programmers who want to learn C++ . . . fast. It may also be helpful for Java programmers learning C++ . It assumes that the reader knows basic programming including types, control structures, functions, arrays, pointers, and simple data structures. The material should help you develop a deep understanding of clean program design and the features that make C++ a powerful and flexible language.https://digitalcommons.newhaven.edu/electricalcomputerengineering-books/1001/thumbnail.jp
Some History of Functional Programming Languages
We study a series of milestones leading to the emergence of lazy, higher order, polymorphically typed, purely functional programming languages. An invited lecture given at TFP12, St Andrews University, 12 June 2012
Programmiersprachen und Rechenkonzepte
Seit 1984 veranstaltet die GI-Fachgruppe "Programmiersprachen und Rechenkonzepte", die aus den ehemaligen Fachgruppen 2.1.3 "Implementierung von Programmiersprachen" und 2.1.4 "Alternative Konzepte für Sprachen und Rechner" hervorgegangen ist, regelmäßig im Frühjahr einen Workshop im Physikzentrum Bad Honnef. Das Treffen dient in erster Linie dem gegenseitigen Kennenlernen, dem Erfahrungsaustausch, der Diskussion und der Vertiefung gegenseitiger Kontakte
Lazy functional parser combinators in Java
A parser is a program that checks if a text is a sentence
of the language as described by a grammar. Traditionally, the program
text of a parser is generated from a grammar description, after which it is
compiled and subsequently run. The language accepted by such a parser
is, by the nature of this process, hardcoded in the program. Another
approach, primarily taken in the context of functional languages, allows
parsers to be constructed at runtime, thus dynamically creating parsers
by combining elements from libraries of higher level parsing concepts; this
explanins the the name "parser combinators". Efficient implementation
of this concept relies heavily on the laziness that is available in modern
functional languages [13, 14]. This paper shows how to use parser combinators
in a functional language as well as Java, and shows how parser
combinators can be implemented in Java. Implementing parser combinators
is accomplished by combining two libraries. The first one, written
in Haskell, defines error-correcting and analysing parser combinators [2].
The second one consists of a small Java library implementing lazy functional
behavior. The combinator library is straightforwardly coded in
Java, using lazy behavior where necessary. In this paper all three aspects,
the two libraries and its combination, are explained
Certifying cost annotations in compilers
We discuss the problem of building a compiler which can lift in a provably
correct way pieces of information on the execution cost of the object code to
cost annotations on the source code. To this end, we need a clear and flexible
picture of: (i) the meaning of cost annotations, (ii) the method to prove them
sound and precise, and (iii) the way such proofs can be composed. We propose a
so-called labelling approach to these three questions. As a first step, we
examine its application to a toy compiler. This formal study suggests that the
labelling approach has good compositionality and scalability properties. In
order to provide further evidence for this claim, we report our successful
experience in implementing and testing the labelling approach on top of a
prototype compiler written in OCAML for (a large fragment of) the C language
An intensional implementation technique for functional languages
The potential of functional programming languages has not been
widely accepted yet. The reason lies in the difficulties associated with
their implementation. In this dissertation we propose a new
implementation technique for functional languages by compiling them
into 'Intensional Logic' of R. Montague and R. Carnap. Our technique is
not limited to a particular hardware or to a particular evaluation
strategy; nevertheless it lends itself directly to demand-driven tagged
dataflow architecture. Even though our technique can handle
conventional languages as well, our main interest is exclusively with
functional languages in general and with Lucid-like dataflow languages
in particular.
We give a brief general account of intensional logic and then
introduce the concept of intensional algebras as structures (models) for
intensional logic. We, formally, show the computability requirements for
such algebras.
The target language of our compilation is the family of languages
DE (definitional equations over intensional expressions). A program in
DE is a linear (not structured) set of non-ambiguous equations defining
nullary variable symbols. One of these variable symbols should be the
symbol result.
We introduce the compilation of Iswim (a first order variant of
Landin's ISWIM) as an example of compiling functions into intensional
expressions. A compilation algorithm is given. Iswim(A), for any algebra
of data types A, is compiled into DE(Flo(A)) where Flo(A) is a uniquely
defined intensional algebra over the tree of function calls. The approach
is extended to compiling Luswim and Lucid.
We describe the demand-driven tagged dataflow (the eduction)
approach to evaluating the intensional family of target languages DE.
Furthermore, for each intensional algebra, we introduce a collection of
rewrite rules. A justification of correctness is given. These rules are the
basis for evaluating programs in the target DE by reduction.
Finally, we discuss possible refinements and extensions to our
approach
A formally verified compiler back-end
This article describes the development and formal verification (proof of
semantic preservation) of a compiler back-end from Cminor (a simple imperative
intermediate language) to PowerPC assembly code, using the Coq proof assistant
both for programming the compiler and for proving its correctness. Such a
verified compiler is useful in the context of formal methods applied to the
certification of critical software: the verification of the compiler guarantees
that the safety properties proved on the source code hold for the executable
compiled code as well
- …