Introduction to Programming Language Theory and System Design

using the Timber language

Course Plan

1. Programming languages (meetings 1&2).
• What is a programming language? Natural, formal, and programming languages. Why do we need different programming languages? Different solutions to the same problem: a programming language construct, a library, a design pattern.
• Introduction to (untyped) lambda-calculus.
• Different evaluation strategies: call-by-value, call-by-name, call-by-need. Strict vs. non-strict evaluation. Eager vs. lazy evaluation.
• Different programming paradigms: imperative, functional, parallel, logic, and neural network programming.
• Introduction to Timber. Evaluation of expressions and execution of commands. Classes, methods, and procedures. Functions, higher-order functions, partial application of functions.
2. Type systems (meetings 3&4).
   • What is a type system and why do we need one?
   • Static and dynamic typing. Inferred (implicit) and explicit types.
   • Type safety. Untyped, weakly-typed and strongly-typed languages.
   • Subtyping relation on types. Type variance.
   • Polymorphism. Qualified types. Recursive types.
   • Introduction to simply typed lambda-calculus. Curry-style and Church-style semantics.
   • Type inference.
   • Type system of Timber.
3. Object-orientation (meeting 5).
   • What is OO programming? State encapsulation and object identity. Multiple representations, separation between interface and implementation.
   • Creation of objects using procedures and using classes.
   • Subtyping as a relation on interfaces. Subclassing as a relation on classes. Inheritance by embedding and by delegation. Open recursion.
   • Objects in Timber.
4. Parallelism and concurrency (meeting 6).
   • Parallelism. Visible and transparent parallelism.
   • Concurrency. Do we need support for concurrency in a programming language?
   • Challenges: shared resources and synchronization. Implementation bottlenecks.
   • Different approaches to implementing concurrency: threads, tasks (in Ada, in TinyOS), active objects, and reactive objects. Functional programming and concurrency. Synchronous languages and concurrency. Transactional memory. Lock-free data structures.
   • Concurrency model of Timber.
5. Design of software systems (meetings 7&8).
   • System design. Desirable properties of software systems. Software design methodologies.
   • Model-based design. Modeling languages.UML. Interface description languages. Contracts.
   • Using Timber as a modeling language.
   • Component-based design of general software systems.
   • Distributed systems. Existing approaches and frameworks.
   • Embedded systems. Existing approaches and frameworks.
   • Resource-constrained systems (CPU, memory, power, etc.).
   • Hard and soft real-time systems. Reliability. Quality of Service.