COMP1120: From Programming to Software Engineering

(6 units) Group A
First Semester

Thirty one-hour lectures and twelve two-hour tutorial/laboratory sessions

Lecturer: Dr Peter Strazdins with Ms Carol Edmondson, Dr Malcolm Newey and Mr Richard Walker

Prerequisites

Admission is by approval of Head of Department. Students will be required to demonstrate an appropriate level of prior programming experience. Students are assumed to have achieved a level of knowledge of mathematics comparable to at least ACT Advanced Mathematics major or NSW Mathematics or equivalent.
Incompatible with COMP1100, COMP1110, COMP1011, ENGN1002, ENGN1213

Syllabus

This course presents the principles of programming from an object-oriented perspective and introduces students to the tools and techniques for developing software systems of a size and quality that is industrially relevant nature. The course teaches the fundamental strategies of abstraction, decomposition and reuse as methods for constructing such systems. Verification and validation techniques, with an emphasis on testing, are taught as a means to ensure that students are able to deliver software products of the quality required.

In particular, the course will introduce concepts of object-oriented programming in Eiffel (class, object, attributes, routines), the basic Eiffel library classes, straightforward algorithms for search and searching, object-oriented methods (class inheritance, assertions on routines, design by contract).

The course will also cover the foundations and use of recursive algorithms in problem solving; structured data types, abstract data types and their applications; system life-cycle, modularisation, and construction of large systems.

The course has a strong practical emphasis, with required attendance at laboratory sessions.

Description

This course provides an introduction to the basic principles of programming from an object-oriented perspective, using the programming language Eiffel. It uses the ``consumer before producer'' viewpoint, in which the student programmer is a consumer of existing software (studying exemplar Eiffel programs, and using Eiffel library classes) before moving to be a producer of software components (first by extending and modifying existing Eiffel classes).

The course provides the concepts and skills necessary to begin writing correct multi-module programs. It introduces them to the fundamental concepts of the software life-cycle, and to methods for rigorous software development. Verification and validation techniques, with an emphasis on testing, are taught so that students are able to deliver the software products required of them. Once delivered, the working life of a commercial application may well reach into decades and so students are taught skills and tools necessary to maintain software, and to create documented, maintainable software in the first place.

Rationale

For students already with a background in (procedural) programming, this first course on the curriculum for the BInfTech and BSEng degrees provides them with a grounding in object-oriented programming. The course is based on the conviction that modern object-oriented methods can deliver software systems that are extendable, reusable and reliable, across a wide range of problem domains.

Industrially relevant problems typically require programs of a size and complexity that renders undisciplined approaches to their construction destined to failure. This course also teaches the fundamental strategies of abstraction, decomposition and reuse as methods for overcoming these problems.

Ideas

This course will carry the main responsibility for:

• the main concepts of an object-oriented programming language and their implementation in Eiffel,
• program maintenance and development using an editor (Emacs) and compiler (GnuEiffel) in the context of a conventional operating system (Unix),
• the systematic use of an agreed programming style (layout, name convention, documentation),
• introducing the general idea of abstraction as a tool for combating complexity in systems (data abstraction, design by contract),
• developing a stepwise refinement approach to implementing large programs,
• describing the software development life-cycle as a model of the process of software construction, and
• introducing formal systems and notations as software-engineering tools.

Topics

The following topics will be covered:

• a review of the basic concepts of imperative programming,
• the principles of object orientation,
• the basic Eiffel classes (BOOLEAN, INTEGER, CHARACTER, REAL, DOUBLE) and library classes (STRING, ARRAY),
• the run-time structures of Eiffel (object store (heap), activation stack, current object, memory management),
• elements of algorithms (techniques using iteration, loop invariants, simple solutions to search and sort problems),
• abstraction mechanisms (assertions on routines, design by contract, assertions on loops, assertions on classes) and extendibility mechanisms (class inheritance, generic classes),
• basic data types: enumerations, lists, stacks, queues, tables, arrays, graphs, sets; their algebraic properties and use in problem solving,
• data structures,
• sorting and searching: serial and binary searching, O(n*n) sorting algorithms,
• recursive algorithms: comparison with iteration, connection with induction,
• simple regular expressions,
• fundamental problem solving, and
• software quality: unit testing strategies, pre- and post-conditions, loop and class invariants.

