Course syllabus for Software engineering principles for complex systems

The course syllabus contains changes
See changes

Course syllabus adopted 2021-02-17 by Head of Programme (or corresponding).

Overview

  • Swedish nameSoftware engineering principles for complex systems
  • CodeTDA594
  • Credits7.5 Credits
  • OwnerTKITE
  • Education cycleFirst-cycle
  • Main field of studyComputer Science and Engineering, Software Engineering
  • DepartmentCOMPUTER SCIENCE AND ENGINEERING
  • GradingTH - Pass with distinction (5), Pass with credit (4), Pass (3), Fail

Course round 1

  • Teaching language English
  • Application code 52117
  • Block schedule
  • Open for exchange studentsNo
  • Only students with the course round in the programme overview.

Credit distribution

0119 Project 6 c
Grading: TH		0 c6 c0 c0 c0 c0 c
0219 Written and oral assignments 1.5 c
Grading: TH		0 c1.5 c0 c0 c0 c0 c

In programmes

Examiner

Go to coursepage (Opens in new tab)

Eligibility

General entry requirements for bachelor's level (first cycle)
Applicants enrolled in a programme at Chalmers where the course is included in the study programme are exempted from fulfilling the requirements above.

Specific entry requirements

The same as for the programme that owns the course.
Applicants enrolled in a programme at Chalmers where the course is included in the study programme are exempted from fulfilling the requirements above.

Course specific prerequisites

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.

Aim

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.

Learning outcomes (after completion of the course the student should be able to)

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 software systems
    • Explain industrial practice and examples of complex software systems engineering
    • Explain processes and concepts for engineering complex and variant-rich software systems
    • Explain business-, architecture-, process-, and organization-related aspects of engineering complex software systems

    2. Skills and abilities

    • Model a software system from different perspectives (e.g., using feature models, UML diagrams, architecture description languages)
    • Engineer a variant-rich software system (e.g., variant-rich software system, software product line, software ecosystem)
    • Analyze and re-engineer a complex software system
    • Use and reason about modularization techniques
    • Use modern component or service frameworks

    3. Judgement and approach

    • Analyze existing software systems and discuss potentials for improvement or re-engineering
    • Reason about characteristics software modularity concepts
    • Recognize in which situations which principles for handling of complex software systems are appropriate
    • Read and analyze scientific literature

    Content

    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 support the engineering of complex software systems. We will discuss these principles in the lectures and will apply them in project work.

    Organisation

    There will be weekly lectures covering the theoretical course content. Additionally, there will be project work in groups and, as a part of this, weekly compulsory supervision meetings in the groups. In addition, there will be individual written assignments. 

    Literature

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

    Examination including compulsory elements

    The examination consists of two parts: an individual written report assignment (1.5 hec) and a group project (6 hec). The project part is graded individually, taking into account the group work as well as the student's individual contribution to the groupwork.

    The course examiner may assess individual students in other ways than what is stated above if there are special reasons for doing so, for example if a student has a decision from Chalmers on educational support due to disability.

    The course syllabus contains changes

    • Changes to course rounds:
      • 2024-06-18: Examinator Examinator changed from Gregory Gay (ggay) to Chih-Hong Cheng (chihhong) by Viceprefekt
        [Course round 1]