Extensibility and Modularity in Programming Languages
In this seminar, we study questions of extensibility and modularity in programming languages, as well as proposed solutions, by reading research papers on the topic.
Many programming languages offer features which allow to extend the program in a safe way and without modifying existing code. For starters, there are two dimensions of extensibility to be considered: adding new variants, and adding new operations. The so-called Expression Problem asks how to achieve both in the same language while preserving the (type) safety and no-modification properties (and possibly others). Programming languages are often biased towards one of the two extensibility dimensions in that their constructs offer a straightforward way to either add new variants or new operations, but not both. Nevertheless, even for those languages there are encodings which, via sticking to a certain programming discipline/pattern, allow the programmer to independently add variants and operations. Such encodings usually come with limitations, e.g. in the specific form of variants or operations supported, and/or costs, e.g. in the form of the complexity of the necessary language constructs. A lot of research on the Expression Problem is about such trade-offs.
This is all part of a larger research effort on how to best group a program into modules, which can be considered and worked on independently of each other (e.g., using separate compilation) and which only communicate via well-defined interfaces, and how to design and/or use programming languages and their module systems accordingly.
More details will be announced through this page.
Structure of course
This seminar will be conducted as a paper reading group with weekly meetings.
Each week one of the students is the discussion leader, who familiarizes herself/himself with the paper’s content in greater depth. The other participants should also read the paper and prepare questions for the discussion leader. During the session, the discussion leader will summarize the main points of each section, be ready to answer the other participants’ questions, keep the discussion on track, and point out additional insights gained by her/his in-depth preparation.
At the end of the semester, each participant will write a term paper on the topic he prepared as discussion leader. It is also possible to accompany this with some artefact, e.g. a mini software project, that showcases some of the extensibility or modularity aspects discussed in the term paper.
Credits: 3 LP (new PO), 4 LP (old PO)
Weekly meeting: To be decided at the kick-off meeting (see below)
Contact email: julian (dot) jabs (at) uni-tuebingen (dot) de
(Instructor’s note: I’m a native speaker of German, so you can write me in German if you want to.)
17.10.2017 16:15-18:00, Room A302.
This is an (incomplete) list of papers to choose from, plus other relevant literature.
- D. Parnas, On the Criteria to be Used in Decomposing Systems into Modules, CACM 1972 (Bibliographic data/official version)
- D. MacQueen, Modules for Standard ML, LFP 1984 (Bibliographic data/official version)
- W. Cook, Object-Oriented Programming Versus Abstract Data Types, REX 1990 (Bibliographic data/official version)
- P. Wadler, The Expression Problem, note to Java-genericity mailing list 1998 (Author’s archived version)
- Palsberg & Jay, The Essence of the Visitor Pattern, COMPSAC 1998 (Bibliographic data/official version)
- Zenger & Odersky, Extensible Algebraic Datatypes with Defaults, ICFP 2001 (Bibliographic data/official version)
- W. Swierstra, Data Types à la Carte, JFP 2008 (Bibliographic data/official version)
- Oliveira & Cook, Extensibility for the Masses: Practical Extensibility with Object Algebras, ECOOP 2012 (Bibliographic data/official version)