Elements of Programming Languages

EPL: Resource List

flittlet — Tue, 18 Jul 2023 14:55:44 +0000

EPL: Resource List flittlet Tue, 18/07/2023 - 15:55

There is no required course text. The following three resources are recommended reading to supplement the course materials. Specific reading suggestions are listed along with the lectures below.

Practical Foundations for Programming Languages (PFPL2), second edition, by Robert Harper (Cambridge University Press 2016). Both editions of the book are available electronically through the library, and there are print copies of the first and second editions in the library. A draft of the second edition is also available on the author's webpage; some chapter references may differ between the two editions.
Concepts in Programming Languages (CPL), by John Mitchell (Cambridge University Press). Also available at no cost through the University Library's ebook access.
Martin Odersky and Tiark Rompf, Unifying functional and object-oriented programming with Scala, Communications of the ACM, Vol. 57 No. 4, Pages 76-86

Other useful books on programming languages include:

Types and Programming Languages, by Benjamin Pierce (MIT Press). In the University Library.
Essentials of Programming Languages, by Friedman and Wand (MIT Press) presents programming languages via a series of interpreters (in Scheme). In the University library (including electronic access).
The book Functional Programming in Scala by Chisuano and Bjarnason and is a well-written introduction to functional programming in Scala (targeted at mainstream programmers, not academics), similar to the way we will mostly be using it in this course. In the University library.

The following are some historically-influential papers on programming languages, and may be of interest to students interested in pursuing further study of programming languages.

Peter J. Landin. The next 700 programming languages. Communications of the ACM, 9(3):157-166, March 1966.
John C. Reynolds. Definitional interpreters for higher-order programming languages. Higher-Order and Symbolic Computation, 11(4):363-397, 1998.
Robin Milner. A theory of type polymorphism in programming. Journal of Computer and System Sciences, 17:348-375, August 1978.
Gordon Plotkin. Call-by-name, call-by-value, and the λ-calculus. Theoretical Computer Science, 1:125-159, 1975.
John C. Reynolds. Towards a theory of type structure. In Colloque sur la Programmation, Paris, France, volume 19 of Lecture Notes in Computer Science, pages 408-425. Springer-Verlag, 1974.
C. A. R. Hoare. An axiomatic basis for computer programming. Communications of the ACM, 12(10):576-580 and 583, October 1969.
John Hughes. Why functional programming matters. From "Research Topics in Functional Programming" ed. D. Turner, Addison-Wesley, 1990, pp 17-42.

License

EPL: Lectures

flittlet — Tue, 18 Jul 2023 14:55:43 +0000

EPL: Lectures flittlet Tue, 18/07/2023 - 15:55

Lecture Recordings

All lecture recordings should be accessed via Learn; you will need to log in using your EASE account. (Learn provides you with access to any lecture recordings available for this course. You will need to select the "lecture recording" link once, before you can access any direct links to a lecture recording.)

Lecture Slides

Lecture slides will be posted here as the course proceeds. The suggested readings cover related material in "Practical Foundations for Programming Languages (second edition)" (PFPL2), "Concepts in Programming Languages" (CPL), and other sources, however, we will cover some topics in a different order or differently than in these textbooks.

Course Introduction and Admin. (pdf) Related reading: CPL 1
Lecture 1: Abstract Syntax (pdf). Related reading: PFPL2 1.1; CPL 4.1, 5.4.1
Lecture 2: Evaluation (pdf, LArith.pdf). Related reading: PFPL2 2.1-3, 2.6, 7.1, CPL 5.4.2
Lecture 3: Booleans, conditionals, and types ( lec3.pdf , LIf.pdf) Related reading: PFPL2 4.1-4.2, CPL 5.4.2, 6.1, 6.2
Lecture 4: Variables, scope, and binding (pdf, LLet.pdf). Related reading: PFPL2 1.2, 3.1-3.2, CPL 4.2, 7.1
Lecture 5: Functions and Recursion (pdf, LRec.pdf). Related reading: PFPL2 8, 19.1-2; CPL 4.2, 5.4.3
Lecture 6: Data structures (pdf, LData.pdf). Related reading: PFPL2 10.1, 11.1, CPL 5.4.4
Lecture 7: Records, subtyping, and pattern matching (pdf). Related reading: CPL 6.5; PFPL2 10.2, 11.2-3, 24.1-3
Lecture 8: Polymorphism and type inference (pdf, LPoly.pdf). Related reading: PFPL2 16.1; CPL 6.3-4
Lecture 9: Programs, modules, and interfaces (pdf). Related reading: CPL 9, PFPL2 42.1-2, 44.1
Lecture 10: Objects and classes (pdf). Related reading: CPL 10, 12.5, 13.1-2
Lecture 11: Object-oriented functional programming (pdf). Related reading: Odersky and Rompf
Lecture 12: Imperative programming (pdf, LWhile.pdf). Related reading: CPL 4.4, 5.1-2, 8.1
Lecture 13: Small-step semantics and type safety (pdf). Related reading: CPL 6.1-2, PFPL2 5.1-2,2.4,7.2, 6.1-2
Lecture 14: References, arrays and resources (pdf). Related reading: PFPL2 35.1-3, CPL 5.4.5, 13.3
Lecture 15: Evaluation strategies and laziness (pdf). Related reading: PFPL2 36.1, CPL 7.3, 8.4
Lecture 16: Exceptions and Continuations (pdf). Related reading: CPL 8.2-3, PFPL2 29.1-3, PFPL2 30.1-2
Course review lecture (pdf)

