Software Construction for Software Engineers COMP2500
Course overview
Assumed knowledge & required skills
introductory programming, preferably in an object-oriented language
Course description
This course is about the implementation and test phases of the software construction process. It is based around creating individual practical assignments on the small scale, and modifying a medium scale project in two major assignments over the whole semester. In this project, students work on a substantial application, relevant to their experience as computer users. The project is closely specified and designed around a strong architectural structure as an exemplar, and may involve a graphical user interface. During the semester students learn to improve their own software development practices by following the Personal Software Process, learning time-management, planning, and quality control. The course also studies aspects of the principles and practices of software engineering.
The following topics are covered: working with software larger systems; code review and inspections; test planning and unit testing (derived from specification and design documents); object-oriented (Java), and scripting (Bash) languages; recursive data structures; graphical user interfaces; the Personal Software Process; build tools (Make and Ant) and version control (Subversion); use of external code libraries.
Course content
This course is about the implementation and test phases of the software construction process. It is based around an individual project lasting the whole semester. In this project, students work on the construction of a substantial application, relevant to their experience as computer users. The project is closely specified, and involves a graphical user interface. During the semester, students follow the Personal Software Process, learning time-management, planning, and quality control. Develop knowledge of the professional tools in industry, and develop professsional communication skills.
Rationale
This course is one of three courses (COMP2100, COMP2110, COMP3110) which address constructive aspects of the software development process. It has a primary focus on the software implementation and test phase.
This course can be placed in context from several points of view.
Process: This course follows on from a 1000-level sequence of courses (COMP1100 and COMP1110) that introduces a modern object-oriented language (Eiffel) and introduces the main themes of software engineering. One way to characterise the development of maturity over this sequence of courses would be to say that by the end of COMP1100 students can read a class and write a routine; by the end of COMP1110 they can read a multi-class system and write a whole class; and by the end of COMP2100 they can read a design and write an entire system.
COMP2100 is the first course in a sequence of 2000-level and 3000-level courses that studies the software process in detail (COMP2100, COMP2110, COMP3110 and COMP3120) and which provide students with project experience (COMP3100). In particular, this course focuses on the construction phase of the process. This study cannot be carried out in isolation, and some elements of the design phase are involved.
Tools and methods: The software construction task uses a range of tools (context-sensitive editors, incremental compilers, dependency-sensitive processors (make, version control, test-case scripting) and a range of methods (embedded documentation, programming styles, test case generation) whose systematic use only makes sense in the construction of software systems above a minimum size and complexity. This course seeks to exercise these tools and methods in a realistic context.
Experience: The phrase ``the Devil lies in the details'' applies with particular focus to software construction. It is not amenable to a reductionist approach where a set of knowledge elements are worked through in sequence. Rather, a case-based approach is appropriate. The students are confronted with the complexity that only a nontrivial software system can bring, and gain experience in confronting and learning to cope with this complexity. Such experience cannot be captured in a set of small exercises.
This exercise will be typically be built around a construction of a technical ``computing tool''. Possible examples are: basic Web browser , email client, text editor, spreadsheet, file manager, help viewer, calendar manager, UML class-diagram editor, document data structure transformation, rendering, and manipulation.
Here the essentials of a nontrivial tool are constructed from first principles. Generally the approach involves the identification of the intrinsic ``abstract machine'' inherent in the tool. This will exercise many of the recurring themes in computing (dynamic data structures, linguistic elements, graphical user interfaces).
Ideas
This course carries the main responsibility for the following ideas:
- control of complexity in software construction,
- coding standards and styles,
- quality issues in software construction,
- personal software process in the construction phase.
This course shares the responsibility for the following ideas:
- the object-oriented approach to software design, construction, and testing,
- dynamic data structures and basic algorithms over those structures,
- basic elements and constructs of a working OO language (Java)
- abstraction constructs in an OO language
Topics
The following topics will be covered.
- Object technology (classes as design elements, inheritance, genericity, design by contract, exception handling, classes and typing).
- Test planning and testing procedures (JUnit tool)
- Software construction methods (program dynamics and debugging; task dependencies: build tools theory and use (make tool); version control (subversion tool); programming standards; module documentation; command shell language scripting, (Bash shell)
- Elements of graphical interfaces (rationale of standard GUI libraries, interface design principles) (Java Swing).
- Dynamic data structures: reinforce use of linear structures (array, list, queue, stack), tree structures and traversal algorithms, tree representation of abstract syntax.
- The Personal Software Process: time recording and summaries, personal process improvement, code reviews.
Technical skills
- use an integrated development environment to develop small object-oriented programs, and to gain understanding to modify medium-sized programs
(level in Biggs SOLO taxonomy: 3 ; generic graduate attributes: 3); - understand program specifications and architecturally based design of medium-sized programs
(level in Biggs SOLO taxonomy: 2 ; generic graduate attributes: 3); - design and create simple command shell script programs
- apply standard tools (make, subversion, an industrial quality editor or IDE, grep, shell command scripting) on small programming tasks
(level in Biggs SOLO taxonomy: 2 ; generic graduate attributes: 3); - find, read and use documentation for tools and class libraries (level in Biggs SOLO taxonomy: 2 ; generic graduate attributes: 3, 10);
- construct a simple graphical user interface
(level in Biggs SOLO taxonomy: 3 ; generic graduate attributes: 2, 3); - follow the estimation and error reporting parts of the Personal Software Process and use the data collected to improve their effectiveness (level in Biggs SOLO taxonomy: 2 ; generic graduate attributes: 1, 10);
- write clear, concise reports on program development work they have carried out (level in Biggs SOLO taxonomy: 3 ; generic graduate attributes: 2);
Textbooks
There is no required textbook for COMP2100. Useful reference books are:
Tremblay, Jean-Paul & Cheston, Grant A. Data Structures and Software Development in an Object-Oriented Domain, Java edition, Prentice-Hall, 2003.
Humphrey, Watts Introduction to the Personal Software Process, Addison Wesley, 1997.
Hunt, Andrew & Thomas, david The Pragmatic Programmer , Addison Wesley, 2000.
McConnell, Steve Code Complete , Microsoft Press, 1993.
Workload
Thirty-two one-hour lectures, six two-hour tutorial/laboratory sessions and two one-hour seminars
