B0011 - Software Process Engineering

Learning outcomes

By the end of the course, the student is expected to (i) master advanced techniques for organising the software development process, and to (ii) be able to set up, evolve, and maintain complex software following an agile approach. In particular, the student will acquire conceptual and practical skills involving modern version control systems, build automation, multi-platform and multi-target testing, continuous integration, and continuous delivery. The student will also become familiar with relevant notions and practices in software engineering (and their rationale) such as software licensing (with a focus on open source products) and versioning. Finally, the student will train their capability of performing domain-first analyses before development, in a technology-independent fashion, leveraging approaches such as Domain-Driven (DDD) and Model Driven (MDD) development. To support these approaches, the student will be informed about advanced practices, such as the definition of domain-specific languages (DSLs) and the corresponding code generators, as well as the development of language-internal DSLs in modern programming languages.

Course contents

Prerequisites

Students are expected to have:

• a working knowledge of object-oriented programming and Java;

• basic practical knowledge of Git, including repository creation, commits, branches, merges, fetching, and pushing.

Previous knowledge of Scala and familiarity with a Unix-like command-line environment are useful but not required.

The course is organised into two teaching modules.

MODULE 1 — Software process automation and DevOps

• Agile software-development processes and the DevOps philosophy: collaboration, shared responsibility, reproducibility, automation, incrementality, and continuous improvement.

• Kotlin essentials, with emphasis on the language features used throughout the course and comparison with Java and Scala.

• Construction of language-internal domain-specific languages in Kotlin.

• Build automation, with Gradle as the reference tool.

• Dependency management:

  • direct and transitive dependencies;

  • dependency graphs and conflict resolution;

  • version constraints and update strategies;

  • dependency locking and reproducible builds.

• Automated testing and quality assurance, including multi-platform and multi-target test execution.

• Software release and versioning strategies.

• Software licensing, with particular attention to open-source software.

• Organisation of collaborative development workflows using Git.

• Advanced version-control practices, including rebasing, cherry-picking, squashing, stashing, and submodules.

• Continuous integration and pipeline design, with GitHub Actions as the reference platform.

• Continuous delivery and continuous deployment.

MODULE 2 — Domain- and model-driven development

• Domain-Driven Design:

  • domains and bounded contexts;

  • ubiquitous language;

  • context mapping;

  • domain modelling and the principal DDD building blocks.

• Model-Driven Development:

  • formal and technology-independent models;

  • model transformations;

  • generation of executable artefacts from models.

• Design and implementation of external and internal domain-specific languages.

• Development of parsers, interpreters, validators, and code generators for domain-specific languages.

• Containerisation of software systems.

• Orchestration of containerised applications and management of their configuration, services, networks, persistent data, and secrets.

• Multi-platform software design and programming, with Kotlin Multiplatform as a reference technology.

• Platform-independent modelling, platform-specific implementations, and testing across multiple targets.

• Bug hunting, fault localisation, debugging, and performance engineering.

• MLOps: application of DevOps principles and practices to the development, automation, delivery, monitoring, and evolution of machine-learning systems.

• LLMOps: engineering practices for the development, evaluation, deployment, monitoring, governance, and maintenance of systems based on large language models.

Practical activities

The conceptual topics are supported by guided laboratory exercises and development tasks.

Readings/Bibliography

Course materials for examination preparation

The material contained in the course slides is sufficient to prepare for the examination. The slides are available on the course website or through Virtuale.

All readings listed below are suggested and are not required for the course.

Suggested books

• Eric Evans, Domain-Driven Design: Tackling Complexity in the Heart of Software.

• Mark Richards and Neal Ford, Fundamentals of Software Architecture: An Engineering Approach.

• Scott Millett and Nick Tune, Patterns, Principles, and Practices of Domain-Driven Design.

Additional suggested readings

• Nate Ebel, Mastering Kotlin: Learn Advanced Kotlin Programming Techniques to Build Apps for Android, iOS, and the Web.

• Dmitry Jemerov and Svetlana Isakova, Kotlin in Action.

• Vijay Nair, Practical Domain-Driven Design in Enterprise Java: Using Jakarta EE, Eclipse MicroProfile, Spring Boot, and the Axon Framework.

