MSE Project Plan
CIS985
KansasStateUniversity, spring 2005
UML Sequence Diagram Generator
1st Version
AuthorMajor Advisor
Samer AlisalehBill Hankley
Overview
This document will describe the different phases, iterations and milestone for the software. It will also includes plans and estimated dates, sign-offs and evaluation criteria.
A Gantt chart will be provided to summarize the different phases and the plans.
Part of this document will be dedicated for the cost estimate on size, time and effort required for the project. Another part will be dedicated for architecture elaboration plan that will define the activities and the actions the must accomplished to prior to the architecture presentation. The plan must include the set of requirement the need to be formalized and the artifacts that will undergo formal technical inspection.
Deliverable / Tasks / Completion Criteria / Time2005 / Cost
MSE Project Webpage / Creating time log for the Project over the web / Time Log is available in the web / Jan 14 / 1
Project Vision Document 1st Draft. / Writing a project vision document / Advisor Approval / Jan 16 – Jan 18 / 2
SRS 1stDraft / Writing the project requirement / Advisor Approval / Jan 19 – Jan 27 / 9
WBS Draft / Cost Estimates & Arch. Elaboration. / Advisor Approval / Jan 28 – Feb11 / 11
GUI Prototype / Constructing The first prototype / Advisor Approval / Feb 18 – Feb 25 / 7
First Presentation April15
Project Vision Document 2nd Draft / Updating the project vision / Advisor Approval / May 1 – May 2 / 1
SRS 2nd Draft / Cost Estimate and Project Planning / Advisor Approval / May2 – May6 / 4
Formal Specification. / Writing formal specification / Advisor Approval / May 7 – May10 / 4
Architecture Design / Class Diagram Design / Advisor Approval / May 11 – May 12 / 1
Sequence Diagram / Advisor Approval / May 13 – May 14 / 2
State Diagram / Advisor Approval / May 15 – May 16 / 1
Test Plan / Define the critical use cases / Advisor Approval / May 18 – May 18 / 1
Define Test Data / May 19 – May 19 / 1
Define test type & test cases / May 20 – May 21 / 1
Formal Technical Inception / Approved Letter by 2 MSE students. / Review report from the inspectors. / May 23 – May24 / 2
2nd Prototype / Develop Class Diagram Editor / Executable Editor / May 11 – May 23 / -
Develop Sequence Diagram Generator / Executable Code / May 24 – June 6 / 14
Develop the Analyzer / Executable Code / June 7 – June 12 / 6
2ed Presentation June 20
Action Items / Implement action Items / Action Items from 2nd presentations are addressed / June 22 – June 25 / 4
User Manual / Document how to install and run / Advisor Approval / June 28 – June 27 / 2
Document How to use / Advisor Approval / June 28 – June 29 / 2
Component Design Document / Finalize all the design model documentation. / Advisor Approval / June 30 – July 2 / 3
Source Code / Submit final source code / Advisor Approval / July 4 – July 4 / 1
Assessment Evaluation / Run Test Cases / Test cases passed / July5 – July6 / 2
Document Testing Result / Advisor Approval / July 5 – July 6 / -
Project Evaluation / Document Project Usefulness / July 7 – July 7 / 1
Document & Analyze Cost Estimates / July 8 – July11 / 4
References / Document All References used for the project / - / July 12 – July 12 / 1
Formal Technical Inspection letter / Submit review letters from the inspectors / July 13 – July 13 / 1
Final Presentation July21st
Total / 98
Cost Estimation:
In this project, Functional Point Analysis and COnstructive COst MOdel ( COCOMO ) are used for estimating the size and cost of developing the application.
A function point is a rough estimate of a unit of delivered functionality of a software project. To calculate the number of function points for a software project one counts all the user inputs, outputs, inquiries, number of files and number of external interfaces, then split them up in according to the degree of their complexity like simple, average and complex.
User Inquiries
These are request response pairs that do not change the internal data. Example, a request for the address of a specified employee is an inquiry. The whole sequence of asking, supplying the name and getting the address would count as one inquiry. Also an inquiry is defined as an online input that results in the generation of some immediate software response in the form of an on-line output. Each distinct inquiry is counted.
I summarized the user inquiries in the following items:
-Class inquiry for methods (Simple).
-Class inquiry for attributes (Simple).
-Method inquiry for parameters (Simple).
-Association inquiry for association type (Simple).
-Association inquiry for head multiplicity (Simple).
-Association inquiry for tail multiplicity (Simple).
-Sequence Diagram Message Validation (Complex).
-Sequence Diagram message sender object (Simple).
User Inputs
Theyare each unique user data or control input that enters the application boundary and also updates (adds to changes, or deleted from) a logical internal file, data set, table or independent data item. Each input is uniquely formatted or processed portion.
I summarized the user inputs in the following items:
-Class Position in the class diagram plane (Average).
-Class Name (Simple).
-Association head (Average).
-Association tail (Average).
User Outputs
Each user output that provides application-oriented information to the user is counted. In this context output refers to reports, analysis screens, error messages, and so on. Individual data items within a report are not counted separately.
I summarized the user inputs in the following items:
-Selected Object node (Average).
-Selected Message Arrow (Simple).
-Message Validation result (Complex).
-Pseudo code for the sequence diagram (Average).
External Interfaces
The data that is shared with other programs like personal file might be used by HR for promotion & pay roll. Thus, it would be considered an interface in both the systems. All machine-readable interfaces (e.g. data files on tape or disk) that are used to transmit information to another system are counted. There are no external interfaces for this system.
The only external interface the program has to interact with is the java graphical library (Complex).
Files
Each major logical group of user data or control information related to application. They may be one part of a large database or a separate file. If an actual file contained 100 entries of personal data it would probably be counted as one file. However, if the file containedpersonal data, department summary data and other department data, it would probably be counted as 3 separate files for counting function points. For this application.
I summarized the program files in the following items:
-Class Diagram Structure file (Average).
-Sequence Diagram Structure file (Complex).
-XML Class diagram file (Average).
Function Point Unadjusted Value:
To calculate the FPunadjusted value, the total weights for each function point should be calculated according to the following table:
Note: The scale for each item is taken from the book of Software Engineering by Roger Pressman - Fig 4.5 pg 90, fifth edition.
Item / Simple / Average / Complex / TotalInputs / 3*(1) / 4*(3) / 6*(0) / 15
Outputs / 4*(1) / 5 *(2) / 7*(1) / 21
Inquiries / 3*(7) / 4*(3) / 6* (1) / 39
Files / 7*(0) / 10 *(2) / 15*(1) / 35
Interfaces / 5*(0) / 7*(0) / 10(1) / 10
Total / 120
From the table above, we conclude the value of FP unadjusted is (UFP)= 120.
To calculate the value of function point adjusted, the value of the product complexity should be obtained from the following table, that estimates the use of the following software features in the intended application by a scale from 0 (not important) to 5 ( heavily used). The summation of all values will be the complexity factor.
Note: this table is considered after looking into several MSE project from former MSE students.
Features / Complexity Weight1 / Is the code designed to be reusable? / 5
2 / Are conversion and installation included in the design? / 3
3 / Is the system designed for multiple installations in different organizations? / 3
4 / Is the application designed to facilitate change for ease of use by the user? / 5
5 / Does the system require online data entry? / 0
6 / Does the online data entry require the input transactions to be built over multiple screens or operations? / 0
7 / Are the master files updated on-line? / 0
8 / Are the inputs, outputs, files, or inquiries complex? / 4
9 / Is the internal processing complex? / 5
10 / Does the system require reliable backup and recovery? / 1
11 / Are data communications required? / 0
12 / Is performance critical? / 4
13 / Will the system run in an existing, heavily utilized operational environment? / 2
Total / 32
Product Complexity Adjustment (PC) =
∑FP unadjusted *[.65 + (0.01 * Product Complexity Factor)] = 0.97
Total Adjustment Function Points (FP) = UFP * PC = 0.97 * 120 = 116.4
To estimate the total number of lines of source code, the following formula is used:
Source Lines of Code (SLOC) = FP * Language Factor. Since Java is going to be the development language for this application, then the language factor is estimated to be = 38. Therefore:
SLOC = 116.4 * 38 = 4423
Based in Pressman book – mentioned earlier – the programmer productivity for an application program is given as follows:
Programmer Productivity (PM) = 2.4 * (KDSI) ^ 1.05, where the KDSI is determined from the value of SLOC as 4.423. Therefore:
Person Productivity (PM) = 2.4 * 4.423^1.05 = 11.4 person-month.
Also from the same source the development time can be estimated for an application program, as follows:
Development Time (TDEV)= 2.5 *(PM)^0.38 = 2.5 * 11.4 ^ 0.38 = 6.3 months
Note: The results of this cost estimation is not 100% realistic and accurate and that is due to the reason that this project is not an industrial project that is done under business environment in which the numbers provided for the cost estimation model is based on. For this project there are other considerations and limitationsthat come along its academical nature, such as the fact that only one student is developing the project where he or she can be occupied with other courses, projects and assignments. That is why in my cost estimation I increased the complexity of some function points that led to 6.3 months and 11.4 person-months. I believe that if this project is done under business environment the total time and effort can be cut in half.
Gantt chart:
Documentation
Coding.
Design.
Testing.
Presentation