Objectives

Upon completion of this course, the student will be able to:

1.   describe the concepts of an object-oriented programming language (Eiffel).
2.   given the specification of a simple task, write an Eiffel program to perform that task.
3.   in the context of an Eiffel program involving several programmer-written classes and several library classes:
   • systematically determine program properties such as class relationships (client diagram, inheritance diagram) and flow properties (control flow diagram, data flow diagram),
   • systematically determine the run-time behaviour of the program, and
   • write a narrative description of selected program properties.
4.   given an appropriate specification, modify the behaviour of a given program within its design and architecture by such techniques as
   • changing relevant program parameters,
   • modification of relevant routine bodies,
   • class extension, and
   • construction of new classes.
5.   complete the implementation of an Eiffel class, given as specification of the required behaviour of the class.
6.   analyze alternatives among simple data-structures -- stacks, queues, and arrays, for example -- and select the most appropriate structure for a simple task.
7.   explain and analyze alternatives among simple algorithms -- sorting and searching, for example -- and select the most appropriate for a simple task.
8.   reason about the correctness of a simple program fragment given a description of its required behaviour.
9.   apply their knowledge of regular expressions to devise regular expressions and to match target phrases (strings).
10.   apply their knowledge of testing principles to select appropriate test data for an individual software routine.
11.   identify economic implications of the software life cycle to the process of software construction.
12.   identify the invariant of a simple loop.
13.   apply the technique of recursion to implement simple requirements.
14.   independently use selected writings in computing to analyse and explain technical computing problems.

Assessment

The following assessment modes are used:

Examination:

The course will have a final examination, supplemented by a mid-semester exam. These primarily test objectives  1,  2,  8,  9,  11 and  12. Other course objectives may also be examined in a supplementary way by this assessment.

Assignments:

Students will complete three programming assignments in which they are required to analyse and implement alternative data-structures, devise test sets to check the quality of their implementation, and write a report discussing their analysis and testing results. These assignments will test objectives  3,  4,  5,  6,  7,  10. and 13.

They may also require the student to complete selected readings from the computing literature; this will test objective  14.

Technical Skills

Upon completion of the course the student will be able to use a modern GUI-based computer system (Unix, CDE) to perform the following tasks:

• effectively use web, news and email utilities,
• construct directory subsystems to support laboratory and assignment tasks,
• use a modern editor system (Emacs) to write simple text documents, and compile and execute Eiffel programs (GnuEiffel compiler system),
• use the wild-card expansion facilities of the shell to match multiple files,
• use the UNIX grep tool to find files containing targeted regular expressions, and
• proficiently use Emacs to edit Eiffel programs and to view the short forms of Eiffel classes.

Recommended Reading

• Susanna S. Epp. Discrete Mathematics with Applications. Computer Science Press, New York, 1995.
• Jacob Gore. Object Structures: Building Object-Oriented Sofware Components with Eiffel. Addison-Wesley, Reading, Massachusetts, 1996.
• Jean-Marc Jézéquel. Object-Oriented Software Engineering in Eiffel. The Eiffel in Practice Series. Addison-Wesley, Wokingham, England, 1996.
• Bertrand Meyer. Object-Oriented Software Construction. Prentice Hall, Upper Saddle River, New Jersey, 2nd edition, 1997.
• Pete Thomas and Ray Weedon. Object-Oriented Programming in Eiffel. The Eiffel in Practice Series. Addison-Wesley, Wokingham, England, 2nd edition, 1997.