• Thomas Stahl and Markus Völter, with Jorn Bettin, Arno Haase, and Simon Helsen, Model-Driven Software Development: Technology, Engineering, Management.

• Lorenzo Bettini, Implementing Domain-Specific Languages with Xtext and Xtend.

Teaching methods

Teaching is delivered through lectures and practical laboratory sessions. Lectures introduce the relevant software-engineering concepts, methods, and tools, while laboratory sessions allow students to apply them through guided exercises and hands-on development activities.

The course combines conceptual discussion with the practical configuration, use, and evaluation of the techniques and technologies presented during the lectures.

Given the type of activities and teaching methods adopted, participation in the laboratory sessions requires all students to complete modules 1 and 2 of the training on safety and health in study environments in e-learning mode before attending.

The course can be attended on the e-learning platform.

Assessment methods

Assessment is based on a group-developed software project. The project must be finalised at least two weeks before the discussion.

Discussion dates are agreed upon on a case-by-case basis and are not scheduled in advance. Groups requiring an appointment before a specific date should contact the teachers in advance to ensure that a suitable examination slot is available. Contacting the teachers three to four weeks in advance is recommended. The project does not need to be complete when the appointment is requested.

The discussion consists of:

• a 10–15-minute presentation of the project;
• project-driven questions covering all the topics addressed in the course.

Candidates may use supporting materials, including slides, during the project presentation.

The project must be developed according to Domain-Driven Design or Model-Driven Development principles and may address one of the cyber-physical scenarios discussed during the course. It must demonstrate the ability to organise a collaborative workflow using version-control tools and to automate the building, testing, maintenance, verification, quality assurance, documentation, and deployment of the software product.

Students may use any tools, libraries, frameworks, and documentation during project development. The techniques required for this course may also be applied to a project developed for another course, subject to prior agreement with the teachers.

Generative AI may be used during project development. Any use of generative AI must be disclosed in the project report. Regardless of how they were produced, all code, documentation, diagrams, schemas, configuration files, and other project artefacts are considered the students’ responsibility.

During the discussion, students must be able to explain and justify every part of the submitted work. Failure to explain a code fragment, including pipeline configuration, a technical term used in the report, a diagram, a schema, or any other description is considered an error and negatively affects the evaluation. Serious or repeated failures may result in the project being deemed invalid.

The final grade is expressed on a 30-point scale and is determined jointly by the teachers. The evaluation considers:

• the candidates’ technical preparation and analysis skills;
• the appropriate and effective use of the methodologies, techniques, and tools presented during the course;
• the quality and completeness of the project;
• the ability to explain and justify technical and methodological decisions;
• mastery of the relevant terminology;
• the clarity and effectiveness of the presentation and discussion.

Original or technically noteworthy project features are also considered in the final evaluation. Attendance is strongly recommended but does not directly affect the final grade.

Grades are assigned according to the following criteria:

• 18–23: sufficient preparation and analysis skills; sufficient knowledge but limited use of the methodologies, techniques, and tools presented during the course; an overall informative discussion.
• 24–27: fair technical preparation and analysis skills, with some limitations; good knowledge and broad use of the methodologies, techniques, and tools presented during the course; an informative discussion.
• 28–30: good technical preparation and analysis skills; extensive knowledge and broad use of the methodologies, techniques, and tools presented during the course; mastery of the relevant terminology and an engaging discussion.
• 30 with honours: excellent technical preparation and analysis skills; extensive knowledge and state-of-the-art use of the methodologies, techniques, and tools presented during the course; complete mastery of the relevant terminology and an insightful discussion.

Students with specific learning disorders or temporary or permanent disabilities are advised to contact the relevant University office (https://site.unibo.it/studenti-con-disabilita-e-dsa) well in advance. The office will propose any appropriate adaptations, which must be submitted to the teachers for approval at least 15 days before the examination. The teachers will assess their suitability in relation to the learning outcomes of the course.

Teaching tools

Course slides, code examples, project templates, exercises, and technical documentation are provided through the course website and Virtuale.

Generative AI tools may be used to support individual study, experimentation, and project development. Their outputs must be critically assessed, and any use in the examination project must comply with the disclosure and responsibility requirements specified in the assessment methods.

Links to further information

https://unibo-spe.github.io/

Office hours

See the website of Danilo Pianini

See the website of Giovanni Ciatto