Elements of Programming Languages - Fall term 2015

Summary

Elements of Programming Languages is an Honours course in Informatics on the foundations and practicalities of programming language design. It is normally to be taken in year 3 but as a level 10 course it can also be taken by year 4 or MSc students.

Few computer scientists will ever design a new, general-purpose language, but most will need to learn several languages over the course of a career, and many will design new domain-specific languages for restricted problem domains. Programming language design involves many subtle choices and tradeoffs among performance, convenience, and elegance. Although some of the earliest programming languages (such as FORTRAN) are still going strong, new language designs and features are still being proposed, and it seems that we are still far from fully understanding the space of possible language designs.

Elements of Programming Languages covers the essential programming structures for managing data and controlling computation, as well as abstractions that facilitate decomposing large systems into modules. The course also covers pragmatics of programming languages, including abstract syntax, interpretation and domain-specific language implementation. Elements of Programming Languages is not about learning or programming in one specific language, rather, it covers the basic elements needed to understand the next 700 programming languages, or design a new one.

Course Staff

Course Structure

There will be 20 lectures, starting Tuesday, September 22nd, 2015. The lectures include the course introduction, two guest lectures, 16 lectures of examinable course content, and a course review lecture.

Lectures are 1410-1500 on Tuesday and Friday. UPDATED! The lectures are in several different locations:

There is a laboratory session on Wednesday, September 30th (time and location TBC), 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 two for-credit coursework exercises, together worth 25% of the final grade.

Course timetable

Week
Begins
Tue Lec
Tutorials/Lab
Fri Lec
Coursework (CW)
1 21 Sep   Intro   Lec 1    
2 28 Sep   Lec 2 Lab Lec 3  
3 5 Oct   Lec 4 Tut 1   Lec 5 CW1 available
4 12 Oct   Lec 6 Tut 2   Lec 7
5 19 Oct   Lec 8 Tut 3   Lec 9
6 26 Oct   Guest Lec 1 Tut 4   Lec 10 CW1 due ; CW2 available
7 2 Nov   Lec 11 Tut 5   Lec 12
8 9 Nov   Lec 13 Tut 6   Guest Lec 2  
9 16 Nov   Lec 14 Tut 7   Lec 15
10 23 Nov   Lec 16 Tut 8   Review CW2 due
11 30 Nov No lecture No tutorial Mock exam discussion Mock exam available

Key:

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

Office hours

The course lecturer and teaching assistants are available (during Semester 1) for discussion of course material at the above hours. Meetings outside these hours are also possible by appointment.

Topics

Course Text and Supplementary Material

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

Other useful books on programming languages include:

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.

Scala

The programming language used for lab, tutorial and coursework exercises is Scala. Any DICE machine (i.e. any Linux machine in an Informatics computer lab) should have Scala 2.11 installed; type scala at a command prompt to start the Scala interpreter.

Scala has many features in common with functional languages (such as Haskell) and object-oriented languages (such as Java). Prior familiarity with Scala is not needed for EPL, and we will investigate many of these features as part of the course. We will not cover all of Scala's more advanced or experimental features.

We will follow a "functional-first" style of Scala programming for most of the course, while most resources on Scala are oriented towards object-oriented programmers familiar with Java, Python or Ruby. Although the lectures, tutorials and lab/assignment handouts should provide all of the information about Scala you need for this course, you might be interested the following resources which cover Scala's features in more depth or from a different perspective.

Lab

There will be a 2-hour lab session during Week 2 to ensure that students have an opportunity to learn the basics of Scala needed for later coursework exercises. Students unfamiliar with Scala (i.e., most students) are strongly encouraged to attend and complete the lab assignment. The first hour will consist of an interactive demo of basic Scala programming concepts, following a lab handout (which will also be available in advance). During the second half of the lab session, you will be free to work on the lab exercises on your own or with others, and the course lecturer and lab demonstrator will be available to answer any questions.

The lab exercises may be handed in for formative feedback. That is, they will be marked and returned with feedback, but the results do not count toward your final grade. The due date for completed lab assignments is October 7.

The lab assignments have now been marked and are available from the ITO

Tutorials

Tutorials start Week 3 (October 5-9). See tutorial groups with times and membership. Tutorial notes and solutions will also appear here as they become available.

  1. Tutorial for week 3. (Sample solution)
  2. Tutorial for week 4. (Sample solution)
  3. Tutorial for week 5. (Sample solution)
  4. Tutorial for week 6. (Sample solution)
  5. Tutorial for week 7. (Sample solution)
  6. Tutorial for week 8. (Sample solution)
  7. Tutorial for week 9. (Sample solution)
  8. Tutorial for week 10. (Sample solution)

Guest Lectures

There is a lot of research on programming languages in the School of Informatics. EPL will feature two guest lectures covering more advanced topics that apply or extend ideas covered in the course. The two guest lectures are as follows:

While these lectures don't cover examinable material, we encourage students to attend, as they provide additional context and motivation for the material covered in EPL, and may also be interesting starting points for students interested in doing a Honours project or MSc project on a topic related to EPL.

Lecture Slides

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

Here is a single PDF file with all of the lecture slides: epl-all.pdf

Coursework

There will be two, summatively assessed, coursework exercises. The first is worth 10% of the final grade and the second is worth 15%. Once marked, the coursework will be returned to students with feedback.

Late assignment submission and academic conduct policies

Important: Please note that, as with all Informatics courses, late submissions of coursework cannot be accepted without approval for the appropriate Year Organiser (UG3), and that this course is subject to the School's academic conduct policy regarding plagiarism and acknowledgement of sources. For full details please consult the School's policies:

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:

In addition, both summatively assessed coursework exercises will be marked, commented and made available for students to collect 2 weeks after submission.

Previous Exams

This is a new course for 2015, so there are no previous exams. Past courses "Language Semantics and Implementation", and "Functional Programming and Specification" offered in previous years may cover similar material, but EPL is a different course and its exam will be different.

A mock exam is available here:

We will hold a review session 1410-1500 on December 4 in G.03, 50 George Square to discuss solutions and answer any questions about the mock exam.


Home : Teaching : Courses : Epl 

Informatics Forum, 10 Crichton Street, Edinburgh, EH8 9AB, Scotland, UK
Tel: +44 131 651 5661, Fax: +44 131 651 1426, E-mail: school-office@inf.ed.ac.uk
Please contact our webadmin with any comments or corrections. Logging and Cookies
Unless explicitly stated otherwise, all material is copyright © The University of Edinburgh