Skip to main content

DD2487 Large-Scale Software Development 7.5 credits

The biggest problem in the development and maintenance of large-scale software systems is complexity — large systems are hard to understand. [Out of the Tar Pit, by Moseley and Marks, 2006].

A major part of this complexity is accidentally created when we introduce and manage state. 

This course will enrich the participants on how functional programming can reduce unintended complexity and create code bases that are simpler to maintain and reason about. 

Functional programming is a paradigm, which focuses on values and pure functions rather than mutable objects and imperative statements. In a functional language, state management is typically pushed to the boundary of the program.

Since well design of code is intersubjective we need to have a good dialogue together in the course. We need to be open-minded, share our perspectives and experiences, and continuously reflect upon our own and others experiences. 

By gaining experience, we will acquire empirical knowledge, intuition and sensors for avoiding unintended complexity, creating appropriate abstractions and a sustainable code base.

We will use the principle of single source of truth with atomic updates. On the course web, you can see what the library re-frame states upon those concepts.

Course offerings are missing for current or upcoming semesters.
Headings with content from the Course syllabus DD2487 (Autumn 2023–) are denoted with an asterisk ( )

Content and learning outcomes

Course contents

The lectures consist of much live coding, practical guidance, code-review and dialogue around how we can improve the architecture and design of the program code. This requires an active participation and an open positive atmosphere during the lectures. The idea of the lectures is to enthuse and broaden the perspectives around large-scale software development.

The lectures are compulsory, since the course is based on our joint dialogue and the active participation that is included in it.

Main contents: functional programming, code quality, readability, maintainability, cooperation, version management (git), global state, dependencies, mathematical functions, persistent data structures, handling of the state of applications, reactive programming, web development, testability, test as documentation, comparison with object-oriented programming, atomic updating of state, concurrency, DSL, LISP and REPL.

The programming languages Clojure and ClojureScript are used to realize the course content in a project. Thereby, the course will also give solid knowledge in LISP Clojure, Clojure Special and REPL workflow.

Every week,the students will be shown a video with a conference presentation. The idea is that it should give inspiration and open new doors. During the lectures, we will reflect on the contents.

Intended learning outcomes

After passing the course, the student shall be able to

  • design, using functional programming, large systems so that they become easier to test, understand and manage
  • model information in a program using only immutable data
  • reflect on and discuss how architecture and design can be improved
  • reflect on the concepts identity, state and value
  • design entities and components so that they become easy to test and write tests for them
  • protect internal design of a program at integration with other systems
  • develop a program in collaboration with other developers
  • review and reflect on given source code,
  • maintain given source code

in order to

  • understand and master the parameters in software development that make source code sustainable, re-usable and flexible during changing requirements. 

Literature and preparations

Specific prerequisites

Software engineering equivalent to one of the courses DD2480, DD1369/DD1392/DD1393, DD1346, DD1387/DD1388/DD2387, IV1303, HI1027/HI1201, or DD1385/DD2385.

Recommended prerequisites

No information inserted


No information inserted


No information inserted

Examination and completion

If the course is discontinued, students may request to be examined during the following two academic years.

Grading scale

P, F


  • PRO1 - Software engineering project, 7.5 credits, grading scale: P, F

Based on recommendation from KTH’s coordinator for disabilities, the examiner will decide how to adapt an examination for students with documented disability.

The examiner may apply another examination format when re-examining individual students.

Other requirements for final grade

Attendance at at least 80 percent of the lectures is compulsory.

Opportunity to complete the requirements via supplementary examination

No information inserted

Opportunity to raise an approved grade via renewed examination

No information inserted


Ethical approach

  • All members of a group are responsible for the group's work.
  • In any assessment, every student shall honestly disclose any help received and sources used.
  • In an oral assessment, every student shall be able to present and answer questions about the entire assignment and solution.

Further information

Course room in Canvas

Registered students find further information about the implementation of the course in the course room in Canvas. A link to the course room can be found under the tab Studies in the Personal menu at the start of the course.

Offered by

Main field of study

Computer Science and Engineering

Education cycle

Second cycle

Add-on studies

No information inserted


Tomas Ekholm (

Additional regulations

This course contains a group project. Course registration after the official registration period is therefore not possible, since we need to create the groups in the beginning of the course.