1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
\documentclass[a4paper]{article}
\usepackage[english]{babel}
\usepackage{geometry}
\usepackage[hidelinks]{hyperref}
\usepackage{natbib}
\title{High-level code processing in a functional style}
\author{Camil Staps}
\begin{document}
\maketitle
\begin{abstract}
As the tools provided by programming languages become more abstract and
semantically complex, it becomes necessary to have systems that can reason
about these programming languages on a high abstraction level. Functional
languages can aid interpreter and compiler designers: abstraction is trivial,
and in addition to that the use of a functional language makes it easier to
prove properties about programs. By means of a case study, an interpreter of
the language While \citep{proganal}, the advantages of functional languages
for code processing are shown.
\end{abstract}
\section{Introduction}
Compilers and interpreters are among the most complex pieces of software
written to date. Due to the rapid technological development of the last
decades, programming languages have become semantically so complex, that it is
impossible for a programmer to keep in mind the impact of changes on generated
machine code. This led to the \emph{assumption problem}: developers constantly
rely on assumptions about how the language that they write in works. Intuitive
semantics may change over time, however, and we cannot found a world relying so
principally on software as ours on contingent assumptions.
Algol 60 was the first language of which the semantics were precisely
documented \citep{algol}. Its report is the primary link between Algol
programmers and the compiler designers, clarifying the language for the first
and specifying it for the second. These kind of specifications were the first
solution to the assumption problem.
However, programming languages have evolved significantly since Algol 60, and
semantical specifications have become increasingly complex. Whereas the
assumption problem has been solved on the programmer's side, it has now
occurred on the compiler designer's side: the specification has become too
mathematically complex to efficiently translate it into imperative code, and
writing a correct compiler or interpreter is no longer trivial.
Functional programming languages offer writers of code processing systems tools
to efficiently implement semantical specifications. Using a higher level of
abstraction, the gap between specification and implementation is closed,
allowing for quicker correctness checks and better maintainable code. The
connections between functional languages and mathematics let us \emph{prove}
properties about code processing systems (for example, their correctness with
respect to a specification).
\bibliographystyle{jfp}
\bibliography{paper}
\end{document}
|
