Jeroen D. Fokker

The architecture of the Utrecht Haskell compiler

In this paper we describe the architecture of the Utrecht Haskell Compiler (UHC). UHC is a new Haskell compiler, that supports most (but not all) Haskell 98 features, plus some experimental extensions. It targets multiple backends, including a bytecode interpreter backend and a whole-program analysis backend, both via C. The implementation is rigorously organized as stepwise transformations through some explicit intermediate languages. The tree walks of all transformations are expressed as an algebra, with the aid of an Attribute Grammar based preprocessor. The compiler is just one materialization of a framework that supports experimentation with language variants, thanks to an aspect-oriented internal organization.

Abstract Interpretation of Functional Programs using an Attribute Grammar System

We describe an algorithm for abstract interpretation of an intermediate language in a Haskell compiler, itself also written in Haskell. It computes approximations of possible values for all variables in the program, which can be used for optimizing the object code. The analysis is done by collecting constraints on variables, which are then solved by fixpoint iteration. The set of constraints grows while solving, as possible values of unknown functions become known. The constraints are collected by decorating the abstract syntax tree with an attribute grammar based preprocessor for Haskell. An introduction to this preprocessor is also given.

The Structure of the Essential Haskell Compiler, or Coping with Compiler Complexity

In this paper we describe the structure of the Essential Haskell Compiler (EHC) and how we manage its complexity, despite its growth from essentials to a full Haskell compiler. Our approach splits both language and implementation into smaller, manageable steps, and uses specific tools to generate parts of the compiler from higher level descriptions.

The systematic construction of a one-combinator basis for Lambda-Terms

A single closed λ-expression that generates all λ-expressions is constructed. The derivation is carried out with simplicity as driving force. The result is simpler than single-combinator bases known in the literature.

Functional Specification of JPEG Decompression, and an Implementation for Free

A decoder for images compressed by the JPEG algorithm is stated in the pure functional programming language Gofer. The program can be regarded as a mathematical specification of the decompression algorithm; the concise description (which is included almost in full) is very suitable for learning about the algorithm. At the same time the ‘specification’ is an executable program, which shows the usefulness of a functional programming language as a prototyping tool for graphics algorithms.

Explaining Algebraic Theory with Functional Programs

A hierarchy of six important structures from abstract algebra (groups, rings, fields etc.) is introduced as Gofer class definitions and laws about them. Many instance declarations are provided, explaining the algebraic construction of integers, quotients, adding i, function spaces, polynomials, and matrices. The definitions include generalized implementations of polynomial division and matrix inversion. Monadic parsers are provided for all constructs discussed. As an application, a one-line program is given for calculating the eigenvalue equation of a matrix.

Building Your First Game Application

This chapter provides an introduction to this book. In this chapter, we will explain which tools you are going to need, and how to set up a basic game development environment for programming a game in C#. We will also explain how to run the example projects.

Basic Game Objects

This chapter deals with organizing instructions in different methods and classes. You will learn how to write your own methods, properties, and classes, and how you can use these programming concepts to design different game object classes. We will discuss the difference between values and references and what the null keyword means in that context. Finally, we will show the difference between a class and a struct. We further develop the Painter game in this chapter to incorporate classes that are used to create the instances of the various game objects in the game.

Redesigning the Game World

Many things change over the course of running a game: levels are completed, the player’s character may change, new quests and enemies are introduced, and so on. In terms of programming games, this translates into more classes and changing relations between instances of these classes. There are, however, also a couple of things that will not change at all while a game is running. For example, the process for loading sprites and sounds will probably stay the same throughout the game, so the class that deals with this will not really change. In this chapter, we will investigate how to set up a class for dealing with various assets in a game, an instance of which is accessible to all the objects that need assets such as sprites and sounds.

Loading Levels from Files

Many games consist of different levels. Especially in casual games such as puzzles and maze games, the game may have several hundreds of levels. With the programming tools that we have seen thus far, we could add different levels to our game by, for example, writing a generic Level class, and then defining (hundreds of) subclasses, where each class defines what the particular level looks like. A much better approach, however, would be to store the different levels in a text file, and then read the information from this text file to create the levels. Then, if we want to add another level to our game, we do not have to change the source code but we can simply edit the text file. In this chapter, we will see how we can load levels from a text file using the C# file I/O classes. As an example, we will show how to create a tile-based game world based on information saved in a text file.