DevOps, Software Evolution and Software Maintenance, MSc
The course "DevOps, Software Evolution and Software Maintenance" is an MSc elective.
In this course, the students will discover all the software engineering activities that take place after an initial software product is delivered or after a legacy system is taken over from a theoretical and practical perspective. Students (in groups) will take over such a system that is live and serving users, they will refactor and migrate it to the languages and technologies of their liking. All subsequent DevOps, software evolution and software maintenance activities will be performed directly on the systems of the students.
In this course, the students will discover all the software engineering activities that take place after an initial software product is delivered or after a legacy system is taken over from a theoretical and practical perspective. Students (in groups) will take over such a system that is live and serving users, refactor and migrate it to the languages and technologies of their liking. All subsequent DevOps, software evolution and software maintenance activities will be performed directly on the systems of the students.
Students will learn DevOps, Software Evolution, and Software Maintenance concepts via:
- Using Linux/Unix based operating systems via the command line (Bash)
- Virtualization via containers and virtual machines
- Continuous integration (CI), continuous delivery, and continuous deployment
- Version control systems (Git), various branching strategies, and collaborative development workflows
- Coding standards, static analysis, linters, etc.
- Collaborative development process with code reviews, pair programming
- Time-planning and scheduling in software engineering projects
- Techniques for division of subsystems across multiple platforms
- Logging and log analysis
- Scalability, load balancing
- Service-level agreements
- Security of web-facing applications
- Deployment strategies
- Technical Debt & Maintainability
- Refactoring and evolution of legacy systems
The course consists of weekly workshop sessions (4h), which include lecture style teaching and interactive lab style exercises.
Additionally, students work in project groups (favorably five persons) together during the entire course. Project milestones, such as setup and configuration of a CI tool, automatic deployment of a software system, inclusion of new features, such as, logging, monitoring, etc. will serve as bi-weekly assignments.
Since we continuously deploy software on infrastructure as a service (IaaS) or platform as a service (PaaS) services and depending on the chosen services, each group might need some funding. Usually, each group should not use more than $10 per person over the run of the course. Students will not have to buy any books for this course on the other hand. Some of the services that we intend to use offer free credits for new users via the GitHub Student Developer Pack.
- Familiarity with at least one object-oriented programming language, such as Java, C#, etc.
- Be able to design, implement, and test medium-sized object-oriented programs. That includes the use of concepts such as classes, encapsulation, inheritance, polymorphism, interfaces, packages, data structures, concurrent programming , IO operations, basic GUI, and basic web programming.
- Be able to design, create, and use test medium-sized (relational) databases. That includes the use of concepts such as tables, primary, and foreign keys, normalization, etc.
Intended learning outcomes
After the course, the student should be able to:
- Explain, apply and reflect on the principles of DevOps and its constituents, including application of its concepts for software maintenance and evolution.
- Describe and apply various methods and strategies for, amongst others, continuous integration, delivery, and deployment, logging, monitoring, scalability, version control with branching, virtualization, maintenance, and handling of technical debt and their role in the context of DevOps.
- Explain and be able to execute all software engineering activities necessary to operate, evolve, and maintain a minimal-viable-prototype.
- Document and explain all steps during software maintenance and refactoring, e.g., with developer logs and the design and architecture of web-systems through the use of common standards for documentation including UML and standard documentation tools.
- Design and implement distributed and/or layered software using a suitable programming language and corresponding tools and frameworks for data storage, logging, monitoring, etc.
- Continuously maintain and evolve (refactor) a software system through adjustments in its architecture or refinements in its configuration.
- Analyze, discuss, choose, and relate different technologies and frameworks for their suitability in certain development and production scenarios.
- Discuss the advantages and disadvantages of different methods and practices for designing and developing software continuously.
- Identify and present current work practices and discuss potential modifications/improvements of these for adoption of DevOps principles.
Ordinary examExam type:
D: Submission of written work with following oral, Internal (7-point scale)
D2G: Submission for groups with following oral exam supplemented by the submission. Shared responsibility for the report.