Rich Internet Application (RIA) to visualize a rule-based Health of a Project
Rich Internet Application (RIA) to visualize a rule-based Health of a Project
Version <2.0>
Faculty Advisor
Dr. Kwok-Bun Yue
Mentor
Mr.Abbasi Dhilawala
Team Members
Karthik Nittala
Rachana Mandava
Satya Veni Achanta
Srinivas Veesam
Acknowledgement:
We take the opportunity to thank our instructor Dr. Kwok-Bun Yue and mentor Mr.
Abbasi Dhilawala for the valuable guidance and encouragement they have provided us in
bringing out this project successfully.
We would also like to thank Mr. Nicholas Davis for helping us getting started with Flex.
We would also like to thank all the people who helped us in this project and whom we might not
have mentioned here.
- ii -
Abstract
Tietronix Software, Inc. had developed a software project management tool called SDA.
The User Interface of this tool was built using Scalable Vector Graphics (SVG). This tool is
currently being used by Tietronix and a few other Government organizations. They feel that a
richer UI would look good when launching this product into the market. Tietronix wants to
upgrade the software to use a richer UI built using Flex, an environment for developing Rich
Internet Application (RIA).
The existing system displays a color representation of the status of each activity in the
process flow diagram based on simple metrics- the start date, the end date and percentage work
complete of each activity. An activity that is running late by ten days is represented by the same
color as an activity that is late by a day. This representation doesn’t give the user a numerical
representation of the status of the project. Tietronix wants to compute the health of the project
which gives a clear picture about the status of the project at various stages of its lifecycle. In
addition to the simple metrics they have been using to display the status of an activity, our
application would consider factors such as risk tolerance, software class designation, and
threshold values for alerts. This computation of the health would be carried out using a set of
rules implemented as JBoss rules.
Our project emphasizes on the display and animation of the software process flow
diagram that contains ‘flow’ activities. Each activity represents some kind of work that needs to
be performed by a person on the software lifecycle team. For each of the activities, ‘n’ number of
data points will be provided. Our aim is to run through these data points, calculate project status
using rules and then animate the process flow to update the project status as it progresses through
the data points.
- iii -
Table of Contents1. Introduction………………………………………………………………………….1
2. Requirements of the project………………………………………………………….3
3. Required Technologies…..……………………………………….………………….7
4. Design and Implementation of the Solutiion4.1 System Architecture Diagram……….…………………………..……........11 4.2 Use Case Diagram……………………………………………...….……….124.3 Implementation issues…………………………………………….….…….13
5. Evaluation of solution
5.1 Solution to the problem……………………………………………..…......145.2 Design of solution………………………..…………………………..........145.3 Functionality of the solution…………………………………………........155.4 Performance of Solution prototype…………………………………....…..15
6. Lessons learnt………………………………………………………………………167. Future enhancements……………………………………………………….………178. Tasks we have completed…………………………………………………....……..189. Conclusion……………….………………………………………………………….1810. References……………………..………………………………………………….19
Appendix - AA.1. Project Management
A.1.1 Time line of our project………………….……………………..20 A.1.2 Team information………………………………………………20 A.1.3 Task Distribution……………………………………………….21
Appendix - BB.1. Downloaded Technologies…………………………….…………………23B.2. How to deploy the software ………….…………………..……………...23B.3. How to use the software ………………………………………………...30
Appendix - C: Screen shots…………………………………………………………..34
- iv -
1. Introduction
“SDA is a software process enactment platform that guides software teams
through their project specific standards, processes and procedures. Software projects are
decomposed into all of their required process steps or tasks. Each task is assigned to
project personnel. SDA orchestrates the performance of work required to complete all
project tasks in the correct sequence. SDA notifies team members when they may begin
work on their assigned tasks and then provides all of the tools, instructions, reference
materials, and supportive artifacts which allow users to efficiently and compliantly
perform their work.” [1]
SDA has been built by Tietronix using Scalable Vector Graphics (SVG). SVG is
an XML specification for two dimensional graphics. This product is being used by
Tietronix and a few other Government organizations. With an intent to release it into the
market, Tietronix now wants to upgrade this software to use a richer user interface built
using an open source Rich Internet Application (RIA) development environment Flex.
The status of each activity in the process flow diagram is displayed as a color
representation based on simple metrics such as start and end dates , and the percentage
work complete. The lack of a numerical representation of the status of an activity fails to
give the user a clear understanding of the status of the project. Tietronix would now want
to incorporate this numerical representation, called the health of the project into the
existing application in addition to upgrading the UI. The health of the project is
calculated based on a set of rules implemented as JBoss rules. The data for the rules will
be provided by the already existing TieSPA database.
- 1 -
The major tasks of the project are:
Understanding the requirements
Building rules in JBoss
This task is the heart of the project. Computation of the health of
the project is implemented as a set of rules. For different states of an
activity, a different formula for calculation of the health was to be
implemented.
Developing User Interface in Flex
To accommodate large amounts of data in the space we have, we
have decided to use 3d objects. Each activity is represented by a cube,
containing data relevant to the activity on four sides of the cube. Data that
is displayed include start and end dates, percentage work complete, alerts,
resources assigned.
Integrating Flex and JBoss
The UI and the rules need to exchange data i.e. data from
the UI has to be sent to the server components wherein the rules
are triggered and the health is calculated. The server component
needs to send back data to the UI for display.
Report and other Documentation
- 2 -
2. Requirements of the Project
This project involves the (RIA) display and animation of a software process flow diagram
that contains ‘flow’ activities. Each flow activity represents some kind of work that needs
to be performed by a person on the software lifecycle team. For each of the activity ‘n’
number of data points will be provided. The intent of the capstone is to run through those
data points, calculate project status via rules and then animate the process flow to update
the project status as it progresses through the data points.
Every time status info is supplied the process flow diagram is modified and animated to
reflect the new overall status. Each individual flow activity will use color to represent the
schedule status – for instance red will represent a process flow that is behind schedule.
Also, each flow activity will use fill levels to represent % complete. An example would
be if a process activity at time T is 60% complete, then that process activity graphic
representation will be ‘filled in’ with color that covers 60% of the area of the graphic –
filled in from left to right. The color of the fill will be the color that reflects the schedule
status (again, a red color would reflect a ‘late’ status). For each unit of time that data is
supplied the following things will occur:
Animation of the process flow – as discussed above
Process metrics are compiled (via rules)
System alerts may be generated and logged
Tietronix will generate several data sets for this application to operate upon. The intent
of the rules is to allow a generic system so that parameters can be changed to reflect the
change in how things are done. To help with this the capstone will generate an interface
- 3 -
for the initialization of the project. The initialization will take in various parameters that
allow finer tuning of the rules.
Setup & Initialization:
1) User is prompted for and enters dataset identifier for a run
Tietronix will prefabricate several dataset inputs for this application
They should be available to select with a dropdown menu populated
w/their names
The selected data set should be used for all further calculation.
2) Initial settings are displayed and the User will be allowed to modify:
Software class designation (Valid values are A, B, C, D and E with C
as the default)
Risk tolerance (Valid values are Low, Moderate, High with Moderate
as the default)
Threshold range for status calculations
i. Very Late (default 0.2)
ii. Moderately Late (default 0.7)
iii. On time (default 1.0)
Process Flow Animation:
1) After initial settings are finalized – User pushes a start button to begin a run
2) For each time T=1 to n
a. Compute the status for each activity in the flow based on several
parameters. The computation will occur in the rules. The rules will take in
attributes like
- 4 -
i. Planned start, planned end
ii. % complete
iii. Process state (active, inactive, completed etc)
iv. The user defined parameters (risk tolerance, software class etc)
b. The rules should store the computed into a local storage (database, file etc)
c. The rules will also generate alerts based on certain conditions (see Rules
section below)
d. The application then streams the data to the Flex UI. This stream includes
data like the computed status, % complete, Resources assigned, alerts
created etc.
3) There should be some mechanism and interface to conclude a run and begin
another
4) There should be some mechanism and interface to conclude a run and end the
application
5) If alerts were issued for any process activities have some kind of alert bar
underneath each activity that is somehow lit up reflecting one or more alerts were
triggered during this ‘time’ (see next section labeled Rules)
6) Display the estimate of the total time left to complete the process flow somewhere
on the process flow (see next section labeled Rules)
Rules:
Rules for process flow display:
1) Compute schedule status
- 5 -
a. For each process activity that is active
i. Compute the activity status by a formula
ii. Compute the status based on the following:
1. < (very late) THEN color=red
2. Inbetween (very late) and (moderately late) THEN color =
yellow
3. Inbetween (moderately late) and (on time) THEN color =
green
4. > ontime THEN color = gold
iii. Create alerts for the following conditions and send to the alert log
1. Very late or moderately late condition
2. % complete backs up from the last time
3. % complete does not advance in 5 time increments
4. Person responsible for process activity changes or is
unassigned
b. End the loop
Main Displays
1) Initialization form
2) Process flow – animated during data run
- 6 -
3. Required Technologies:-
Our project is implemented as a three tier application using Flex for the
presentation layer, JBoss, Java and XML for the business logic and MS SQL Server 2000
for database. We have also used papervision3d to render 3D cubes in to flex.
Flex:
Flex is a highly productive open source framework for building and maintaining
more responsive web applications. It gives the user a rich experience in building dynamic
web pages and makes web application look like windows application. It doesn’t have
cross browser compatibility issues like AJAX, as it uses flash player to run. Flex can
handle large data sets on the client-side. Thus runtime and data manipulation time are
significantly less when compared with other RIA technologies.
JBoss Rules:
A rule based inference engine is open-source software that can apply one or more
rules to one or more facts; utilize the knowledge from an expert system to make decisions
and provide resulting consequences. It works by decomposing large sets of rules into a
very efficient network of nodes that can process and react to facts far more efficiently
than programmed manual.
The three most important aspects for specifying the system are facts, patterns, and
the rules themselves. Facts are just bits of information that can be used to make decisions.
Patterns are similar, but can contain variables that allow them to expand into other
patterns or facts. Rules are (normally) written in the "drl" language. Finally, rules have
- 7 -
predicates/premises that if met by the facts will fire the rule which allows the action to be
performed (or conclusion to be made).
This Rule Base inference engine takes input elements like software class designation,
percentage work complete, planned start, planned end, actual start, actual end and risk
tolerance against a set of business rules (written in health.drl) and triggers an action
(calculating activity status) if the rules evaluate it to be true.
Implementation details of JBoss:
1. Creation of framework to run JBoss rules:
PackageBuilder builder = new PackageBuilder
2. Load rules from a ‘drl’ file:
final Reader source = new
InputStreamReader(Health.class.getResourceAsStream("Health.drl"));
3. Add rules to a package:
RuleBase ruleBase = RuleBaseFactory.newRuleBase ()
ruleBase.addPackage (pkg)
- 8 -
4. Working Memory creation:
StatefulSession session = rulebase.newStatefulSession ()
1. Insert data into session so as to check against rules:
session.insert ()
6. Fire all rules and dispose session:
Session.fireAllRules ()
Session.dispose ()
Advantage of JBoss Rules:-
Logic and Data Separation:
Rules engines simplify applications by separating business policy or rules
logic from process, infrastructure, and presentation logic. This modularity enables
business analysts, rules developers and auditors to develop, deploy, modify and
manage a business process rules with much greater ease and speed.
Speed and Scalability:
The Rete algorithm provides very efficient ways of matching rule patterns to
the domain object data.
Centralization of Knowledge:
Rules can create a repository of knowledge (a knowledgebase) which is
executable.
Tool Integration:
- 9 -
Tools such as Eclipse provide ways to edit and manage rules and get
immediate feedback, validation and content assistance. Auditing and debugging tools
are also available
- 10 -
4. Design and Implementation of the solution:
4.1 System Architecture Diagram:
The system has been built as a three tier web application. The UI Component
is built using an open source rich internet application development framework,
FLEX. Inputs from the user interface are sent to the JSP in the middle layer via
HTTPRequest. The JSP then calls a method calculateHealth, which triggers the rules
in the Rules component.
Values required for the calculation of the activity status are picked up from the database
and the calculated activity status is stored in the database. The GenerateXML method is
then called from the JSP, which retrieves required information from the database in the
- 11 -
form of am xml string. This xml string is sent back to the user interface as
HTTPResponse.
4.2 Use Case Diagram:
The user is a member of software life cycle team. This application helps the user
to know the status of the project. A user is able to calculate the health of the project by
selecting some of the metrics such as software designation, risk tolerance.
User can also view alerts, resources, start and end dates in the process flow
diagram. Alerts for each activity are generated by rules, which in turn use threshold
- 12 -
values. Resources are the assignees of that particular activity, and dates indicate the start
and end dates of the activity. All the data required for this is retrieved from the database.
4.3 Implementation Issues:
Papervision3d is an open source real time 3d image rendering engine. We have
used this to render 3d cubes. Each cube represents an activity in the process flow
diagram. Not much documentation as to where to get the libraries is available for
papervision3d. The latest release of papervision3d dates back to November 2007. We had
to download the latest libraries using subversion, for any of the examples we found to
run. Figuring this out took a long time.
- 13 -
5. Evaluation of Solution
5.1 Solution to the problem
Our task is to animate the process flow with health of the software project. We
have used three dimensional cubes to represent each activity. We have displayed different
colors to reflect the status of each activity and the amount of percentage completed is
graphically depicted using progressive bar.
We have come up with a set of rules that calculates activity status. We have also
written rules for generating alerts based on threshold settings.
5.2 Design of the solution
We have divided our entire project into three components:
User Interface component
Built using Flex.
Rules component
This component consists of a Java class that inserts facts and then triggers
the rules. The result of the rules is put in the database.
Communication component
This component consists of a JSP which receives a HttpRequest from the
UI, triggers the rule component and then picks up required data from the
database and returns an xmlstring to the UI as HttpResponse.
This division enhances the system flexibility enabling the developer to modify either of
the components without affecting the other.
- 14 -
5.3 Functionality of the solution
The basic functionality of this project is to use a rule-based technology to
compute the activity status, generating alerts based threshold setting and animating the
process flow.
5.4 Performance of the solution prototype
We have demonstrated a reliable prototype that calculates activity status within a
minimal time frame and animates the process flow after every polling interval. Hence we
believe that our solution has met the given requirements and will be able to cope with
future enhancement.
- 15 -
6. Lessons Learnt
Importance of Research
As we are new to the technologies such as Flex and JBoss, learning them in detail
required lot of research. We understood how important it is to thoroughly research topics
and learn them on which we have no clear idea before trying to implement them.
Team Work
We also understood the importance of team work. Coordinating as a team with
different people is very challenging. Through out this project we have learnt a lot about
team coordination, planning, communicating through emails, presentation and developing
personal attitude towards teamwork.
Time Management
Another important lesson we have learnt while working on this project is the
importance of time management. Without time management it is hard to complete things
on time. Meeting the various deadlines set by the instructor was a bit tough but on the
other hand gave us a valuable experience of how to effectively manage time.
Gained Valuable Experience
We have gained valuable knowledge and experience working on this project.
We learnt new technologies like JBoss Rules, Flex and establishing communication
between the client and server. We also learned to work in a professional way which
will help us in the future.
We have not given much importance to performance of the system, but it did go
unnoticed with the project as the application was relatively light. Querying the same
- 16 -
table in the database multiple times does affect the performance of the system and has
to be avoided.
7. Future Enhancements
With the effective simulation of the process flow, the process flow diagram
need to be generated automatically
Making the user interface look richer using the rich internet application,
providing users with easy navigation and thus, enhancing the user experience.
The client requirements for the rules were rather simple and more
complicated rules need to be added as the project is being enhanced.
- 17 -
8. Tasks we have completed
1. Developing the user interface with 3d objects using paper vision 3d and flex.
2. Writing JBoss rules which are used to calculate the health of the project in a logical
way.
3. Calculating and displaying the health of the project
4 Each cube representing an activity displays information on every face of the cube
such as activity name, activity status in a progress bar, start and end dates of the
activity, resources and alerts.
5. Establishing the communication between flex and database and vice versa.
6. Generation of alerts for each activity based on the user input values.
7. Simulation of the process flow using the test data given and came up with a
working end product.
8. Report and other Documentation.
9. Conclusion
We have developed the rich internet user interface making it more effective to the
users using 3d objects. The simulation of the process flow diagram is done by calculating
the health of the project in a more logical way using JBoss rules. Our current work
enables the user to know the status of the software project based on some input values
- 18 -
such as software designation, risk tolerance and threshold. Hence, our solution using a
rule based approach and rich user interface proves to be very efficient to know the status
of the software project. In conclusion, the team has successfully completed the
requirements and ended with a successfully working prototype.
10. References:
1. http://www.tietronix.com/
2. Getting started with flex: http://flex.org/
3. Help in flex: http://livedocs.adobe.com/flex/3/html/index.html
4. JBoss Rules: http://jboss.org/
5. Wikipedia: http://en.wikipedia.org /
6. Documentation:
http://dcm.cl.uh.edu/yue/courses/csci6838/Spring2008/FinalReport.html
- 19 -
Appendix-A
A.1 Project Management
A.1.1 Time Line of our Project
Show below are the various tasks performed in respective time limits.
A.1.2 Team Information
Karthik Nittala (Team Leader) – Involved in Research, Architectural Design, coding,
DBA, testing and documentation. Coordinated the team and assigned tasks.
- 20 -
Rachana Mandava – Involved in Research, Web Master, coding, debugging and
documentation.
Satya Veni Achanta – Involved in Research, Web Master, coding, debugging, and
documentation
Srinivas Veesam – Involved in Research, Architectural Design, coding, testing, and
documentation
A.1.3 Task Distribution:
The project was divided into tasks depending upon the phase of development.
Each task has been assigned to the team members as follows:
Team Leader Karthik Nittala
Research and Design All
Webmaster Satya Veni Achanta (50%), Rachana
Mandava(50%)
Flex
3d objects Karthik Nittala(55%), Satya Veni
Achanta(45%)
Layout Srinivas Veesam(55%), Rachana
Mandava(45%)
Implementation All
JBoss Rules Satya Veni Achanta(50%), Karthik
Nittala(50%)
Communication between Flex Srinivas Veesam(50%), Rachana
- 21 -
and server components using
XML and HTTP
Mandava(50%)
Testing and Debugging All
Technical Report All
Appendix – B
- 22 -
B.1 Downloaded Technologies:
1. FLEX Builder 3 from http://www.adobe.com
2. Eclipse Classic 3.3.2 from http://www.eclipse.org/downloads/
3. Papervision3d from http://blog.papervision3d.org/
4. Drools 3.0.6 from http://www.jboss.org/downloads/
5. Apache Tomcat 5.5.26 from http://tomcat.apache.org/download-55.cgi
6. MS SQL Server 2000 from http://www.microsoft.com/downloads
B.2 How to deploy:
Download and install apache tomcat 5.5.26 on port 8080(it is the default port
number).
Unzip Team4_final_deliverables.zip.
Copy the contents of Team4_final_deliverables\Tomcat 5.5\ common\classes
to Program Files\Apache Software Foundation\Tomcat 5.5\common\classes.
Copy the contents of Team4_final_deliverables\Tomcat 5.5\ common\lib to
Program Files\Apache Software Foundation\Tomcat 5.5\common\lib.
Copy the contents of Team4_final_deliverables\Tomcat 5.5\ webapps to
Program Files\Apache Software Foundation\Tomcat 5.5\webapps.
Install MS SQL Server 2000.
Restore database set.
- 23 -
Unzip Team4_final_deliverables\testdata.zip. This zip file consists of
backups of three databases: Capstone_SDA, Capstone_Liferay, and
Capstone_workflow.
The data set is for a project named “TestProjectA”. The dataset
contains 72 data points, each 1 day apart.
To restore the backup open up SQL Server Enterprise Manager
- 24 -
Right click on databases and select “Restore Database”
On the restore dialog type in the name of the database you want to
restore (must match the names above) and select “From Device”.
- 25 -
Click Add and browse to the database files.
(Team#4_final_deliverables\testdataset\Capstone_SDA). Select the
appropriate File.
Click Ok.
On the options tab make sure the log and data file are named correctly (${DATABASE_NAME}_Data and ${DATABASE_NAME}_Log
Also make sure the physical file paths are right (If you installed SQL server with default values the data and log stays on C:, If it was changed make sure the file paths are right)
- 28 -
Click Ok
Repeat these steps for all databases.
IMP NOTE: When Installing SQL Server choose “Mixed Mode
authentication”. If SQL Server has already been installed, check which
mode it is. To do so right click on the SQL Server Name (Generally
LOCAL but may also be the machine name) and select properties. On
the properties window select the Security tab. The Authentication
- 29 -
value should be “SQL Server and Windows”. If not select it and click
ok.
Start Tomcat.
Open a web browser and enter: http://localhost:8080/health/main.html in the
address bar.
B.3 How to use the software:
1. Select project Name in the drop down menu.
2. Select Software Class Designation.
Software’s are classified into five different categories- A, B, C, D and E.
The degree of relaxation of deadlines is the criteria for classification.
3. Select Risk Tolerance.
Risk Tolerance is defined as the degree of relaxation of deadlines of
activities in the process flow diagram. Risk Tolerance can be one of "Low",
"Moderate" or "High" and is selected from a dropdown list in the UI.
For example, If an activity is planned to be completed in 10 days, A risk
tolerance of "HIGH" and a Software Class Designation "A" would suggest
that the end date of the activity can be relaxed by ((10 * 1.5 * 1.5) - 10) = 12.5
days; where 1.5 is the risk tolerance value tied up with "HIGH" and s/w
designation class value tied up with "A".
- 30 -
So, a combination of risk tolerance "HIGH" and s/w class "A" ensure
that the activity which is planned to be completed in 10 days can be relaxed
up to 22.5 days. i.e. the activity is shown to be running on time till the 22nd
day after its start.
4. Input Threshold values for alerts.
Three threshold values for "Very late", "Moderately Late" and "On
Time" are to be input to the UI. These values are used for the generation of alerts.
The default values are: 0.2- very late, 0.7- moderately late and 1.0- on time. If the
activity status of an activity is less than 0.2, an alert is generated, saying that the
activity is very late.
5. Input Polling interval.
The intent of this software is to run through the given snapshots of the
process and display the status of each activity. Polling interval specifies the time
after which the UI has to poll the server to pick up data for the next snapshot. The
default value for this is 10 seconds. Changing this value below 7 seconds is of no use
as it takes at least 7 seconds for the server to respond to the request.
6. Start animation. (Click on "Start" button in the UI)
Once all the inputs are given to the UI, the user may start the animation
by clicking on the start button.
7. Pause animation. (Click on "Pause" button in the UI)
- 31 -
Once the animation begins, data from the server is populated on four
sides of the cube. Each cube in the process flow diagram represents an activity. So,
each side of the cube consists of data relevant to that activity.
Contents of the Cube are:
1st side: Activity Name, progress.
2nd side: Dates.
3rd side: Resources.
Resources are classified into "Active", "Inactive" and "Complete".
This face displays the categories and the number of resources that fall
in each category. Clicking on any of those categories displays the
details of the resources working on that activity.
4th side: Alerts.
Alerts are categorized into "Severe", "High", "Elevated", "Guarded"
and "Low". This face displays the categories and the number of alerts
generated in each category. Clicking on any of those categories
displays the details of the generated alerts. Once the user pauses the
animation, the buttons on the cube are activated and can be used to
navigate to other sides of the cube.
8. Resume animation. (Click on "Resume" button in the UI)
- 32 -
The user can resume animation once he is done with reviewing the
contents of the cubes.
9. Stop animation. (Click on "Stop" button in the UI)
At any point of time in the animation, the user can stop the animation.
He will have to start from the beginning if at all he wants to start again.
- 33 -
Appendix – C
Screen Shots:
This is the home page of project where the process flow diagram is hard coded. Each
cube represents an activity and each activity represents some kind of work that needs
to be performed by the individual on the software life cycle team. Each cube has four
faces each one of it represents the activity name, dates, resources and alerts
respectively. The users have an option to select the input values such as project name,
software designation, and risk tolerance. The simulation can be paused to see the
status of an activity.
- 34 -
Once the user enters the input values and pushes the start button the simulation is
done taking the test data as input. Here activity 1 starts and progress bar is filled with
colors representing the status.
- 35 -
The second face of the cube displays the actual start, actual end, planned start and
planned end of each activity. The planed start and planned end are displayed initially
where actual start is displayed when the activity starts and finally actual end is
displayed once the activity is done, these two are done as a part of simulation.
- 36 -
The third face of the cube displays the name and status of the assignees assigned to
the particular activity. Below screen shot shows the status of assignee as complete as
the activity is complete. Clicking on the link it displays the name of the assignee,
assignee status and comments are in the bottom
- 37 -
The fourth face of the cube displays alerts as shown. Clicking on the text it show all
alerts for the current activity in the detail panel.
- 38 -
In the below screen shot activity one and two shows that the activities are complete
and that is done on time. Activities three and four shows that the activities are
complete and they are late based on the input values given by the user.
Here all the activities are completed and they are done on time based on the inputs
given by the user.
- 39 -