Kursplan för Software engineering principles for complex systems

Kursplan fastställd 2019-02-21 av programansvarig (eller motsvarande).


  • Engelskt namnSoftware engineering principles for complex systems
  • KurskodTDA594
  • Omfattning7,5 Högskolepoäng
  • ÄgareTKITE
  • UtbildningsnivåGrundnivå
  • HuvudområdeDatateknik, Informationsteknik
  • BetygsskalaTH - Fem, Fyra, Tre, Underkänd

Kurstillfälle 1

  • Undervisningsspråk Engelska
  • Anmälningskod 52140
  • Blockschema
  • Sökbar för utbytesstudenterNej
  • Endast studenter med kurstillfället i programplan.


0119 Projekt 6 hp
Betygsskala: TH
0 hp6 hp0 hp0 hp0 hp0 hp
0219 Inlämningsuppgift 1,5 hp
Betygsskala: TH
0 hp1,5 hp0 hp0 hp0 hp0 hp

I program


Gå till kurshemsidan (Öppnas i ny flik)


  • TDA590 Objektorienterad systemutveckling IT
  • TDA591 Objektorienterad systemutveckling
  • TDA592 Objektorienterad systemutveckling
  • TDA593 Modelldriven mjukvaruutveckling


För kurser på grundnivå inom Chalmers utbildningsprogram gäller samma behörighetskrav som till de(t) program där kursen ingår i programplanen.

Kursspecifika förkunskaper

The student must know Java programming and must have taken courses on data structures and algorithms (e.g., TDA416) as well as on object-oriented programming (e.g., TDA552, TDA367). Courses on user-interface development (e.g., DAT216, TDA289), and on testing (e.g., TDA567) are recommended.


Real-world software systems are becoming increasingly complex and pervasive. Consider application domains such as enterprise computing (e.g., data-processing/AI systems), business information systems (e.g., web portals), cyber-physical systems (e.g., automotive software), systems software (e.g., operating system kernels), or mobile software and software ecosystems (e.g., Android apps). All these domains boast software systems of unprecedented complexity, many of which are long-living and exist in many different variants. As such, these software systems require dedicated planning, modeling, design, realization, and advanced analysis techniques presented in this course.

Lärandemål (efter fullgjord kurs ska studenten kunna)

Identify and reason about recurrent problems of engineering complex systems and being able to apply appropriate solutions. The learning is driven by a concrete example of a software engineering or re-engineering project that will be developed in group work.

1. Knowledge and understanding

  • Explain the challenges of engineering complex systems
  • Explain industrial practice of complex systems engineering
  • Provide examples of complex systems and explain their realization
  • Explain concepts (e.g., modeling or software synthesis techniques) for engineering variant-rich systems (e.g., software product lines, software ecosystems)
  • Explain processes for engineering complex systems (e.g., product-line engineering, continuous integration and deployment) 
  • Explain business-, architecture-, process-, and organization-related aspects of engineering complex systems
2. Skills and abilities
  • Perform domain engineering (e.g., scoping and domain analysis. platform engineering)
  • Model a system from different perspectives (e.g., using feature models, UML diagrams or architecture description languages)
  • Analyze a given industrial case study to identify and reason about their concepts for handling complexity 
  • Engineer a variant-rich system (e.g., variant-rich system, software product line, software ecosystem)
  • Analyze a complex system (e.g., commonality, variability analysis, model/code analysis)
  • Re-engineer complex systems (e.g., migrate software variants into a software platform)
  • Reason about modularization techniques to increase cohesion and reduce coupling
  • Use modern component or service frameworks
3. Judgement and approach
  • Analyze existing systems and discuss possible improvements or re-engineering potential, also taking economic aspects into account
  • Assess software-engineering organizations using maturity frameworks (e.g., CMMI or Family Evaluation Framework)
  • Reason about characteristics software modularity concepts (incl. component- and feature-oriented engineering)
  • Recognize the situations in which certain of the taught principles are appropriate
  • Read and analyze scientific literature
  • Understand group dynamics as well as the management and resolution of conflicts in group work.


Programming expertise is only one of many skills required to engineer complex software systems. In this course we will critically analyse what software-engineering principles from the areas mentioned above support the engineering of complex software systems. We will discuss these principles in the lectures and will apply them in project work.


There will be weekly lectures covering the theoretical course content. Additionally, there will
be project work in groups of 5-8 members and, as a part of this, weekly compulsory supervision meetings in the groups. The students will be introduced also to the concepts of working in groups and group dynamics via tailored lecture. Each student will be responsible for a certain part of the overall project.

In addition to the project and the written assignment, there will be a final presentation of the project work at the end of the course.


Information about literature can be found on the course web-page.

Examination inklusive obligatoriska moment

The two sub-courses (project and written assignment) are graded individually, both of which comprising the grading scale: 3, 4, 5, and Fail (U). The final grade of the course is calculated as follows:

  • Grade 3: at least 3 to the project grade and at least 3 to the written assignment
  • Grade 4: at least 4 to the project grade and at least 4 to the written assignment
  • Grade 5: 5 to both the project and written assignment
  • Fail (U): otherwise