Course syllabus

Course-PM

TDA594 Software engineering principles for complex systems lp2 HT19 (7.5 hp)

The course is offered by the department of Computer Science and Engineering (CSE).

Contact details

• course responsible and examiner: Thorsten Berger
• teachers: Thorsten Berger, Daniel Strüber
• supervisors: Sergio Garcia, Wardah Mahmood, Mazen Mohamad, Mukelabai Mukelabai, Tobias Schwarz, Daniel Strüber

Questions about the course shall be asked during the (more interactive) Thursday lectures and the forum, for scalability reasons and to let all participants benefit from the responses.

Course purpose

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.

Schedule

Please use the schedule available on Canvas and only resort to TimeEdit to figure out the room. TimeEdit shows a superset of all slots allocated to this course (you would essentially move to the campus if you would need to attend all those slots ;) ). Also note that since it's a new course, there will be changes, so

TimeEdit

First lecture: Monday, Nov. 04 2019 at 15:15 in HB2. It is important to attend. Thereafter, there will be a lectures on Tuesdays and mostly Thursdays. The Tuesday lecture presents the curriculum, while the Thursday lecture will provide a recap, additional curriculum, and an interactive session where we will discuss concrete software systems (concrete robocode bots) and questions can be asked about the course.

Course literature

The main textbooks are:

Apel, S., Batory, D., Kästner, C., & Saake, G. (2016). Feature-oriented software product lines. Springer-Verlag Berlin. (available online via SpringerLink; use a Chalmers IP address to get it for free or go via the Chalmers library)

Van der Linden, F. J., Schmid, K., & Rommes, E. (2007). Software product lines in action: the best industrial practice in product line engineering. Springer Science & Business Media. (available online via SpringerLink; use a Chalmers IP address to get it for free or go via the Chalmers library)

Supplementary books:

Freeman, E., Robson, E., Bates, B., & Sierra, K. (2008). Head first design patterns. " O'Reilly Media, Inc.". (available via the Chalmers library)

 Andrzej Wasowski & Thorsten Berger. (2020). Principles of Software Language Design for Model-Driven Software Engineering. Upcoming (early draft will be available via Canvas, book website: www.mdsebook.org)

Meinicke, J., Thüm, T., Schröter, R., Benduhn, F., Leich, T., & Saake, G. (2017). Mastering Software Variability with FeatureIDE. Springer International Publishing.  (available online via SpringerLink; use a Chalmers IP address to get it for free or go via the Chalmers library)

There will be references to scientific literature in the lecture slides and reading assignments.

Course design

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.

We will specifically look at complex, variant-rich systems, also known as software product lines. A software product line (SPL) is a set of software products that share a common, managed set of features and that together address the needs of a particular market segment or mission. They are developed from a common set of core assets in a planned way. By developing large software systems in this way, companies can produce a set of products more economically, since the development effort put into the shared assets does not need not be duplicated. SPLs can also help companies to better address product customization tasks to meet specific needs of individual customers. This allows sustaining a high rate of product innovation, while keeping guaranteed levels of overall system performance and quality. The fundamental concept of a software product line is an integrated software platform adhering to a platform architecture with variation points. Effectively engineering SPLs does not only concern technical, but also process-, organization-, and business-related aspects. 

We will apply the theory in the group work, with weekly assignments, covering case studies of SPLs, modeling of SPLs, analysis of SPLs, and implementation of SPLs. A focus will be on re-engineering variants of Robocode bots, which are highly interesting systems, covering different architectural styles and levels of intelligence, for instance, incorporating AI (ML/DL) to learn the best strategy to succeed in the Robocode simulator.

For information about Robocode, see its home page and the RoboWiki with many bot variants and further links, especially to challenges and competitions.

Organization

There will be weekly lectures covering the theoretical course content. Additionally, there will be project work in groups of 4-5 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.

Changes made since the last occasion

This course is a new course.

Learning objectives and syllabus

Learning objectives:

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

2. Skills and abilities

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

3. Judgement and approach

• Analyze existing systems and discuss possible improvements or re-engineering potential
• Reason about characteristics software modularity concepts
• Recognize the situations in which certain of the taught principles are appropriate
• Read and analyze scientific literature

Link to the syllabus on Studieportalen.

Study plan

Examination form

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

The group needs to submit weekly group assignments, and individuals need to submit weekly written assignments. These assignments are graded, and at the end of the course a final group report and individual assignment needs to be submitted, which are graded together with a group presentation (Jan. 16 and Jan. 17) where the group work and the individual team members are examined.  These determine determine the final grades of the sub-courses. All weekly assignments before need to be passed.

If a weekly assignment or the final examination is not passed, then a re-submission or re-presentation, respectively, is necessary. The re-submission must fulfill the original requirements and (for fairness reasons): provide a detailed changelog with an explanation how/why the first attempt was not sufficient or did not work, and how/why the re-submission works. Also note that, while the project work is done in groups, it is graded individually. In most cases, the members of a team obtain the same project grade, but these grades can also differ.

Plagiarism Policy

There is, as always, absolutely no plagiarism accepted. Two short modules on academic integrity are part of the course.

Specifically, plagiarism (= unattributed copying of material from other sources) will yield an immediate FAIL in the course and will be reported to the university disciplinary board.