Project Requirement Specification
1. Objective
The objective of this course project is to practice what you are learning in this CSC4001 Software Engineering course by specifying, designing, implementing, testing, and documenting a Web based client-server application (e.g., web application, mobile-cloud application). The project serves as a vehicle to sharpen your knowledge in Software Engineering and to develop your relevant skills. This course project also introduces students to teamwork and project management, which are keys for successful large-scale software development. Besides, you can take the project opportunity to develop a tech-savvy, customer-driven, and eye-catching software product (such as a mobile application), as if you are founding an IT start-up company.
The project consists of four phases: (1) project design document, (2) initial code, (3) completed code and demo, and (4) commented code and final report. After the submission of completed code in (3), project team needs to make a demonstration and answers questions regarding the project during the demo on the Demo Week(s).
2. Project Grouping
https://forms.gle/wCPXVopgmvCp2gPL8
3. Project Requirements:
The goal of the project is to develop an advanced Web based client-server application with an arbitrary topic defined by your group. The whole project is composed of two parts, implementation and documentation. Here we just list the requirements, for detailed grading criteria, please refer to Section 5.
3.1. Implementation
For the implementation part, you can imagine that this project is the killer application of a start-up company created by your team. Thus, you can try to design and implement as many fancy features as you like, making use of the full power of software engineering techniques, under your topic. Meanwhile, there are some basic requirements that you must include in your project:
▪ Web-based access under client-server architecture
The application must be a Web-based client-server system, actively accessible over the Web using a Web browser (e.g., Chrome). Your application will provide useful and friendly functionality/service to the human users via Webpage interfaces. There is no particular technological requirement on Web access. However, we encourage you to employ modern Web technologies, such as HTML5, CSS3.0, JQuery, Ajax, Node.js, WebSocket, Vue, AngularJS, ReactJS, React Native, etc.
▪ Database
Either SQL database (e.g., MySQL, or SQLite) or NoSQL database (e.g., MongoDB, or Redis) must be employed by your application for storing data. If you are not using a database, please explain why in the project design document.
▪ Clear UI
Your application should at least have a clear graphical UI design. The UI should be consistent and easy to understand. Users should be able to use the application without the help of your developers.
▪ User management
Your application should also have comprehensive user management functionalities. Specifically, you should let users to sign up, login/logout, upload profile photo, and change password. Verification emails are required to activate the user account.
▪ Admin User
Your application should also have admin user account, who is responsible for the management of the whole application. The major functionality of an admin user is to manage the database of the whole application. Specifically, he/she should be able to modify all the content in the database, e.g., user profile.
3.2. Documentation
For the documentation part, you are required to use techniques (e.g., requirement analysis, DFD, UML) taught in the lectures in your project development process and provide a comprehensive documentation for your design and implementation. In this project, you will provide two documents, a high-level design document and a final report. You are recommended to employ as many software engineering techniques taught in the lectures as possible. However, the followings are the basic requirements that you must include in your documents:
▪ DFD (Data Flow Diagram)
Requirement specification is fundamental to your project. You are expected to submit your project requirement specification by English description and DFD techniques taught in the class, which explain the key components of your project. This is normally done before the project design phase, but for this project we simply require it in your Final Report, when you have completed your demo and got a comprehensive idea of your project. You are recommended to employ DFD as detailed as you like in your Final Report, with proper revision to reflect your actual software system specification.
▪ UML
UML must be employed to describe the key components of your project design. This will also be described in the class. You are required to employ UML in your Final Report, so as to reflect the final detailed design of your software system.
▪ Test Cases
You must design some test cases to test the key functionalities of your project. The design of test cases includes black box testing (required) and white box testing (optional), which will be covered in the class.
Apart from these basic requirements, you could also include Finite State Machine in your documentation to describe non-trivial software system behaviors. These are requirement specification techniques, which will be covered in the class. Trivial system behavior, such as the typical login process, will not count. You are encouraged to specify the Finite State Machine of your system in the Final Report, to describe your system behavior in detail.
3.2. Other requirements
4. Project Phases:
There are four project phases described as follows:
(1) Project Design Document
(2) Initial Code
(3) Completed Code and Demo
(4) Commented Code and Final Report
5. Grading Criteria:
0. Team Formulation — Feb. 14 (23:59:59)
1. Project Design Document 10% Mar. 4 (23:59:59)
2. Initial Code 5% Mar. 18 (23:59:59)
3. Completed Code and Demo 50% Code submission: Apr. 18 (23:59:59),
Demo Day: week 12 and week 13
4. Commented Code and Final
Total 100%
5.1. Project Description
5.2. Initial Code
The initial code will be graded on the availability of your GitHub repository. The implementation of your project is not required.
5.3. Completed Code and Demo
The Completed code and Demo will be graded upon the functionalities of your application. The grading criteria is listed as follow:
▪ Required Project Features (60%):
The required project features are functionalities that all projects should meet. There are 10 functionalities in total. You will get 6 points for each functionality you implemented. We provide a checklist for your reference.
Functionality Requirements
User Interface
Basic UI Design A graphical UI design.
Database
Database Integration Integrate a database like MySQL.
User Management
User signup Create a new user profile.
User Login & Logout Let user login and logout your application. Users should be able to conduct more operations after login.
Email Verification Send email to verify a user identity when a u=ser signup.
Profile Photo Each user should be able to upload a profile photo.
Password Modification Users should be able to modify their passwords.
Admin User
Admin user interface The admin user should have different interface from normal users.
Reset user password The admin user should be able to reset the password of any normal users.
List all users The admin user should be able to access the user profile of all normal users.
▪ Advanced Project Features (40%)
– Project specific functionalities
– Deployed on the Cloud
– Mobile Integration
– Pretty UI
– …
During the demo, we will check all the required project features listed in the checklist above. For the advanced project features, you will be graded based on your project specific functionalities and other advanced techniques you employed. You can show as many interesting features in the demo as possible and your grade will be considered accordingly.
5.4. Final Report and Commented Code
6. Submission
There are two report submissions (i.e., Project Design Document and Final Report), three code submissions (i.e., Initial Code, Completed Code, and Commented Code), and one demo package submission (i.e., demo video and slides). The submissions need to meet the following requirements:
6.1. Report submission and demo package submission
Each project group should submit the softcopy of the report to Blackboard System before the deadlines. The followings are the required names of the attached documents of different phases:
“Group** Project Description Document”
“Group** Final Report”
“Group** Demo Package”
Please replace the “**” with your group ID.
6.2. Code submission.
Appendix 2 provides a guide for code submission. Further information will be provided in the related emails or information on the website.
Appendix 1: Guidance for Documentation
The reports should be submitted by the whole team (one report per team) and the report will be graded as a whole for the team members.
Project Description Document focuses on the high-level system functionality and architectural design. In typical software engineering project, there should be a detailed design document which include detailed classes diagrams, component descriptions, pseudocodes, and programmers should be able to implement the system based on this design document. We skip this for reducing project development workload (except for DFDs to show your detailed design), and defer the detailed design to the Final Report. In the Final Report, besides the design details, the work assignment of project members, code statistics (e.g., lines of code, number of functions, etc.), project highlights, test case design and results, and lessons learned should be reported.
Each document should contain three parts: cover page, table of contents, and detailed contents.
The Cover page must contain the following information
▪ Name of Document
▪ Group ID
▪ member names and SID
The followings are the detailed outlines for the two reports:
1.1 Project Description Document (Main body no more than 10 pages)
The project description document is mainly focused on the purpose of the product you are designing, and its high-level descriptions. You should describe the objective, expected customers and market, features, and architectural design of your Web application project. Moreover, the project background, architecture diagram and brief descriptions of the system components should be provided. The recommended outline is listed as follows.
1 INTRODUCTION
1.1 Project Overview
1.2 Objective
1.3 System Features
2 BACKGROUND
Emphasize why your design the product, and its most attractive functionality/features.
3 SPECIFICATION (e.g., DFD)
4 SYSTEM ARCHITECTURE
4.1 Architecture Diagram
4.2 System Components
1.2 Final Report outline (Main body no more than 30 pages)
Your Final Report should include five sections (introduction, system architectural design, detailed description of components, user interface design, and test plans/cases). The detailed requirements of each section is listed below. A recommended report structure is attached at the end of this document. You are not restricted to the recommended report structure, but your own structure should contain AT LEAST the following listed sections and sub-sections.
Introduction
In this section, you should describe the general overview of your project. Contents that you should report in this section include background, group members and the workload of each group member, the problem to be solved, your motivation, project key features, etc.
In the highlights sub-section, you can include major attractive functionality and advanced features in your project. The expected customers and users can also be included, and you can elaborate why they will enjoy your project.
In the project statistics sub-section, you should indicate the LOC (lines of code) and McCabe’s number (to be taught in class) of your project, including the main function and other major functions. These metrics can be as extensive as possible, and down to module level. Present your project statistics clearly, such as using a tabular format.
System Specification
In this section, you should describe the system specification of your project. You have to include the DFD diagrams to introduce the operational specification of your project. Besides, you are encouraged to use FSM to explain non-trivial system operational behaviors, for the whole or some selected parts of the system.
System architectural design
In this section, you should describe the architectural design of your project. Contents that you should concern in this section include: whole system architecture overview, key components, key interface description etc. Moreover, you should indicate the connections among different key components.
Detailed description of components by UML
In this section, you should use UML to provide the detailed description of at least the key components. Contents that you should concern in this section: UML diagrams (including use-case diagram, class diagram, and sequence diagram) of the major class, functionality of the component, list of major function, etc.
User interface (UI) design
In this section, you should present the UI of your project. This section could be like a user manual of your project. You should teach and guild the users by walking through your UI operations. The use of screenshots is needed to indicate your UI overview and the result after certain user actions.
Testing
In this section, you should present the test plan, test case design, and test result of your project.
In the test overview and test plan sub-section, you should contain your test approach, features to be tested, plan for testing, testing tools if any, and the testing environment.
In the Case-N sub-section, you should concern the objective of each test case, input, expected outputs, Pass/Fail criteria, and so on.
Lessons learned
In this section, please describe what lessons you have learned from the software engineering exercise of this project, what would you do differently if you can re-do the project again, and any positive and negative experience you have with the project.
Recommended Final Report structure
Cover Page
Table of Contents 1 INTRODUCTION
1.1 Project Overview
1.2 Objective
1.3 Highlights
1.4 Project Statistics
2 SYSTEM ARCHITECTURAL DESIGN by DFD
2.1 System Architecture
2.2 DFDs
3 DETAILED DESCRIPTION OF COMPONENTS by UML
3.n Component-n
3.1.1 Structural Diagram
3.1.2 UMLs
3.1.3 Functionality
3.1.4 Procedures and Functions
4 USER INTERFACE DESIGN
4.1 Description of the User Interface
4.2 Screen Images
4.3 Objects and Actions
5 TEST
5.1 Test Overview and Test Plan
5.n Case-n
5.1.1 Purpose
5.1.2 Inputs
5.1.3 Expected Outputs & Pass/Fail Criteria
6 LESSONS LEARNED
7 CONCLUSION
Appendix 2: Guidance for Code Submission
You MUST submit your project via GitHub.com, and faithfully record your coding activities.
1. Create a GitHub account (if you don’t have one)
GitHub is the leading code management platform worldwide. If you do not have an account, you can navigate to https://github.com and Sign up.
2. Create a new repository
To facilitate submission, you are required to set up a git repository on GitHub.com.
Click the “+” on the upper right corner of GitHub, and click “New repository”
Then enter the name of your repository and choose the visibility. You can set up either public or private repository. For public repository, you need to submit HTTPS URL of your repository (e.g., https://forms.gle/rPxUpm4CAb42JGWu5). For private repository, you need to follow the guide below to add ssh key and submit SSH URL of your repository (e.g., [email protected]:yttty/my-awsome-project.git).
3. Add deploy key to the private repository
If you choose to create a private repository, you need to add deploy key to your project so that TAs can access your code. Please be reminded the member capacity of a private repository of a free account is limited to 3. You should apply for Student Account to increase the member capacity to enable everyone to contribute code.
First, download the key from the project page of BB:Content; extract the zip file; open the public key of your group with a text editor and copy the corresponding public key of your group. Please ensure you add the right public key, otherwise TAs cannot access your private repository.
Then, go to your GitHub repository, navigate to settings->Deploy keys->Add deploy key
Paste the public key you just copied, then click Add key.
4. Read More
– If you are new to git, start with this simple guide.
– The official git documentation: https://git-scm.com/documentation.
– Git and GitHub Tutorial https://www.youtube.com/watch?v=xuB1Id2Wxak
