This project is read-only.
Term Project
Spring 2010

You are hired by Philips as a software engineer to develop a system to keep track of orders and the inventory of televisions, DVDs, VCRs,…. ( ) – look under Consumer products/Sound and Vision.

In this term project you will design and develop a small version of such a system. Although this project is a design project, with most of the details intentionally left open, there are certain components and features the system must contain. For each item, the following data must be supplied:
• Model
• Style
• Color
• Maintenance
• Warranty
• Price
At the functional level, the following capabilities must be included:
• Search in the inventory
• Update the inventory
• Process customer orders
• Maintain sales data, e.g. the data of the item sold and the data of the customer it is sold to
No system can exist without a reasonably friendly interface. As a minimum, you must provide a text interface with a hierarchy of menus. Graphical interface is optional.
The entire project is subdivided into the following phases/deliverables:
• Project Plan: Due 2/17
• Project Requirements and Analysis: Due 3/10
• Project Design: Due 3/31
• Project Implementation: Due 4/14
• Project Documentation: Due 4/21
• Project Presentation and Debriefing: In-class 4/28
In order to simulate a real world project, some of the phases of your project will be assigned to other resources. The individual components are outlined below.
It is critical that you have a plan for your project. Lack of planning is one of the leading causes why projects fail. The following is required:
• Develop and plan and schedule for the project
• Identify milestones
• Identify risks
• Complete the Initial Estimate column on the Estimate Matrix hours
• Track the above metrics for each phase in your plan
Initial Estimate Revised Estimate Actual
Phase 1 - Discovery, Requirements gathering, Analysis
Phase 2 - Design
Phase 3 - Coding
Phase 4 - Testing
Phase 5 – Delivery*
Phase 6 - Documentation
*Delivery will be the in-class demo of the end product including the final documentation
Before you even begin thinking about software design, you must set some boundaries. At this stage of the project, the following must be done:
• Determine how much you can achieve in 12 weeks and set some limits on the project accordingly
• Gain a thorough understanding of the major problems to be solved
After the problem is understood and the limitations are set, the next step is to establish some requirements. This involves the following:
• Establish system requirements, e.g. hardware, software, laboratory, etc.
• Understand customer requirements as clearly as possible (this is a delicate procedure because most customers do not know exactly what they want, i.e. their descriptions maybe quite vague in terms of software design)
• Establish the requirements of the dealership, e.g. what kinds of products must the system handle, what departments, e.g. sales or service, are involved in the use of the system, etc.
• Consider other possible, not yet established, requirements, e.g. dual capability Standards
The most critical part of your project is the initial design of the entire system. This has the following important components:
• Investigate how the requirements can be met
• See how the system is decomposed into smaller modules
• Establish the mode of decomposition
o Modular decomposition
o Functional decomposition
o Data-oriented decomposition
o Event-oriented decomposition
o Outside-in design decomposition
o Object-oriented decomposition
• Design the system architecture
• Design the independent components
• Design a form of the user interface
• Document each component of your design
After the system design is completed, a general program design must be performed before coding can commence. The important issues are as follows:
• Establish programming standards and styles
• Set up the major data structures
• Complete the design of major algorithms in the following ways:
o Provide an English description of each major program
o Draw flowcharts demonstrating the structure of major programs
o Provide details of major algorithms in pseudo-code form
Coding is the translation of the user-oriented algorithmic description and pseudo-code into machine executable code. The following issues must be addressed:
• The choice of the programming language
• Coding standards and styles
• Writing of code frames for the entire system
• Review of code frames with respect to flow charts and pseudo-code
• Completing coding
• Debugging and raw testing of individual functions
Once coding is completed, individual units (functions or function groups) must be thoroughly tested. This entails the following:
• Setting up test requirements and procedures
• Performing code inspections
• Finding and removing bugs
• Developing typical test examples
• Performing step/walk-throughs
• Performing various tests
o Statement tests
o Branch tests
o Path tests
o All-uses tests
• Proving code correctness
After the individual units are well tested, it must be seen how well these units are integrated into a complete system. The following major issues emerge:
• Determining integration types:
o Bottom-up integration
o Top-down integration
o Sandwich integration
• Developing testing tools:
o Code analyzer
o Structure checker
o Data analyzer
o Watch dogs
• Developing test case generators
• Establishing confidence indicators, i.e. when to stop testing
One of the most critical parts of software engineering is system testing. This is the last phase of the system building before the system is delivered to the customers. The following tasks must be performed:
• Develop a test bed environment
• Test individual functionalities
• Perform general tests as follows:
o Stress testing, i.e. pushing the system to its limits
o Volume testing, i.e. testing the system with large volumes of data
o Configuration testing, i.e. testing the system on various computer systems
o Time testing, i.e. checking the speed of the system on typical data sets
o Quality testing, i.e. checking reliability, maintainability, etc.
• Perform acceptance testing involving:
o Pilot testing, i.e. experimental testing
o Alpha testing, i.e. in-house testing
o Beta testing, i.e. customer's pilot testing
• Do installation testing at customer's site
• (Always) document your tests
Documentation is performed at three different levels:
• Design documentation to record all important design decisions and architectural components
• System documentation including:
o User’s manual
o In-house documentation
o Operator’s guide
o Tutorials
o Programmer’s guide
• Program documentation which contains for each function the following:
o A one-line description for fast browsing
o A general description
o Typical calling examples
o Accessibility
o Function prototype
o Proper code structuring
o Proper commenting of each important code fragment
System delivery is the happy ending of software design. At the minimum, it includes the following:
• Installation of the system
• Several demonstrations to various user groups
• User and operator training
On the due date, you must:
• Submit a soft and hard copies of all the documents pertaining to the project that is based on your requirements
• Submit the Estimate Matrix
• Analyze the differences on the estimates and provide justification for the discrepancies
• Present the project that is based on your requirements

Last edited Feb 22, 2010 at 12:07 AM by corticus, version 2