Skip to navigation | Skip to main content | Skip to footer
Menu
Menu

COMP33812: Software Evolution (2010-2011)

This is an archived syllabus from 2010-2011

Software Evolution
Level: 3
Credit rating: 10
Pre-requisites: COMP23420
Co-requisites: No Co-requisites
Duration: 11 weeks
Lectures: 22 hours (in 11 2 hour sessions)
Lecturers: Andy Carpenter, Suzanne Embury
Course lecturers: Andy Carpenter

Suzanne Embury

Additional staff: view all staff
Timetable
SemesterEventLocationDayTimeGroup
Sem 2 Lecture 1.4 Fri 13:00 - 15:00 -
Assessment Breakdown
Exam: 70%
Coursework: 30%
Lab: 0%

Themes to which this unit belongs
  • Agile Methods

Introduction

This course unit continues the Agile Methods theme by focusing on the challenges not of creating new systems from scratch, but of evolving systems that already exist.

It has been observed that 80p of every pound spent on software development is spent on maintenance of existing systems. In real life, most software engineers spend their time either helping software systems to continue to meet the needs of their users, or adapting them to meet changing needs. Even new applications are typically constructed by combining existing components and database systems new software.

Similarly, downstream in agile development projects, new functionality must be implemented in the context of existing development, some of which may have been deployed to the customer and which must continue to deliver business value through the new development.

Aims

This course unit aims to make students aware of the challenges inherent in the evolution of existing systems, especially when they are in constant use, and to provide a working understanding of some of the techniques and best practices currently known for changing existing bodies of software safely.

Programme outcomeUnit learning outcomesAssessment
A2 A4Have an understanding of the importance of taking a long term view of software development at all stages in the software life cycle.
  • Examination
A2 A4Understand the factors that make change of existing systems both technically challenging and risky, and the processes required to control change.
  • Examination
B1 B3Be able to apply standard tools and techniques for program comprehension, in order to quickly gain an understanding of an unfamiliar software system.
  • Individual coursework
  • Examination
A2 A4Be aware of some of the techniques and tools used to assist in the modification of code, including debugging, impact analysis and refactoring.
  • Examination
A2 A4 B1 B3Have a knowledge and understanding of the specific problems inherent in the maintenance and evolution of legacy software systems, and be able to apply some of the techniques that can be of use in comprehending and changing them.
  • Examination
  • Individual coursework
A2 A4 B1 B3Have a knowledge and understanding of the specific challenges inherent in the maintenance and evolution of data-intensive systems, and be able to apply some of the techniques that can be of use in comprehending and changing them.
  • Examination
A2 A4 B1 B3Have a knowledge and understanding of the specific problems inherent in the maintenance and evolution of package-based software systems, and be able to apply techniques for designing change-resistant systems from pre-packaged code.
  • Examination
B1 B3Be able to make appropriate choices regarding the tools and techniques to apply to software evolution problems, trading off costs and limitations against the expected benefits.
  • Examination

Syllabus

Introduction [2]


Motivation for and overview of the course unit. Outlines the challenges inherent in software evolution, based on a case study from real life. Change as a fact of life for software systems.

System Comprehension [6]


Introduction to techniques for understanding software systems built by others. Recognising common architectural patterns. Code reading techniques for program comprehension, including bottom-up reading (based on idioms) and top-down reading (based on abstractions). Additional roles of code reading in agile projects.

Evolutionary Design [4]


Techniques for evolutionary design in the small: refactoring. Techniques for large-scale evolutionary design, especially evolution of legacy systems. Architectural patterns for isolation/exposure of change.


Evolution of Data-Intensive Systems [4]


Specific challenges for incremental migration of data-intensive systems. Impact of data quality on migration of legacy systems. Challenges in comprehending data intensive systems.


Evolution of Black-Box Systems [4]


Introduction to the increasingly common practice of constructing new systems by integrating new software components with software purchase off-the-shelf. Discussion of the special problems inherent in maintaining such systems. Testing and debugging techniques for package-based systems. Glueware and the role of standard component types, such as wrappers and brokers, in modifying package-based systems.

Summary [2]


Exam revision session.

Reading List

The book by Sommerville contains a sizeable section on software evolution, which provides a basic overview.

The book by Pressman contains several chapters which provide useful background to parts of this module, notably chapters 27, 30 and 31.

The Lano and Haughton book is good for maintenance in general and reverse engineering in detail, but is unfortunately now difficult to get hold of (though the JRUL and the School of Computer Science library each have a copy).

Further pointers to reading material for specific lectures can be found on the module web pages.

Title: Software engineering: a practitioner`s approach (8th edition)
Author: Pressman, Roger S.
ISBN: 9781259253157
Publisher: McGraw-Hill
Edition: 8th
Year: 2014


Title: Reverse engineering and software maintenance: a practical approach
Author: Lano, Kevin and Howard Houghton
ISBN: 0077078977
Publisher: McGraw-Hill
Edition:
Year: 1993


Title: Software engineering (10th edition)
Author: Sommerville, Ian
ISBN: 9781292096131
Publisher: Addison-Wesley
Edition: 10th
Year: 2015