CPSC 333: About This Course

Location: [CPSC 333] [Listing by Topic] [Listing by Date] [Next Topic] About This Course

This material was covered during lectures on January 8-10, 1997.

Much of What You Think You Know about Programming is Incorrect

The lecture began with the claim that ``much of what you know about software development is incorrect (sort of).''

This means that the experience of participating in an undergraduate course in programming, or even of doing an entry-level job in programming, differs substantially from the development and maintenance of complex software in a commercial or industrial setting - so that some of the conclusions you might make about software development after participating in an undergraduate programming course are invalid.

In an Undergraduate Course in Programming...

During Commercial Software Development...

First, it should be noted that ``commercial software development'' is very diverse, so that almost no statement made here will apply in every case. However, most of the statements that follow are valid for projects involving complex software, that is either being developed for a single client or is to be sold commercially, provided that it's too large to be developed by a single person, and provided that this software is to be used and maintained for a period of years or decades - as is frequently the case.

Things to Keep in Mind

A Definition of Software Engineering

There have now been quite a few attempts to define software engineering. Here is an early (but useful) definition given by Fritz Bauer:

Software Engineering is the establishment and use of sound engineering principles in order to obtain economically software that is reliable and works efficiently on real machines.

As an exercise, you should reread the material that precedes this (and what follows it), and see how it relates to this definition!

Course Goals

We will consider the software development cycle from the perspective of a developer of software (rather than the perspective a manager, customer, user, etc.). Requirements analysis and specification, software design, and testing will be emphasized. Very little will be said about maintenance because of lack of time, and because this involves many of the things that will be introduced when requirements analysis, design, and testing are discussed. Very little will be said about coding, because this has already been discussed in CPSC 231, 233, and (to some extent) 331.

Sound development principles will be introduced and discussed. It's likely that these principles will endure, even though development methods are changing.

Methods for requirements analysis and specification, software design, and testing will be introduced. Some time will be spent on methods that might be useful for the maintenance of old software (chiefly, ``structured'' or ``function-oriented'' methods), newer methods that are frequently recommended for the development of new software (chiefly, ``object-oriented'' methods), and methods that aren't yet widely used in industry but that might be used more extensively in the future (in particular, the course will include an introduction to formal methods for the specification of requirements and for program verification, if time permits).

You'll See It Again...

Some of the material introduced in this course will likely be seen again in senior computing courses. For example, some of the requirements specification models and methods (notably, state transition diagrams) may appear again in CPSC 481; entity-relationship diagrams may be used in CPSC 461. You will be participating in a development project as part of a large group in CPSC 451, and may be applying several of the methods introduced in CPSC 333 when you work on that course's project.

Two Development Paradigms

Structured Development

This is sometimes called function-oriented development - or process-oriented development. The version that will be discussed in this course might even be called data-oriented development, since we will be discussing the design of a relational database (first) as part of this.

Stored data may be stored in either a set of files, or in a relational database.

Programs will consist of many independent functions, such that each has a clearly identified task to perform. Ideally, none of these functions has side effects, no function will perform more than one of these tasks, and no single task will be split among several functions.

C, Pascal, or Modula are programming languages providing the features needed to code software developed using this paradigm. If you're ``lucky,'' then the older software you get to maintain will have been developed this way.

Object-Oriented Development

In object-oriented software, data is ``encapsulated'' along with functions to form objects. The data inside these objects can only be accessed or modified (by the rest of the system) through the object's interface. Thus, implementation details are hidden from the rest of the system, and can be changed as needed in a relatively safe way.

Objects with similar characteristics belong to the same classes.

Software consists of multiple objects that communicate, and cause work to be done, by sending messages from one to another (again, using the objects' interfaces).

Inheritance mechanisms and templates allow large software components to be modified and reused more easily than is possible using other development approaches. This allows developers, development teams, or businesses to produce and refine their own software libraries as they work on projects, reducing the amount of software that will be needed to be developed ``from scratch'' in the future. It also allows software to be developed more easily in an incremental fashion - so that (for example) a small number of functions can be supported initially, and extended or added to later, making it possible for working (sub)systems can be assessed and refined before work on other subsystems have started.

C++, Java, and Smalltalk are all ``object-oriented'' programming languages that support many of the features needed for this kind of development.

A Brief Outline

Three development activities will be considered in this course in some detail:

  1. Requirements Analysis and Specification
  2. Software Design
  3. Software Testing

For each of these topics we will begin by considering goals and principles for this activity. For the first two topics, we will consider methods for performing the activity as part of structured development as well as object-oriented development. This may be more difficult for the third topic, since not much has been written yet about ``object-oriented testing,'' but testing objects will also be discussed, if possible.

If time permits, then the course will end with a brief introduction to ``formal methods'' for the specification of requirements and for the verification of programs.

Location: [CPSC 333] [Listing by Topic] [Listing by Date] [Next Topic] About This Course

Department of Computer Science
University of Calgary

Office: (403) 220-5073
Fax: (403) 284-4707