Software & Data Evolution
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
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.
engineer an existing system and produce (a) an abstract model of the
system and (b) the appropriate documentation that goes along with the
- 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.
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 MaterialObject-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.
ScoringThe 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).
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
- 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/3- here.
- 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.