Class Software Project, UIT2201 (Spring 2003), NUS

UIT2201: CS & the IT Revolution
Class Software Project (Spring 2003)
Emulation of An Intelligent Appliance

About the UIT2201 Class Software Project

Software systems have revolutionalized the world -- in all aspects of our lives and they are becoming pervasive. It is best to learn about the revolution by experiencing it -- and in this course, we shall experience it by developing a software system ourselves.

It will be a group-based project in which the class will be divided into project teams. The project teams will work on different aspects of the system.

The project will be decomposed into several smaller and more manageable modules. The basics of each module will be discussed during tutorials at the appropriate time -- and the module will then be enhanced by the relevant group.

Possible Software Project

Software emulation of an intelligent appliance. The possible appliances, as proposed by the students, are:

(11 votes) door
(4 votes) lift/elevator
(4 votes) spectacles/glasses
(2 votes) refridgerator
(2 votes) washing machine
(2 votes) car
(2 votes) tv
(1 vote) telephone
(1 vote) coat
(1 vote) shoe
(1 vote) clock/watch
(1 vote) air conditioner
vacuum cleaner/broom
microwave
pen
hifi
lights

Based on your votes, we consider choices with at least 2 votes. Recall that in making a choice, we have to favour those that has scope for discussing most of the topics covered in the course. We will have to exclude choices that are too limiting (not much scope to explore all the topics in the course) or too complicated (requires a lot the detailed technical domain knowledge).

Based on those, I will exclude car, tv, glasses, and washing machines. Factoring in your votes, this leaves us with three choices:

door,
lift/elevator,
refridgerator.

Selected Software Project -- An Intelligent Door!

After the 2nd round on 13-Feb-2003, the overwhelming choice was for DOOR -- and so a cool, intelligent door it is.

We now need to find a cool, creative name for our Intelligent Door. So, all you creative types, get cracking!

Project Development Methodology

There are several (possibly concurrent) phases involved in building a software emulation of the chosen "appliance".

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)
- Writing Detailed Use-Cases
System Architecture and Design
- System Architecture Design -- (Prof Leong)
- High Level Design (Sub-systems) and Integration -- (SDA1)
- GUI Design and Implementation -- (SDA2)
- DBMS Desgin and Implementation -- (SDA3)
System Implementation, Testing, and Integration
- Module Detailed Design -- (SI1 - SI4)
- Module Coding and Testing -- (SI1 - SI4)
- Integration -- (SI1 - SI4, SDA)
Deployment and Infrastructure Mgmt -- (provided by SoC)
- HW required;
- Software and services required
- Technical Expertise (installation and maintenance)
- Management of the Infrastructure and Services

Team Assignments:

Based on the project methodology above, we have formed teams and given their assignments as described here.

SDA1: Software Architecture and Integration

This team will be responsible for design the system architecture and integrating the various sub-systems of the Intelligent Door Emulation Application (IDEA).

They will design the following:

plan and design the various IDEA sub-systems
implement the central controller that will integrate the various sub-systems (sub-systems to be initially implemented as stubs)
design the appropriate interface so that the various sub-systems can be separately and independently developed and tested
manage the integration of the various sub-systems

SDA2: GUI Design and Implementation

This team will design and implement all various screens for the GUI of the IDEA system. The GUI team will need to know the possible responses and forms required for the various sub-systems.

SDA3: DBMS Design and Implementation

This team will 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").

SIx: Systems (Feature) Implementation

This group will be divided into teams of 2 each. Each team will be responsible for implementing a feature of the IDEA. These features can be implemented independents and integrated after they have been debugged and tested.

Requirements for Our Intelligent Door!

On 13 Feb, five groups of 4-6 students had brainstorming sessions to come up with requirements for our Intelligent Door.

The results (as submitted by the scribes) are as follows:

Khoo Teck Ping -- Requirements (pdf)
Daniel Lim Chen-Yi -- Requirements (txt)
Ng Kok Shern -- Requirements (txt)
Heng Wei Chu -- Requirements (not ready)
Michael Park Jun Seo -- Requirements (not ready)

