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. |
InstructorsLearning 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 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). ProjectsThe
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.
Announcements
- 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.
Useful Links
|