Software Evolution (COMP 762)

[News] [Basic Information] [Overview] [Prerequisites] [Course Work and Evaluation] [Schedule] [Links and Documents]

Basic Information

Instructor:	Martin Robillard
Time:	Mondays and Wednesdays, 2:35 pm - 3:55 pm
Location:	McConnell Engineering Building 103
Office Hours:	By appointment

Overview

Much more effort is spent modifying existing software systems than creating new ones. In general, the process of evolving a software system to ensure its continued usefulness and relevance is a complex, costly, and risky business.

This course will explore issues related to software evolution: why it is difficult, and how we can cope with this difficulty. Specifically, the course will look at advanced tools and techniques proposed by the research community to ease, simplify, and automate software evolution, with a special focus in areas of program analysis, modularity, and understanding. The course will also cover the methodology used in validating software engineering results.

In this course, you will have a chance to read and discuss research papers and a carry out a small yet complete software engineering project. After completing this course, you should have a very good idea of the important challenges associated with software evolution and of the methods for doing research in this area.

Prerequisites

An undergraduate software engineering course;
Experience developing software as part of a team using software engineering practices (e.g., configuration management);
Up-to-date knowledge of at least one "industrial" programming language (e.g., Java, C++);
Familiarity with issues in programming languages, object-oriented languages, and object-oriented design;
A good command of written and spoken English (the course is discussion-based)

Please contact the instructor for an assessment meeting if you are interested in taking the course but do not have all the prerequisites.

Course Work and Evaluation

Most of the lectures will be organized around the discussion of one or more research papers taken from software engineering journals and conference proceedings. You will be expected to read each paper covered and be prepared to discuss it in class. In addition, you will be required to lead one in-class discussion and write one paper review. There will also be a take-home final exam consisting of essay questions requiring a synthesis of some or all of the papers covered in the course.

The practical component of the course will consist of a two-part project. In the first part, you will analyze an existing software system to assess its evolvability. In the second part, you will design and implement a software evolution tool or technique, and use the system analyzed in the first part to validate your work. Your results and experiences will be presented to the class during a workshop.

The grading scheme for the course should look like this (subject to change):

Project 1: Software Analysis 15%

Project 2: Prototype Development 40%

Discussion 10%

Paper review 10%

Final exam 15%

Class participation 10%

Intangibles may be considered in assigning grades.

Summary of what to do in this class

Reading: Look at the schedule. Download and read the papers required for each class before the class (all papers in the schedule are required). For each paper, prepare a 1-paragraph summary (see the list of links for guidelines on how to read research papers). Your summary should describe what you think is important about the paper, trying to address the problem/motivation, solution, validation, contributions, and future work, if applicable. A good length for your summary is between 15-20 lines of ASCII. Your summary should not discuss at length your opinion of the paper. However, keep any opinions or ideas about the paper in mind as they will come in handy when we discuss the paper. At the beginning of each class, I will ask a few randomly-chosen students to informally read or present their summary. The mark for this will be factored in the class participation mark.
Formal review: During the first week of classes, you will need to choose one of the papers in the course for a review. I will post on my office door a list of all papers covered in the course that are available for review and discussion. Sign up for one review and two discussions. You may not lead the discussion for the paper you review. Only one student can write a review or lead a discussion for any given paper.
Paper discussions: During the first week of classes, you will need to choose two papers for which to lead a discussion. When the paper is scheduled to be discussed, you will be in charge of leading the discussion. See paragraph above for how to sign up. You cannot pick two papers scheduled on the same day.
Projects: The projects will be posted and submitted using WebCT. Deadlines are posted on the schedule.
Class participation: You will be expected to contribute to in-class discussions by asking questions and proposing your views on the papers discussed.

Academic Integrity

