Possible projects

• Develop a compiler from a subset of C (e.g. micro-C) to the Hitachi H8 embedded processor, and determine experimentally the energy cost of different ways to compile the same source code. For embedded software in battery-driven devices, energy cost is just as important as program speed.
• Study Javascript (a dynamically typed class-less object-oriented language), describe how it realizes inheritance, and implement some examples. modsætning til Java).
• Implement type checking for micro-C.
• The language Icon permits so-called goal-directed evaluation. Write a small Icon implementation using continuations in Standard ML. Ignore the imperative facilities (except write); they are pretty strange. See D A Gudeman: Denotational semantics of a goal-directed language. ACM TOPLAS 14, 1 (1992) 107-125.
• Study the Cyclone programming language, a statically safe dialect of C. Implement some programs in Cyclone, or reimplement C programs in Cyclone by adding type annotations.
• Study Microsoft's C# programming language, describe differences and similarities to Java, and implement pedagogical examples that highlight the differences. The latter could be done in the style of a phrasebook: if you would write this in Java, you must write so and so in C#; or this construct in C# means so and so in Java.
• Microsoft's Common Language Runtime has support for runtime code generation (in the System.Reflection.Emit namespace). Use runtime code generation to speed up a parametrized algorithm, e.g. to generate specialized code for multiplication of NxN matrices for given N, or to generate a specialized regular expression matcher for a given regular expression. Evaluate the efficiency and speed-ups. See also Morten Rhiger's work.
• Study Microsoft Intermediate Language MSIL and formalize (part of) it, by writing an interpreter or using inference rules in the style of Peter Bertelsen's dynamic defensive semantics for the Java Virtual Machine.
• Generate MSIL code (as text, in MSIL assembly format, and compile with ilasm) from a simple functional, imperative, or object-oriented language.
• Generate stack-oriented x86 machine code instead of our homemade stack machine code from micro-C. The assembly code can be generated as input to the GNU assembler gas, or perhaps even more simply, as inline asm instructions in C code for GNU gcc to compile.
• Implement Java exceptions and the try-catch-finally statement in the micro-Java interpreter. See e.g. Bart Jacobs: A Formalisation of Java's Exception Mechanism, ESOP 2001, for details.
• Implement Danvy and Filinski's conversion to continuation-passing style for a small functional language.
• Implement a lazy functional language using the machine model from Sestoft: Deriving a Lazy Abstract Machine (1997).
• Write a compiler (in SML or Java) for Martin Richards's language VSPL (Very Simple Programming Language). You may compile to JVM. Unfortunately, VSPL isn't that simple after all, and may be too much work for a four-week project.
• Study the tool Extended Static Checking for Java (ESC/Java), available for download at http://research.compaq.com/SRC/esc/. It seems to require JDK 1.3 (does not work with JDK 1.4). Download and install also the JDK spec files from the ESC/Java Web site. Take some existing non-trivial Java programs, annotate them, and apply the ESC/Java tool to them. Report on your experience: How hard is it to write annotations to satisfy the checker? Did you find any errors in the process? If possible, compare with other tools for Java, C, or C++.
• Make Moscow ML generate MSIL intermediate code instead of the current Caml Light intermediate code. (This is a long-term project, but some preliminary investigations and analysis may very well be carried out in a four-week project).
• Develop a language for formalizing study plan constraints such as `any SWU student must pass at least two courses within each of the categories Process-oriented Courses and Technical Courses, and must do at least one Program Construction Project'. Design a grammar, lexer and parser specifications, an abstract syntax, and a checker that for any given student can check that the constraints are satisfied. It would be useful to be able to pretty-print the constraints also in (almost) natural language, for general comprehensibility. Inspiration can be gotten from Niels Hallenberg, IT-C, and Michael Schwartzbach, Aarhus University.
• Suggested by Lars Birkedal: Implement a generational garbage collector for the ML Kit implementation of Standard ML. This requires some familiarity with the C programming language. This project is large enough for a Master's thesis; it should include a study of the various kinds of garbage collectors, design, implementation and experimental evaluation. It is a good idea to start with a four week project to familiarize oneself with the area.
• Implement an XML-parser and other XML tools in Standard ML. For instance, given a representation of a Document Type Definition (DTD) or an XML Schema, validate XML documents.
• Compile micro-C to Parrot, the forthcoming Perl Abstract Machine; see http://www.parrotcode.org/. This is not a stack-based abstract machine, so you will need to learn about register allocation (e.g. from Torben Mogensen's Basics of Compiler Design).