Software Construction COMP2100
Course overview
Assumed knowledge & required skills
Introductory programming, preferably in an object-oriented language, to design and implement programs with several classes, with simple inheritance.
Course description
This course is about the implementation (construction) phase and test phase of the software development process. It develops students' skills in programming at the pragmatic level and at an increased level of abstraction. Students will create individual practical assignments on the small scale, and read, critique, and modify medium scale software systems, in part through two major assignments over the whole semester. The system is closely specified and designed around a strong architectural structure, exemplifying abstraction and design patterns, and a graphical user interface. During the semester students learn to improve their own software development practices by following the Personal Software Process to learn time management, planning, and quality control.
The following topics are covered: working with larger software systems; introduction to 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); introductory software design patterns.
Course content
This course is about the implementation and test phases of the software construction process. It is based around paced development of a series of eight or more small programs, and reading, analysing, and modifying existing, larger programs. The formal content of the course is less important than the development of a practical understanding of abstraction in programming. During the semester, students are recommended to follow the Personal Software Process, learning time-management, planning, and quality control, and teamwork skills in practice. The course introduces and applies tools from the software developers toolkit such as version control, build tools, unit testing, review, command shell scripting, integrated development environment, a programming language library. Teamwork skills are developed by practice.
Rationale
This course is part of the second round of the spiral approach to learning software design and construction. It has a primary focus on the software implementation and testing phases.
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 the foundations of programming and a modern object-oriented language (currently Java), 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 and write elementary programs; 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 a larger program example, and understand it in the context of an entire system, and in the human processes of developing software.
This course COMP2100 is the first course in a sequence of 2000-level and 3000-level courses that studies the software process in detail (COMP2100, COMP2120) and provides students with project experience (COMP3100). In particular, the COMP2100 course focuses on the construction phase of the process. This study cannot be carried out in isolation, and some elements of the design phase and testing, in line with modern agility, are involved.
Tools and methods:
The software construction task uses a range of tools (integrated development environments, or context-sensitive editors, incremental compilers, and dependency-sensitive processors (build tools, version control, test-case scripting) and a range of methods (embedded documentation, programming styles, test case design and generation) whose systematic use only makes sense in the construction of software systems above a minimum size and complexity. This course seeks to introduce and exercise these tools and methods in a realistic context.
Experience:
Students need repeated practice in constructing increasingly large programs starting from the fairly small, to build confidence and to develop their experience into repeatable skills. But the phrase ``the Devil lies in the details'' applies with particular focus to software construction. Learning the processcannot be done by 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 alone.
The medium-scale 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, or 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, abstraction, 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 Object-Oriented language (Java)
- abstraction constructs in an OO language
- software design notation (Unified Modelling Language)
- software design patterns
Topics
The following topics will be covered.
- Object technology (classes as design elements, inheritance, genericity, design by contract, exception handling, classes and typing).
- introduction to software design patterns
- 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 and analyse 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 by hand programming with library components
(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);
- present 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, but a Java reference book is strongly recommended.
Workload
Thirty one-hour lectures and six two-hour tutorial/laboratory sessions
