SE2 (ECE452/SE464/CS446/CS646): Software Design and Architecture Fall 2006

Prof Ric Holt, Department of Computer Science, Waterloo University

Assignment 2: Detailed Design


This assignment is a follow-on from Assignment 1, in which the goal was to design a Software Architecture for the information processing layer of the Voice Over IP (Voip) system.


The following constraints, previously given in assignment 1, still hold.

For this version of the course, the following constraints are imposed by the management:


You are to produce a report that documents the Detailed Design of the software that you propose to develop for the Voip system (for upper level in this term). Your target audience is to be a junior programmer who is to implement your design as well as a manager or developer who is somewhat but not intimately familiar with Voice Over IP. A junior programmer should be able to correctly implement any package or module given your Detailed Design.

Your report giving the Detailed Design for the Voip system is to be a companion document to go with your report on the Architecture. Ideally, you will repeat little that was already given in your Architecture report. At the same time, your Detailed Design report should, as much as reasonable, be a standalone document that can be read without the Architecture report.


You report should include the following:

Title: About 3 to 6 words making clear what your report is about.

Authors: List of authors, their addresses, date, etc.

Abstract: About 2/3 of a page overviewing the key points in your report, targeted to a programmer, developer or manager.

Introduction and Overview: About 1 to 3 pages summarizing the purpose of report, its organization, and its salient conclusions. A person should be able to read just the abstract or just the introduction and have a good idea what is in the rest of your report.

Detailed Design:

You are to give, for each module, a clear specification for the module, such that a junior programmer can implement that module. The Detailed Design will include a clear description of the behaviour of the module and its externally visible interface. It will include a description of algorithms and data structures to be used and will give pseudo code when necessary to describe non-obvious implementation techniques.

In this version of the course, the implementation is to be in Java, so a "module" or a package will eventually be implemented as a set of files in the Java language. A subsystem is to be a set of packages or modules and other systems.

You should reference descriptions in your Architecture report of important patterns, classes abstractions, data structures or algorithms that are critical to the successful implementation of your system. Use diagrams as appropriate for this report. Do not include diagrams unless they are actually useful to the readers of you Detailed Design.

External Interfaces: Give details of information transmitted to/from the system, such as the Graphical User Interfaces, files, data bases, messages or networks. This should include menu design (give example menus) and an unambiguous specification of any details by which modules in the system transmit information to/from the external interfaces. If appropriate, give Java interfaces to specify these methods. You do not need to include a discussion of feasibility studies.

Data Dictionary: Update the glossary in the Architecture report as necessary to include any new terms you have defined.

Programming Conventions: List programming conventions that your programmers are required to follow, including conventions for naming procedures and variables.

References: List any documents that your reader may wish to or need to read in conjunction with your report. Since the report is to be web readable, include links to references when appropriate.


Do not make your report longer than necessary. In general, shorter reports that contain appropriate information are preferred. Your report must not be longer than 20 pages (in the hard copy version), including all diagrams and appendices.

Write clearly. Organize your report so it is easy to find things in it.

Design to minimize the need for documentation (while maximizing the simplicity and understandability of your system), without sacrificing necessary system performance.


The next assignment, number 3, is to implement this Detailed Design. Each implemented package or module is to include as comments its specification (given in this Detailed Design report).

In particular, each package or module should include a comment that gives the package or module specification. These comments in turn should be written so that they (and the items they define) can be mechanically extracted from the code, eg, ideally Javadoc should be able to produce convenient documentation of your implementation.