Guest Lectures

There will be two guest lectures:

October 12: Elizabeth Polgreen. Program synthesis This lecture will be an intro to formal synthesis algorithms used to automatically synthesise code that satisfies specifications. (Slides)
November 9, Amir Shaikhha. Building DSL compilers in Scala
Domain-specific languages (DSLs) are specialized programming languages tailored to address specific problem domains, offering concise, expressive, and efficient solutions within their context. In this talk, we give an introduction to DSLs and show how to use Scala to build compilers for them.

License

EPL: Schedule

flittlet — Tue, 18 Jul 2023 14:55:43 +0000

EPL: Schedule flittlet Tue, 18/07/2023 - 15:55

The exact schedule of lectures is subject to change, depending on availability of guest lecturers.


Week	Begins	Mon Lec	Tutorials/Lab	Thurs Lec	Assignments
1	18 Sep	Intro		Lec 1
2	25 Sep	Lec 2	Lab	Lec 3	Assignment 1 (Lab) available
3	2 Oct	Lec 4	Tut 1	Lec 5	Assignment 1 due; Assignment 2 available
4	09 Oct	Lec 6	Tut 2	Guest lec 1
5	16 Oct	No lecture	Tut 3	Lec 7
6	23 Oct	Lec 8	Tut 4	Lec 9	Assignment 2 due; Assignment 3 available
7	30 Oct	Lec 10	Tut 5	Lec 11
8	6 Nov	Lec 12	Tut 6	Guest lec 2
9	13 Nov	Lec 13	Tut 7	Lec 14
10	20 Nov	Lec 15	Tut 8	Lec 16	Assignment 3 due
11	27 Nov	Review		Mock exam discussion	Mock exam available

Introductory/review lecture (non-examinable)
Guest lecture (non-examinable)
Examinable lecture

License

EPL: Elements of Programming Languages

flittlet — Tue, 18 Jul 2023 14:55:42 +0000

EPL: Elements of Programming Languages flittlet Tue, 18/07/2023 - 15:55

Welcome to Elements of Programming Languages

Programming languages are used in all areas of Informatics, and most people doing an Informatics degree will go on to use programming in their work, whether in industry or academia. You will most likely have learned two or three programming languages in your studies (or on your own) so far. This course is not about teaching you about programming in any specific language, but about learning how programming language work, how they are designed and implemented, and even how you might design your own. Since new programming languages and programming features are being introduced continuously, this course will help you be ready to adapt to whatever new (or old) languages you might encounter in the rest of your studies or career.

Learning Outcomes

On successful completion of this course, you should be able to:

Investigate the design and behaviour of programming languages by studying implementations in an interpreter
Employ abstract syntax and inference rules to understand and compare programming language features
Design and implement a domain-specific language capturing a problem domain
Understand the design space of programming languages, including common elements of current languages and how they are combined to construct language designs
Critically evaluate the programming languages in current use, acquire and use language features quickly, recognise problematic programming language features, and avoid their (mis)use.

Course Outline

Abstract syntax and name-binding; Lexical vs. dynamic scope
Modelling programming language features using inference rules
Interpreters as a way of defining and exploring language features
Domain specific languages, translators, and pragmatics of language processing
A selection of topics illustrated by case studies from current or historically important language designs:
- data structures: pairs/record types; variant/union types; recursion
- abstracting data: overloading; generics; ad hoc vs. parametric polymorphism
- control structures: goto, loops, case/switch, exceptions
- abstracting control: procedure call/return; function types; continuations
- design dimensions: eager vs. lazy evaluation; purity vs. side-effects; state
- object-oriented features: objects, classes, interfaces, subtyping, (multiple) inheritance
Advanced topics/guest lectures on concurrent, parallel, distributed programming, security, or verification (linking to UG4 year courses)

Course Structure

There will be 20 lectures, starting September 18, 2023. The lectures include the course introduction, three guest lectures, 16 lectures of examinable course content, and a course review lecture.

Lectures are as follows:

Monday 1410-1500 in Chrystal MacMillan Building Seminar Room 2 (G.02).
Thursday 1410-1500 in Appleton Tower 2.12 (AT 2.12).

In case of any discrepancy between the information above (provided for convenience) and the University timetable, the latter takes precedence.

There is a laboratory session on September 27 in Appleton Tower labs 5.05/5.07 with a not-for-credit coursework exercise due one week later. This exercise does not count toward your final grade, but will be returned with formative feedback.

Tutorials are held in weeks 3-10. Participation in tutorials (including working on tutorial problems in advance) is expected and the tutorials cover examinable material that is part of the course.

There will be three coursework exercises. The first two are evaluated and returned for formative feedback. The third is worth 25% of the final grade.

The exam is in the December exam diet. Please see the University's exam schedule page to check on the date / time of your exam.

Feedback

Formative feedback provides students with feedback on performance and understanding in time to assist with the assessed aspects of the course (coursework and exam).

Elements of Programming Languages offers the following formative feedback:

Interaction with tutors in tutorials provides general feedback on understanding.
The laboratory assignment will be collected, evaluated, and returned with formative feedback.
The first coursework assignment will be collected, evaluated, and returned with formative feedback.

In addition, the summatively assessed coursework exercise will be marked, commented and made available for students to collect at most 3 weeks after submission and preferably within 2 weeks.

License