Feature List:

The feature list gives the list of the requirements that has been selected for implementation in the current version of the Intelligent Door Emulation Application (IDEA). Since we are short of time, we shall start off with a very modest list.

Welcome Messages (different kinds)
Personal Schedule (for occupants)
Security Feature (for door exterior)
What else?? -- suggestions please
What else?? -- suggest...

Architecture:

The following architecture has been carefully designed after consultation with my graduate students, Francis Ng and Chong Ket Fah. This architecture is designed so that each of the four main components (Controller, GUI, DBMS, and Feature-Engine) can be independently developed after each team have understood the idea behind the architecture.


        IDEA           IDEA 
        Page           result
        (submit)       page
           |            ^
           |            |
          cgi          cgi
           |            |
===========|============|=======================================
           |  I D E A   |
           V            |
     +---------------------------------------------------+
     |                                                   |
     |  +-----------------+         +----------------+   |
     |  | IDEAController  |-------->| IDEAGUI        |   |
     |  |                 |         | Component      |   |
     |  +-----------------+         +----------------+   |
     +---------------------------------------------------+
         |           ^
. . . . .|. . . . . .|. . . . . . . . . . . . . . . . . . . . . . . . . . 
         V           |
     +-----------------------+          +----------------+ 
     |                       |          |                |
     |  IDEAFeatureEngine    |--------->|  IDEADBMS      |
     |  Component            |          |  Component     |
     |                       |<---------|                |
     +-----------------------+          +----------------+

================================================================

Brief Explanation:

Web pages served out by IDEA are called IDEA Page (which may be simple html or html with forms and buttons and other stuffs).
Whenever an IDEA page is activated, the request is send to IDEA system for processing (via cgi). The IDEA system should "process" the web request, computing whatever it needs (using the IDEAFeatureEngine) and returns a new IDEA Page that will display the "outcome" (or "result") of the web request.
The result IDEA Page may also contain Forms or Buttons or menu for other action.
In order to reduce the inter-dependence of the various subsystems, there are four components:
- IDEAController: This component is the most important component. It receives the web request, figures out what is needed, then call the appropriate "function" in the IDEAFeatureEngine to compute the result. It also receives the results computed, figures out the answer code and calls the appropriate "function" in the IDEAGUI component to generate correct result IDEA Page to be returned.
- IDEAGUI: This component is responsible for generating the IDEA Pages (GUI) for the IDEA system. Note that the IDEA Pages for any given web request may be different depending on the outcome of the computation from the IDEAFeatureEngine.
- IDEAFeatureEngine: This component is responsible for processing each of the web request. It may call the database stored in IDEADBMS to get the information it needs to compute the answer.
  (Note: The "functions" in IDEAFeatureEngine can be written in any language (C/C++, Java, perl, sh, csh) provided that an executable file is provided and the program reads in the appropriate input parameter list and prints out the correct output parameter list.)
- IDEADBMS: This component implements the underlying database that stores all the requisite information that is needed by the IDEA system. It also includes suitable interfaces where necessary to facilitate online/offline updating of the database.
Communication APIs: (Being cleaned up....) When calling the IDEAFeatureEngine function, it sends a code that contains information on the parameters of the web request, the function to be called, the sub-system that it belong to, and so on.
The output will also contain a list that includes the above AND the output generated.
More info to come soon....

Sample Codes:

A sample (mockup) has been written by Francis Ng. (This has been updated on 7-Apr-2003 to include Java program to interface with Oracle. Suggest you download new copy. Read the Explanatory Notes below for details.)

I have provided some explanatory notes:

Sample Code -- Explanatory Notes (Also updated a lot on 7-Apr)
- http://www-cgi.comp.nus.edu.sg:8000/~nghoongk/frontend.html
  (you need to be inside SoC's domain to be able to view)
- Get the Sample files (zipped) -- source3.zip (Updated on 7-Apr)

UIT2201: CS & IT Revolution; (Spring 2003); A/P Leong HW

UIT2201: CS & the IT Revolution Class Software Project (Spring 2003) Emulation of An Intelligent Appliance