Software & Data Evolution

Course Description

The course Software and Data Evolution offers an in-depth coverage of a core topic within the broader field of information systems engineering -- specifically, the evolution and re-engineering  of software and data. The course starts by reviewing software evolution in general. Then, it proceeds to cover in an in-depth analysis, the area of re-engineering a legacy software. The course presents the general method of re-engineering a legacy system into a new, well-designed and maintainable object-oriented system. Following, the particular steps of the method, along with patterns and anti-patterns are covered: reverse engineering, abstract modeling of an OO system, identification of bad design symptoms, re-engineering patterns and forces. The cource moves on to cover the evolution of data, and presents typical patterns by which database schemata evolve, and techniques to handle schema evolution.

A team project where a large complex software system is re-engineered accompanies the theoritical lecturing.


Learning Objectives & Expected Outcomes

  • Understand the state-of-the-art and the historical evolution of research in the area under study.
  • Understand in depth the critical steps in the process of re-engineering.
  • Reverse engineer an existing system and produce (a) an abstract model of the system and (b) the appropriate documentation that goes along with the abstract model.
  • Identify symptoms of bad design and rigidity and prioritize them in terms of re-engineering.
  • Understand the role of re-engineering patterns in the process of software maintenance, their interrelationships and tradeoffs.
  • Design specific solutions for the identified problems and assess both the “forces” that constrain the solution space as well as the trade-offs that each candidate solution incurs.
  • Acquire hands-on experience by developing a complete project wherein they apply the design and algorithmic knowledge obtained from the course in order to re-engineer an existing complex software system.

Literature and Study Material

Object-Oriented Reengineering Patterns, S. Demeyer, S. Ducasse, O. Nierstrasz, ISBN 978-3-9523341-2-6.

Working Effectively with Legacy Code, M. Feathers, Prentice Hall, ISBN-13: 978-0131177055.

Refactoring. Improving the Design of Existing Code, Fowler, Addison-Wesley, ISBN 0-201-48567-2.

Refactoring To Patterns, J. Kerievsky. Addison-Wesley, ISBN 0-321-21335-1.

Design Patterns: Elements of Reusable Object-Oriented Software, E. Gamma,R. Helm, Richard, R. Johnson, Ralph, J. Vlissides,  Addison-Wesley, ISBN 0-201-63361-2.

You can download related readings from Prof. Vassiliadis' page.


The score is based on two factors (1) a team project and (2) an atomic project.
  • (Team) Project: 80%
  • (Atomic) Participation to the course lectures, discussions, and individual activities:  20%

You can download the lectures' slides here (contents updated after each lecture).


The project of the course involves the re-engineering of a fairly sizeable object-oriented project. Specifically, the process of bringing the project to successful end involves the following steps.
  • The instructors announce a short list of candidate software projects
  • Students form groups of 2 or 3 persons
  • Depending on the team’s size there is an assignment of project made by the instructors.
  • Deliverable #1 (Program understanding and Reverse engineering): The students perform the actions suggested by the related theory towards program understanding and reverse engineer the legacy code and compose a report consisting of (a) the goals, modus operandi, responsibilities, plan of the re-engineering process, as well as (b) the architecture of the legacy code (package diagram), (c) the design of the legacy code (class diagrams), (d) a description of the functionality of the different parts of the code (e.g., short CRC cards per class).
  • Deliverable #2 (List of problems): The students report a list of problems in two levels: (a) architecture and design level and (b) code and style level, along with (c) a preliminary plan of actions towards re-engineering the legacy code.
  • Deliverable #3 (Plan of actions and Tests): The students report on (a) the tests they have constructed to facilitate the migration process, (b) any preliminary re-engineering steps they have already performed, and, (c) the final plan of actions for the integration.
  • Deliverable #4 (Final deliverable): Finally, the students deliver (a) code published at git, (b) new package and class diagrams, (c) tests and their results, (d) a summary report of the previous deliverables (updated if need) as well as open issues.


  • NEW !!! The final grades can be found here.
  • To participate in the assessment of the course you can follow this link - deadline 14/6.
  • NEW !!! Final deadline for the project Sun 14/6 23:59.
    • Send URL of git + a report in PDF.
  • Deliverable 3: For 28/4 try to have tests and a 1st refactoring of  a simple use case (eg Load Project); if time incrementally add tests and refactorings for other use cases. Report list of test cases and refactorings in terms of UML diagrams (before/after change).   
  • Deliverables 1 & 2 due date Fri April 10 via email.
  • The online lectures will begin on Tue 31/3 via the MS Team platform. You can join the lectures using this code: l2a79uv
  • The second lecture will be on Tue 25/2 at 18:00.
  • The first lecture for this semester will be on Tue 18/2 at 18:00
  • You can declare your project teams - Deadline 6/3here.
  • This year's project is to restructure the Plutarch Parallel Lives project (see the DAINTINESS-Group for more details).
    • You can find a basic report and presentation that explains the goals and the overall architecture of the project here
    • You can find the source code of the project here.

Useful Links