Course syllabus for Functional Programming: continuation course

• 7.5 credits in functional programming
• 7.5 credits in discrete mathematics
• 7.5 credits more in mathematics
• 7.5 credits more in data structures

Knowledge and understanding:

• Explain and apply fundamental abstractions in functional programming, including lazy/strict evaluation, functors, & monads, and describe how these abstractions can be used to handle state, exceptions, and I/O in a purely functional way.
• Explain how algebraic properties such as associativity and commutativity enable divide-and-conquer and parallel evaluation in pure functional programs, and discuss how purity and referential transparency support the design of compositional embedded domain-specific languages (EDSLs).

Skills and abilities:

• Design, structure, and implement functional programs and small EDSLs using appropriate type classes, algebraic operators, and data structures for efficient and, where appropriate, parallel computation.
• Apply functional techniques such as recursion schemes, memoization, and algebraic composition to implement and reason about non-trivial algorithms.
• Use relevant tools and libraries to develop, test, and document maintainable programs, including performance analysis and identification of common inefficiencies.
• Structure and solve real-world programming problems in a functional style, integrating abstraction, testing, and reasoning for correctness and efficiency.

Judgement and approach:

• Critically assess the suitability of abstractions and algebraic structures for specific programming problems, through reflection on the trade-offs between abstraction, performance, and resource use.
• Evaluate program design decisions and correctness using property-based testing, algebraic properties, and equational reasoning.
• Demonstrate responsibility in program design and collaboration, ensuring modularity, clear documentation, and maintainability.

Students will study key abstractions such as lazy/strict evaluation, functors, monads and similar, and learn how these can be used to express effects like state, exceptions, and I/O in a purely functional way. The course also introduces methods for structuring larger functional systems, including the design of embedded domain-specific languages (EDSLs), the use of software transactional memory for safe concurrency, and techniques for parallel and efficient evaluation based on algebraic properties such as associativity and commutativity.

Lab work / programming assignments develop practical skills in designing, implementing, and reasoning about functional programs. Students gain experience with type classes, recursion schemes, and memoization, as well as relevant tools for building, testing, and documenting projects. Emphasis is placed on equational reasoning and property-based testing as means to achieve correctness and efficiency. Students learn to critically assess the trade-offs between abstraction and performance and to structure software in a modular, maintainable, and verifiable way.

The main forms of instruction are lectures, seminars, case studies, and group work.

Language of instruction: English

The course is examined by an individual written exam which is carried out in an examination hall at the end of the course and by written assignments carried out in groups.