McGill University values academic integrity. Therefore all students must understand the meaning and consequences of cheating, plagiarism and other academic offences under the Code of Student Conduct and Disciplinary Procedures (see http://www.mcgill.ca/integrity for more information).

Schedule

The schedule is posted early to give you an overview of the topics covered. Please keep in mind that it might change.

What the symbols mean. In the last column, a number in brackets (e.g., [7]) indicates a paper that can be selected for discussion and/or formal review. An additional asterix (*) in the bracket indicates a paper that cannot be selected for formal review (but that is still required reading and subject to informal review).

How to obtain the papers. Developing a sense of where to look for software engineering literature is part of the objectives for this course. For the first class, you can download the papers by clicking on the corresponding links in the schedule (from the McGill domain). For the following classes, you will be responsible for tracking down the papers (it's not hard, and I will give you pointers on the first class).

Links and Documents

The links below are all displayed in a new window.

Acknowledgments

The style and content of this course are inspired by the graduate course "Software Engineering" created and taught by Gail Murphy at the University of British Columbia, with additional material from Rob Walker (University of Calgary).

Project 1: Software Analysis		15%
Project 2: Prototype Development		40%
Discussion		10%
Paper review		10%
Final exam		15%
Class participation		10%

Date	Topic	Reading, deadlines, etc.
Wed Sep 1	No class	Make sure to read the papers required for next Wednesday and to write a one-paragraph summary for each (see Course Work and Evaluation).
Mon Sep 6	No class (Labor day)
Wed Sep 8	Overview of software evolution	[] L.A. Belady and M.M. Lehman. A Model of Large Program Development. IBM Systems Journal, 15(3), 1976 (except "Formal modeling...", pages 239-248) [] D.L. Parnas. Software Aging. In Proceedings of the 16th International Conference on Software Engineering, 1994.
Mon Sep 13	Software decay	[1] S.G. Eick, T.L. Graves, A.F. Karr, J.S. Marron, and A. Mockus. Does code decay? assessing the evidence from change management data. IEEE Transactions on Software Engineering, 27(1), 2001. [2] J. van Gurp and J. Bosch. Design erosion: problems and causes. The Journal of Systems and Software, 61(2), 2002. Sign up for paper review and discussion (before class)
Wed Sep 15	Modules and structure	[3] D.L. Parnas. On the criteria to be used in decomposing systems into modules. Communications of the ACM, 15(12), 1972. [4] M. VanHilst and D. Notkin. Decoupling change from design. In Proceedings of the 4th ACM SIGSOFT Symposium on the Foundations of Software Engineering*, 1996.
Mon Sep 20	Software composition	[6] A.P. Black and N. Schärli. Traits: Tools and Methodology. In Proceedings of the 26th International Conference on Software Engineering, 2004. Project 1: email your system description to the instructor (before class).
Wed Sep 22	Aspect-oriented Programming	[] T. Elrad, R.E. Filman, and A. Bader. Introduction to AOP. Communications of the ACM, 44(10), 2001. [] T. Elrad (moderator). Discussing aspects of AOP. Communications of the ACM, 44(10), 2001. [7] H. Ossher and P. Tarr. Using multidimensional separation of concerns to (re)shape evolving software. Communications of the ACM, 44(10), 2001. [8] G. Kiczales et al. Getting started with AspectJ. Communications of the ACM, 44(10), 2001.
Mon Sep 27	Program checking	[9] Y. Xie and D. Engler. Using redundancies to find errors. In Proceedings of the 10th ACM SIGSOFT Symposium on the Foundations of Software Engineering, 2002. [10] C. Flanagan et al. Extended static checking for Java. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation, 2002.
Wed Sep 29	Dynamic Analysis	[11] M.D. Ernst et al. Dynamically discovering likely program invariants to support program evolution. In Proceedings of the 21st International Conference on Software Engineering, 1999. [12] J. Law and G. Rothermel. Whole program path-based dynamic impact analysis. In Proceedings of the 25th International Conference on Software Engineering, 2003.
Mon Oct 4	Reverse engineering	[13] E.J. Chikofsky and J.H. Cross II. Reverse engineering and design recovery: a taxonomy. IEEE Software, 7(1), 1990. [14] H.A. Müller et al. Understanding software systems using reverse engineering technology. In Proceedings of the 62nd Congress of L'Association Canadienne Francaise pour l'Avancement des Sciences (ACFAS)*, 1994.
Wed Oct 6	Software Visualization	[15] W. De Pauw, D. Kimelman, J. Vlissides. Modeling object-oriented program execution. In Proceedings of the European Conference on Object-oriented Programming, 1994. [16] M. Lanza and S. Ducasse. A categorization of classes based on the visualization of their internal structure: the class blueprint. In Proceedings of the 16th ACM Conference on Object-oriented Programming, Systems, Languages, and Applications, 2001.
Fri Oct 8		Project 1 due at 12 noon (submit through WebCT)
Mon Oct 11	No class (Thanksgiving)
Wed Oct 13	Feature location	[17] T. Eisenbarth, R. Koschke, and D. Simon. Aiding program comprehension by static and dynamic feature analysis. In Proceedings of the IEEE International Conference on Software Maintenance, 2001. [18] W. Zhao et al. SNIAFL: Towards a static non-interactive approach to feature location. In Proceedings of the 26th International Conference on Software Engineering, 2004.
Mon Oct 18	Validating research in software engineering I	[] M. Zelkowitz and D.R. Wallace. Experimental models for validating computer technology. IEEE Computer, 31(5), 1998. [19] C.B. Seaman. Qualitative methods in empirical studies of software engineering. IEEE Transactions on Software Engineering, 25(4), 1999 [except 2.2 and 4]. [20] B.A. Kitchenham et al. Preliminary guidelines for empirical research in software engineering. IEEE Transactions on Software Engineering*, 28(8), 2002.[only sections 1,2, 3.1, 4.1, 5.1, 6.1, 7.1, 8 and all the guidelines (in italics in the text)]
Wed Oct 20	Validating research in software engineering II	No reading for this week. Special retrospective workshop. Project 2: email your project description to the instructor (before class).
Mon Oct 25	Project consultation 1	No reading this week. This class time will be reserved for one-on-one meetings with the instructor to review the project proposal.
Wed Oct 27	Project consultation 2	No reading this week. This class time will be reserved for one-on-one meetings with the instructor to review the project proposal.
Mon Nov 1	No class (FSE Conference)	Class and reading time is to be used for your project.
Wed Nov 3	No class (FSE Conference)	Class and reading time is to be used for your project.
Mon Nov 8	Virtual Modules	[21] E.L.A. Baniassad and G.C. Murphy. Conceptual module querying for software reengineering. In Proceedings of the 20th International Conference on Software Engineering, 1998. [22] M.P. Robillard and G.C. Murphy. Concern Graphs: finding and describing concerns using structural program dependencies. In Proceedings of the 24th International Conference on Software Engineering, 2002.
Wed Nov 10	Design conformance	[23] G.C. Murphy, D. Notkin, K. Sullivan. Software reflexion models: bridging the gap between source and high-level models. In Proceedings of the 3rd ACM SIGSOFT Symposium on the Foundations of Software Engineering, 1995. [24] M. Sefika, A. Sane, R.H. Campbell. Monitoring compliance of a software system with its high-level design models. In Proceedings of the 18th International Conference on Software Engineering, 1996.
Mon Nov 15	Restructuring	[25] W.G. Griswold et al. Tool support for planning the restructuring of data abstractions in large systems. In Proceedings of the ACM SIGSOFT Symposium on the Foundations of Software Engineering, 1996. [26] T. Mens and T. Tourwé. A Survey of software refactoring. IEEE Transactions on Software Engineering*, 30(2), 2004.
Wed Nov 17	Introduction to software architecture	[] D. Garlan and D. Perry. Introduction to the special issue on software architecture. IEEE Transactions on Software Engineering, 21(4), 1995. [27] D. Garlan, R. Allen, J. Ockerbloom. Architectural mismatch, or, Why it's hard to build systems out of existing parts. In Proceedings of the 17th International Conference on Software Engineering*, 1995.
Mon Nov 22	Software architecture analysis	[28] R.J. Allen and D. Garlan. Formalizing architectural connections. In Proceedings of the 16th International Conference on Software Engineering, 1994. [29] J. Aldrich, C. Chambers, and D. Notkin. ArchJava: connecting software architectures to implementation. In Proceedings of the 24th International Conference on Software Engineering, 2002.
Wed Nov 24	Recent developments	[30] T. Zimmermann et al. Mining version histories to guide software changes. In Proceedings of the 26th International Conference on Software Engineering, 2004. Review: Email your paper review to the instructor (before class).
Mon Nov 29	Workshop 1	Project presentations
Wed Dec 1	Workshop 2	Project presentations
Mon Dec 6	Course wrap-up	Email your Project 2 report to the instructor by 12:00PM (noon).
Wed Dec 8	Course wrap-up	Final exam question available on WebCT at 12:00PM (noon).
Thu Dec 9	Course wrap-up	Final exam answer due on WebCT at 12:00PM (noon).
Later	Course wrap-up	Project 2: Project demonstrations (schedule time with the instructor)