Introduction After finalizing your design, your team shall implement the
software according to the design and requirements for your
application. In conjunction with coding each unit, your team
develop unit test plans covering each of the implemented units.
For this assignment, you must turn in both a descriptive document
(and electronic copy of)
code listings as described below. The source code should be documented
with sufficient, informative comments. This deliverable also includes
unit test plans and test execution histories, which should functionally
and structurally test each unit in the implementation. You should
the unit test plans and test history documentation in much the same way
as the units themselves are organized in the implementation. You need
print out the results of all testing activity, but should show enough
of executing your unit test plans to convince us that your units are
Specify the correspondence between your software design and the
Show this correspondence any way you feel is appropriate (e.g., make
throughout your document or in your minutes), but by all means include
some discussion in the overview section. Implementing the software will
undoubtedly reveal inadequacies in previous documents. Please note
problems and what was done to solve them.
Don't forget to include your meeting minutes and performance appraisals
with your deliverable. You probably want to post your
document and your meeting minutes to your team web page.
Be sure to address:
status of requirements that are not implemented and/or tests that
changes to your design and/or requirements
current plan for reaching successful acceptance test
Update the introduction from your Design Deliverable. Expand as
necessary to discuss your specific approaches to the implementation
of the system and the organization of this document. This
description should guide the reader.
Update and summarize
your project plan to represent how you have accomplished the work so
Reassess the project risks. Based on
the work you have done, revise your estimates on how much your team can
accomplish and deliver. Update your time estimates for the remaining
If you made changes, add text describing why the change was
or why it will improve the ability of your team to accomplish the work
you have proposed.
Give an overview of the implementation. Describe how it works,
provide characterizations of its size, and discuss limitations in its
current state. Provide a link to an electronic version of the
source code. In the document, provide an organization by
module/work unit that can be used to peruse the source code. For
example, for each module, list the source files and briefly discribe
what they contain.
Unit Test Plan/Test History
For your test plan, show the status of each test. For tests
that are not passed, briefly discuss the issue.
Modifications to Prior Documents
These next two
subsections may be short but are extremely important.
Highlight any changes to the design and discuss
why the change was made and by whom (customer, developer,
etc.). Again make sure your design meets the objectives of
abstraction, modifiability, and consistency. If your design has not
then this section will be empty.
Highlight any requirements that are changed, added or deleted. Indicate
why the requirement was changed/added/deleted and by whom (customer,
etc.). Again make sure your requirements meet the objectives of
understandability, utility, unambiguity, and consistency. If your
have not changed, then this section will be empty.
This section is reserved for any additional documentation you may have
developed during this phase of the project. Specifically, if during the
course of developing the your understanding of the various technologies
involved in the project, you discovered items that were not documented,
but which were important, then you should include that here.
Additionally you should list here the major background sources of
that you used during this phase or any that you plan to use during the
remainder of the project. This would include references to similar
One member from the team should prepare a 10-15 minute presentation,
after which we will have time for questions and answers. Your
presentation should include the following:
Very brief context to your project;
Current state of your project plan. Be sure to include a table
showing how many hours were originally planned for each phase and how
many hours you actually spent on each phase. For
phases where there is a large difference (>25%) provide an
Highlights of your implementation including
an overview of your architecture
one or more module/object implementations and associated unit
requirements and design cross reference for the highlighted
A description of how many lines of code you've written, how many
files they are in,
and how those files are organized. A good way of showing this is as a
the file/directory structure, with each leaf node annotated with the
number of lines of code
in that node, and each non-leaf node annotated with the aggregate
number of source lines
in all subsidiary directories and files.
Modifications to your requirements and design that arose as a
your coding process;
project assignments are extensively based on those of Professor Richard
Taylor at UCI.