Domain Specific Languages
June 6, 2007
for the supplemental test are published.
May 14, 2007
Preparatory meeting for the supplemental test: May 23 (wed), 11:00-13:00, BBL-426.
May 3, 2007
All students have been sent an overview of their AFP results by email as well as a
detailed report explaining the grades for the programming assignment.
April 24, 2007
for the exam are published.
April 18, 2007
Results for the DSL assignment have just been sent by email. Other
results will follow soon.
April 17, 2007
Tomorrow's exam will take place in BBL-471
(contrary to the info on the course page).
April 14, 2007
Last Friday, email and webservers were down. Some of you tried but failed to submit
your ant solution by mail. Please retry as soon as possible.
April 11, 2007
of the ant tournament are available.
April 10, 2007
Tomorrow, there will be no lab session. The lecture starts at 11:00.
March 26, 2007
The last exercise
has been published. Since this announcement is rather late,
has been extended accordingly.
March 20, 2007
for some GADT examples.
March 7, 2007
Please fill in the DSL feedback form
for today's presentations.
March 6, 2007
The third exercise
has been published.
February 28, 2007
All meetings with the programming assignment teams will be in the BBL building: let's
meet near the coffee machines at the fourth floor.
February 26, 2007
The second exercise (wxHaskell) has been published.
February 20, 2007
Tomorrow morning there will be a lab session before the lecture.
February 14, 2007
Please read the paper about
before the next lecture (Monday).
The topic FFI is scheduled for Wednesday.
February 8, 2007
You can register
yourself as a Wiki user
(only from BBL machines).
If you mail me, please include
in the subject header.
DSL topics have been assigned (but not yet scheduled).
Also have a look at the old exam question about a
(answers are online).
January 30, 2007
Setup of AFP web for (winter) 2007.
All students have to further investigate one domain specific language: the available topics are listed below, and these will
be assigned in the first week. For each topic, a number of starting points (web sites, papers, etc.) are given. Given these
starting points, try to find
as much relevant information as possible about your assigned topic. The task consists of two parts:
- One 30 minute presentation (in English). You are encouraged to download existing software, to experiment with it, and to show us a (small) demo.
- A review report (about 2 pages). This report should contain at least the following ingredients.
- a summary
- the additional gain of embedding your assigned DSL in a functional language like Haskell.
- your opinion about and experiences with the combinator library.
For this assignment, students may work in pairs. The assignment may also be completed individually, as long as there are enough topics available.
All attendees are asked to submit their opinions: please fill in the feedback forms to be found below. Because these forms
will be processed automatically, you are asked to follow the subsequent instructions:
- Don't edit the lines starting with a
>: the positions where you are supposed to enter text are marked with parentheses.
- Fill in your name (referee).
- For each presentation, supply a mark (between 1 and 10, decimals allowed). You are encouraged to vary your marks. Your grade will contribute to the overall grade.
- For each presentation, provide some positive remarks (what did you like) and some constructive advice (what could be improved). These comments will be sent to your fellow students so don't be insulting or disrespectful. At the same time, constructive advice will be appreciated and will help to improve future presentations. A remark can be put on multiple lines.
- The feedback may be written in Dutch, unless a foreign student is involved. In this case, feedback in English is mandatory.
- You don't have to provide feedback on your own presentation: you may leave that part unchanged.
- Download the feedback form, insert your comments, and send it to me as a text file by email.
Please consult me in case the instructions above are not clear enough.
The feedback forms:
March 7 (Wednesday)
March 21 (Wednesday)
March 28 (Wednesday)
March 29 (Thursday)
Note that this presentation will take place at the regular
Software Technology Colloquium
1. XML Tools
A number of Haskell libraries exist for processing XML. These libraries typically offer facilities such as parsing, filtering, transforming, validating, and generating XML documents. Two well-known combinator libraries for processing XML are HaXML?
and The Haskell XML Toolbox.
2. Computer Music
(from the Haskore Computer Music System homepage
Haskore is a collection of Haskell modules designed for expressing musical structures in the high-level, declarative style of functional programming. In Haskore, musical objects consist of primitive notions such as notes and rests, operations to transform musical objects such as transpose and tempo-scaling, and operations to combine musical objects to form more complex ones, such as concurrent and sequential composition. From these simple roots, much richer musical ideas can easily be developed.
3. Diagram Editor Blobs
(from the Blobs homepage
Blobs is a front-end for drawing and editing graph diagrams. You must add your own back-end engine if you want it to do some analysis or processing of the graph. There are various analysis engines that use Blobs as a front-end, e.g. Dazzle for bayesian analysis of networks, FPTC for safety analysis of systems designs, and so on, but these are not currently available as open source. We do supply a couple of very simple engines, just to demonstrate how to connect the engine up to Blobs.
4. Haskell DB
(from the Haskell DB homepage
Haskell DB is a combinator library for expressing queries and other operations on relational databases in a type safe and declarative way. All the queries and operations are completely expressed within Haskell, no embedded (SQL) commands are needed. This close integration makes it possible to do arbitrary computations on the database (like computing the transitive closure) and makes it very easy to combine Haskell DB with other combinator libraries (like Erik Meijer's CGI library or John Hughes pretty printer).
5. Financial Combinators
(from Simon PJ's homepage
Financial and insurance contracts do not sound like promising territory for functional programming and formal semantics, but in fact we have discovered that insights from programming languages bear directly on the complex subject of describing and valuing a large class of contracts.
We introduce a combinator library that allows us to describe such contracts precisely, and a compositional denotational semantics that says what such contracts are worth. We sketch an implementation of our combinator library in Haskell. Interestingly, lazy evaluation plays a crucial role.
(from the Pan# homepage)
Pan# combines basic mathematical operations with functional abstraction and a simple vocabulary of images. This language puts the tools of visualization in the hands of the student and instructor rather than hiding them deep inside bundled software. Images are defined in a very simple and direct way, free of the details that tell a computer how to display the image. Because images are described using mathematical functions, this language is entirely appropriate for anyone with knowledge of basic algebra.
7. Pretty Printing
There are a number of combinator libraries around for pretty printing. Papers by
John Hughes and Philip Wadler describe the theory behind these libraries.
8. Server-side Web Scripting (WASH)
WASH/CGI is an EDSL for server-side Web scripting with Sessions, Compositional Forms, and Graphics.
9. Web Functions
Robert van Herk wrote his Master's thesis about Web Functions
Web Functions is a DSEL for developing websites, implemented in Haskell. Web Functions is a domain specific embedded language for web authoring, implemented in Haskell. The functionality of the Web Functions framework was inspired by Apple’s Web Objects (http://www.apple.com/WebObjects
(from the Yampa homepage)
Yampa is the culmination of our efforts to provide domain-specific embedded languages for the programming of hybrid systems using the concepts of Functional Reactive Programming (FRP). Yampa is structured using arrows, which greatly reduce the chance of introducing space- and time-leaks into reactive, time-varying systems.
Yampa was used to program the game entities of Frag, a 3D first person shooting game written in Haskell, by Mun Hon Cheong.
This article presents one approach to declarative programming of interactive content, as realized in a prototype system called Fran, for "Functional reactive animation" [Elliott and Hudak 1997, Elliott 1997]. Fran is a high level vocabulary that allows one to describe the essential nature of an animated model, while omitting details of presentation. Moreover, because this vocabulary is embedded in a modern functional programming language (Haskell), the animation models thus described are reusable and composable in powerful ways.
Lava is a hardware description language based upon the functional programming language Haskell. Its main aim is to show that modern programming language features such as type inference, polymorphism, higher-order functions, type classes, and laziness are very useful even in hardware description.
13. Haskell Server Pages
Haskell Server Pages (HSP) is an extension of vanilla Haskell, targetted at the task of writing dynamic server-side web pages.
14. Tangible Values
TV is a library for composing tangible values ("TVs"), i.e., values that carry along external interfaces
15. Dynamic Generation of HTML (WASH)
WASH/HTML is an EDSL for generating dynamic HTML documents.
16. Functional Meta Post
Functional Meta Post is a Haskell frontend to the Meta Post language by John Hobby