Programming Languages Seminar

This is the course page for Programming Languages Seminar.

The official course description in my.itu is here.

• NOTE: papers have been moved to papers directory, links not updated
  
• Seminars: Wednesdays 09:00-12:00 (2A20)
  
• The course period is 14 weeks (7.5 ects) of seminars.
  
• Students are expected to attend the seminars.
  
• In each seminar, there will be two presentations by students about cutting-edge programming language technology.
  
• Those students who do not present a paper in a given seminar
  
  • must read the papers presented
    
  • must be attend the presentations
    
  • must ask questions to the presenter
    
• Exam: Each student should write a small survey (10 pages) peppered with code examples (or similar) over the same subject as their presentation.
  

• There are two talks, each 60 minutes including questions and discussion, each Wednesday (0900-1000 and 1020-1120). So do plan to talk 35 minutes or so. Use examples and concepts, motivate and relate to other languages and ideas.
  
• The presenters for a given day agree between them how to split the topic(s) between them.
  
• Send a 5-10 lines abstract of the talk plus a list of references (web sites, papers, book chapters) to Hannes, Lars and Peter, at least a week before your talk. We'll come back with comments and possibly suggestions for further literature.
  
• Choose one paper or book chapter for everybody to read, for each talk. Send that paper in PDF to Hannes no later than the Friday before the talk so we can put it on the web page.
  
• Use Google scholar, ACM Digital Library, Citeseer, the IT-Library in wing 0B, and similar sources when you search for literature.
  

• Typed Racket
  
  1. From Scripts to Programs
     • Motivation for integrating static typing into dynamic languages
     • Scheme in 5 slides
     • A Scheme program: French nursery rhyme
  2. Static types in Scheme
     • Translate Scheme to a statically typed language. Coercions and their relationship to subtypes. Coercions, threesomes and blame.
     • (Maybe) Soft types for Scheme. Static typing
     • Typed Racket: Explicitly (with annotations) typed sister language. May reject some valid Scheme programs, but gives full static type safety within a module, and a way of interacting with dynamically typed modules.
  3. Fun with Typed Racket programs
     • French nursery rhyme with types
     • Typed Z combinator
• LLVM
  I'll talk about LLVM - Low Level Virtual Machine - a compiler framework designed to support transparent, lifelong, program analysis and transformation. The compiler architecture and code representation will be presented.
• VMKit (LLVM)
  I will give a short overview of projects that use LLVM and closely related to previous talks in the seminar. The rest of the presentation will focus on one specific use case: building Managed Runtime Environments. The project VMKit is aimed to provide a middle layer between LLVM and High-Level MREs with just enough abstraction. VMKit also includes an implementation of JVM and CLI. These High-Level runtimes poses remarkably small, 20 KLOC, code base. We will discuss the design of VMKit by following up on the development of J3, the JVM "clone".
• Typestate
  Typestate oriented programming is a new paradigm that is under investigation. The idea is to incorporate state information into object-oriented programming languages, so it is possible to explicitly define the different states that an object can be in and to statically check that objects are in the correct state when their methods are called.
• Haskell
  I will present Haskell, a lazy, pure, functional programming language, covering:
  1. A very quick introduction to Haskell syntax
  2. Lazy evaluation
     • Concepts of lazy evaluation: call-by-value, call-by-name/need.
     • Exploration of lazy evaluation of the factorial function. Normal recursion, list comprehension, and as an infinite list.
     • How laziness interacts with tail-recursion. Strictness with seq.
  3. Type classes
     • Classes and instances (relationship with Cs and Is in OOP)
     • Examples from the Prelude: Eq, Ord, Num, Fractional
  4. Computational effects with Monads
     • The Monad type class
     • The Maybe monad
     • WIP: Example of monadic style. Reading and parsing a CSV file?
• Dependent Types
  Please read the first two chapters of Certified Programming with Dependent Types by Adam Chlipala. The first is simply an introduction and overview, and the second builds an example very similar to the arithmetic expression evaluator and stack machine used in Advanced Models and Programs. Please skip the two sections titled "Translation Correctness", as proving theorems directly will not be a major focus of my presentation. Also, should you wish to try the examples or play with Coq generally, I recommend trying CoqIDE instead of the Emacs mode if you're not already an Emacs person.
• Scala
  I will present an advanced feature of Scala's generic type system called higher-kinded types, based on the paper:

  Moors, A., Piessens, F., and Odersky, M. 2008. Generics of a higher kind. In Proceedings of the 23rd ACM SIGPLAN Conference on Object-Oriented Programming Systems Languages and Applications (Nashville, TN, USA, October 19 - 23, 2008). OOPSLA '08. ACM, New York, NY, 423-438. DOI= http://doi.acm.org/10.1145/1449764.1449798

  This feature allows reducing code duplication as well as allowing for greater expressiveness relative to Java and C#'s generic type systems. My presentation will assume a basic familiary with Scala, as most of you have taken Advanced Models and Programs. For those who have not, the overview at http://www.scala-lang.org/docu/files/ScalaOverview.pdf (which was required reading in AMP) will be sufficient.

  Scala website

• Clojure
  Clojure is a Lisp-dialect running on JVM. I will present some of the overall syntax of the language, and introduce the concepts and features where they differ from LISP. Clojure share datastructures with Java, and provides macros for easily interfacing with Java classes. We will look into how the integration works from both a Java-perspective and a Clojure-perspective.

  Clojure website

• Concurrency Concepts Article from Matyas about his experiences with actors, comparing with sequential implementation
  
  • Software transactional memory
    STM is an abstraction that should make concurrent programs easier to write and less error prone.

    I will talk about STM as a coding abstraction and why this may seem as a good idea. I will also talk a little about the problems there have been with creating an efficient implementation.

    The Transactional Memory / Garbage Collection Analogy

  • Actors
    The actor model is a model for concurrent computing using message passing. We'll examine how actors are used and implemented in Scala and compare them to purely thread based and event based programming.
• Marshalling (Erlang), Fortress, X10, CSP, Scala, Clojure, F# |
  
• Common Language Runtime
  F# and C# 4.0
• Dynamic and static typing
  Typed Scheme, Soft typing, Strongtalk, Dylan
• Javascript
  v8 and Evolutionary Programming and Gradual Typing in ECMAScript 4
• Systems programming languages
  BitC and RUST and Cyclone
• Dependent types and proof systems
  Coq, Agda, Ur/Web
• Implementation of virtual machines
  LLVM
• Computation on Hardware
  GPGPU, FPGA, From OO to FPGA: Fitting Round Objects into Square Hardware? (OOPSLA 2010), Microsoft Accelerator
• Just-in-time compilation
  IBM JVM, Spur tracing VM, PyPy
• Typestate
  Plaid, Session Types
• Genetic Engineering
  Programming Language for Genetic Engineering of Living Cells and Programming in Biomolecular Computation (Visualization)

• Lars Birkedal (LB) (birkedal@)
  
• Peter Sestoft (PS) (sestoft@)
  
• Hannes Mehnert (HM) (hame@)