UIT2201: CS & the IT Revolution
Class Software Project (Fall 2003)
Software Project Methodology
Project Development Methodology
There are several (possibly concurrent) phases involved
in building a software emulation of the chosen "intelligent appliance" (IA).
- Coming up with the Concept
- Getting the appropriate "Look and Feel"
-- (Everyone)
- Requirements gathering -- getting the wish list
-- (Everyone)
- Setting Priorities and Schedule
-- (Prof Leong)
- System Architecture Design
- System Architecture Design
-- (Prof Leong and Student Assistant)
- Writing Detailed Use-Cases
-- (Prof Leong and Student Assistant)
- Systems Design Design
- High Level Design (Sub-systems) and Integration
-- (Prof Leong and Student Assistant)
- GUI Design and Implementation
-- (GUI)
- DBMS Desgin and Implementation
-- (DBMS)
- Feature Design, Implementation, Testing and Integration
- Module Detailed Design
-- (FDIT)
- Module Coding and Testing
-- (FDIT)
- Integration
-- (FDIT, Student Assistant)
- Documentation, Installation and Deployment
- Writing User Manual
-- (DOC)
- User Training (Manual and PPT presentation)
-- (DOC)
- Infrastructure Mgmt
-- (provided by SoC)
- Hardware required
-- (provided by SoC)
- Software and services required
-- (provided by SoC)
- Technical Expertise for installation and maintenance
-- (Student Assistant)
We give some rough description of the different project tasks as
outlined above.
Requirements Gathering
The task of requirements gathering is to brainstorm the various features
that we would like to have in the chosen intelligent appliance (called
IA here). This is sometimes known as the "wish list" which
usually contain too many features that can be feasibly implemented.
From the wish list, we prioritize and sift out the "feature list"
which represents the features chosen for actual implementation.
Software Architecture Design
This task is to design a system architecture for the IA that
will best allow a team of novice programmers to contribute to
the project without the need to know all the details of the system.
Architecture design includes the decomposition of the
system into subsystems/components
(including DBMS, GUI, controllers, feature modules, etc).
It will also include the implementation of the main components
of this system together with providing sample codes/templates
for working with different parts of the systems.
Writing Detailed Use Cases
This task is to take each feature/requirement in the feature list
and work through the use cases (workflow) for implementing the feature.
From these, we should get the data requirements as well as the
functional (module) requirements of the system/subsystem.
As part of this is also the specification of test cases for complete
testing of the feature.
High Level Design and Integration
From the use cases (& data and module requirements), this task is to write
up the module specifications (including the API's -- input/output requirements).
These includes modules that deals with the GUI, databases.
The modules are to be separately (and independently) developed, tested
and integrated into the system when ready.
GUI Design and Implementation
This task is to design and implement all various screens for the GUI of the
IA system. The GUI teams will need to know the possible responses and forms
required for the various sub-systems.
DBMS Design and Implementation
This task is to design the database schema, including the tables, the fields
to be added in and also implement the
interfaces needed to access and to edit the various databases
(either online or "offline").
An important part of this task is also the job of coordinating
and entry of test data for testing out the various functionality
of the system.
Feature Design, Implementation, and Test
The task here is to implement the various modules that are needed to
support the implementation of the features in the feature list.
The API's for each module will be given to you --- however, some detailed
design may still be needed in the implementation of the module ---
including working with the databases (and may also require changes/additions
to the databases). Many teams will be required to implement the many
features -- however, each team will be able to operate independently
to test their results separately. Their result will only be integrated
after they have been independently tested.
User Manual and Training Notes
This task is to write up a state-of-the-art user manual for users of
the system. Another task is to prepare training notes for training
novice users of the system.
Both the user manual and the training notes should cover all
aspects and features of the system.
Team Assignments:
Based on the project methodology above, the students will be
divided into teams to undertake different parts of the project.
Some of the tasks require more manpower than others and so more
teams will be assigned. These will be decided later.
Students with more experience will be paired with those with
less experience to enhance student learning and teaching experiences.
UIT2201: CS & IT Revolution; (Fall 2003); A/P Leong HW