SOFTWARE PROJECT PLANNING WITH EBS AND ACO

Project Report Submitted

In Partial Fulfillment of the Requirements
For the Degree Of

BACHELOR OF ENGINEERING
IN
COMPUTER SCIENCE ENGINEERING
Submitted By

ZAINAB FATIMA SYED

MOHAMMAD ASIF KHAN
B.SHAIK MD SAMEER

(1604-12-733-073)
(1604-12-733-098)
(1604-12-733-308)

Under the Guidance of

MD SHAHABAZ HUSSAIN
Assistant Professor, CSED

DEPARTMENT OF COMPUTER SCIENCE

MUFFAKHAM JAH COLLEGE OF ENGINEERING &

TECHNOLOGY
(Affiliated to Osmania University)
Mount Pleasant, 8-2-249, Road No. 3, Banjara Hills,Hyderabad-34
2015-16

DECLARATION
We hereby declare that the work presented in this report has been carried out by us under the
supervision of our guide MR. SHAHABAZ HUSSAIN, Assistant Professor Department of
Computer Science Engineering, Muffakam Jah College of Engineering and Technology,
Hyderabad.
We declare to the best of our knowledge that this project report titled SOFTWARE
PROJECT PLANNING WITH EBS AND ACO is an authentic record of our work
during the academic year 2015-2016.

ZAINAB FATIMA SYED

(1604-12-733-073)

ASIF KHAN MOHAMMAD

(1604-12-733-098)

B.SHAIK MD SAMEER

(1604-12-733-308)

iii

ACKNOWLEDGEMENT
It is with great pleasure and sense of satisfaction that we present our project titled
SOFTWARE PROJECT PLANNING WITH EBS AND ACO , we would like to
hereby acknowledge and thank all those who helped us.
First and foremost, we would like to thank god for bestowing his bountiful blessings upon us
and giving us tremendous patience and dedication. Secondly, we would like thank our parents
for always supporting us physically, mentally and financially throughout our academic
endeavour.
We show gratitude to Dr. K. N. Krishnan, Principal MJCET for having provided all facilities
and support.
We take immense pleasure in thanking Dr.A.A. MOIZ QYSER, Associate professor and
Head, C.S.E.D for having permitted us to carry out this project work.
We would like to express our sincere gratitude to Mr. MD.SHAHABAZ HUSSAIN
Assistant Professor C.S.E.D, Muffakam Jah college of Engineering and Technology, our
project guide for showing keen interest and giving valuable guidance during the entire
selection process of the project and for his moral support.
We express our deep sense of gratitude and thanks to all teaching and non-teaching staff of our
college who stood with us during the project and helped us to make it a successful venture.

Finally, we express our hearty gratitude and thanks to all our friends and benefactors who
have contributed their ideas, time and energy that have significantly contributed in the
finalization of our project.

ZAINAB FATIMA SYED

MOHAMMAD ASIF KHAN
B SHAIK MD SAMEER

iv

CONTENTS

TITLE

PAGE NO

Title page

Certificate

Ii

Declaration

Iii

Acknowledgement

Iv

Contents

List of Figures

Vii

List of Abbreviations

Viii

Abstract

Ix

1. INTRODUCTION.1-5
1.1 Organization of Work..................................................................1
2. Literature Survey........6-18
2.1 The resource constrained project scheduling problem model...6
2.2 Employee Allocation Models6
2.3 Multi-level Scheduling Models.8
2.4 Time-Based Model8
2.5 Description of Employees...10
2.6 Description of Tasks10
2.7 Planning Objective..12
2.8 Representation and the Event-based Scheduler...13
2.9 ANT COLONY optimization approach..18
3. SYSTEM ANALYSIS.....19-31
3.1 Existing System...19
3.2 Proposed System..20
3.3 Technical Requirements...21
3.4 Tools21

4. REQIUREMENT ANALYSIS32-37
4.1 Requirement Analysis and Specification32
4.2 Analysis and designing of the system architecture.32

4.3 Implementation.....33
4.4 System Integration..34
4.5 Functional and Non-Functional Requirements34

5. SOFTWARE REQUIREMENT SPECIFICATION.38-40

5.1 Scope of the developed project38
5.2 Overview of document38
5.3 Overall description product perspective..39

5.4 Product Functions.....39

5.5 Module Description..39
5.6 Operating Environment...40
5.7 User view of Product Use40
5.8 Software Quality Attribute Business Rules.40

6. SYSTEM DESIGN....41-48
6.1 System Architecture41
6.2 Process Model.41
6.3 UML Diagrams...43
7. IMPLEMENTATION....50

7.1 Pseudo code..50

8. SCREEN SHOTS73

9. CONCLUSION..98
10. FUTURE ENHANCEMENTS.....99

11. REFERNCES...100

vi

LIST OF FIGURES
Fig No:
2.6
2.9
3.4.1
3.4.2
3.4.6
6.3.1
6.3.2
6.3.3
6.3.4
6.3.5
6.3.6
6.3.7
8.1
8.2
8.3
8.4
8.5
8.6
8.7
8.8
8.9
8.10
8.11
8.12
8.13
8.14
8.15

Figure Name
Cycle of Task Description
ACO Algorithm
Working of java
The java platform
Knowledge discovery process
Use case diagram
Class diagram
Sequence diagram
Collaboration diagram
Activity diagram
Component diagram
Deployment diagram
Client details for a task
Requirement page
Detail entering page
Admin Login page
Available Tasks
Current Working Projects
Current Working Employees
Current Working Project
Current module assigned on the project
Recruitment of a new employee
Recruitment selection process
Employee login area
Current Working Progress on projects
The task action of the project
The current status of the project

vii

Page No
10
18
24
25
28
43
44
45
46
47
48
49
76
78
79
81
82
83
84
85
86
90
91
93
97
98
100

LIST OF ABBREVATIONS
S. No
1
2
3
4
5

Short form
ACO
EBS
PERT
CPM
RCPSP

Full Form
Ant Colony Optimization
Event-based Scheduler
Program evaluation and review technique
Critical Path Method
Resource-constrained project scheduling problem

viii

ABSTRACT
Research into developing effective computer aided techniques for planning software
projects is important and challenging for software engineering. Different from projects in
other fields, software projects are people-intensive activities and their related resources are
mainly human resources. Thus, an adequate model for software project planning has to deal
with not only the problem of project task scheduling but also the problem of human resource
allocation. But as both of these two problems are difficult, existing models either suffer from
a very large search space or have to restrict the flexibility of human resource allocation to
simplify the model. To develop a flexible and effective model for software project planning,
this paper develops a novel approach with an event-based scheduler (EBS) and an Ant
Colony Optimization (ACO) algorithm. The proposed approach represents a plan by a task
list and a planned employee allocation matrix. In this way, both the issues of task scheduling
and employee allocation can be taken into account. In the EBS, the beginning time of the
project, the time when resources are released from finished tasks, and the time when
employees join or leave the project are regarded as events. The basic idea of the EBS is to
adjust the allocation of employees at events and keep the allocation unchanged at non-events.
With this strategy, the proposed method enables the modelling of resource conflict and task
pre-emption and preserves the flexibility in human resource allocation. To solve the planning
problem, an ACO algorithm is further designed.

ix

1. INTRODUCTION

1.1 Organization of Work

With the rapid development of the software industry, software companies are now facing a

highly competitive market. To succeed, companies have to make efficient project plans to
reduce the cost of software construction [1]. However, in medium to large-scale projects, the
problem of project planning is very complex and challenging [2]. In fact, in China it was
reported that more than 40 percent of unsuccessful software projects failed because of
inefficient planning of project tasks and human resources[3].Due to the importance and
difficulty of software project planning, there is a growing need for developing effective
computer aided tools for software project planning in recent years [4], [5], [6]. To plan a
software project, the project manager needs to estimate the project workload and cost and
decide the project schedule and resource allocation. For workload and cost estimation, some
famous models like COCOMO [7], [8] have been developed and widely used. For scheduling
and staffing management, similarly to other projects (e.g., construction projects),
management is usually conducted by project management tools and techniques. For example,
traditional project management techniques like the program evaluation and review technique
(PERT), the critical path method (CPM) [9], and the resource-constrained project scheduling
problem (RCPSP) model [10] have been applied in software project planning.
Although these methods are important and helpful, they are increasingly considered to be
inadequate for modeling the unique characteristics of todays software projects. The main reason
is that, differently from other projects, a software project is a people-intensive activity and its
related resources are mainly human resources [4]. Different software project tasks require
employees with different skills, and skill proficiency of employees significantly influences the
efficiency of project execution. As such, assigning employees to the best-fitted tasks is
challenging for software project managers, and human resource allocation has become
1

a crucial part in software project planning. Techniques like PERT and CPM lack the
consideration of resource allocation and scheduling models like the RCPSP do not consider
the allocation of employees with various skills. Therefore, the tools based on these traditional
project management techniques usually regard task scheduling and human resource allocation
as two separated activities and leave the job of human resource allocation to be done by
project managers manually, resulting in inefficient resource allocation and poor management
performance. Moreover, as the main resources in software development are humans instead
of big machines, resources in software projects can usually be allocated in a more flexible
way than those in construction or manufacturing projects.
In contemporary software projects, it is common that a programmer joins multiple
module development tasks simultaneously, and it is also possible that he stops his current
work and joins the other more critical tasks [3]. If task preemption is properly designed,
human resources can be organized in a more efficient way. Some research has pointed out
that task preemption can have a significant impact on reducing the time and cost of a software
project. However, currently, task preemption is still sparsely considered in software project
management models and tools [7]. Most existing models have the assumption that each
employee can only be assigned to a single task at one time. This assumption reduces the
flexibility of resource allocation in software project planning. To build more suitable models
and tools, traditional project management techniques need to be further extended. One
noteworthy approach is to model software project planning as a search-based optimization
problem. During the last decade, the idea of formulating software engineering as searchbased problems has attracted increasing attention.

Various software engineering activities such as cost estimation, module clustering, design,
testing, and software release planning have been modeled as search-based problems and meta
heuristic algorithms have been applied successfully. Search-based approaches may also become a
promising way for software project planning. In the literature, several works have been done on
developing search-based approaches for software project planning. Duggan et al. [2] and Barreto
et al. [4] built models for the staffing problem of software projects and proposed genetic
algorithm (GA) approaches. But, their models only focused on staffing and the problem of task
scheduling was not considered. Chang et al. proposed the software project management net (SPM
net) model and the project management net (PM-net) model successively, and then further
improved the models to a richer version with a GA. Other GA-based approaches were also
proposed in and, In these approaches, a plan is described by a 2D matrix which specifies the
workload of each employee on each task. But, as this representation is inadequate for modeling
resource conflict, these models all implicitly uses the Mongolian Horde strategy
[6] that assumes an unlimited number of employees can be assigned to a task and an employee
can join an unlimited number of tasks simultaneously, which is usually not the case in practice.
Bellenguez and Ne ron proposed a multi-skill scheduling model by extending the traditional
RCPSP model. The model considers both the problems of human resource allocation and task
scheduling, and takes the skill proficiency of employees and resource conflict into account. Tabu
search (TS) [9], branch and bound, GA have been developed for the model. In all of the abovementioned models, there is an assumption that preemption is not allowed. As discussed before,
this assumption reduces the flexibility of human resource allocation for software projects. Task
preemption in software projects is only considered in a few studies. In Changs recent work [6],
he improved his previous scheduling model by introducing a 3D matrix representation, specifying
the workload assignment of each employee for each task on each

time period. Although this representation is much more flexible, it makes the search space
very large and suffers from the problem of desultory assignment of workloads.
Overall, developing effective approaches for software project scheduling and employee
allocation remains a challenging problem and deserves further research. In the proposed project,
we develop a practical and effective approach for the task scheduling and human resource
allocation problem in software project planning with an ant colony optimization (ACO)
algorithm. Different from the existing approaches, the proposed method is characterized by the
following two features. First, a representation scheme with a novel event-based scheduler (EBS)
is developed. The representation scheme is composed of a task list and a planned employee
allocation matrix. The task list defines the priorities of tasks to consume resources, and the
planned employee allocation matrix specifies the originally planned workload assignments. In this
way, the representation takes both the issues of task scheduling and resource allocation into
account. The EBS regards the beginning time of the project, the time when resources are released
from any finished task, and the time when employees join or leave the project as events. To
generate an actual timetable, the EBS adjusts the workload assignments of employees at events
and resource conflict is solved according to the priority defined by the task list. In this way, the
proposed scheme is practical and flexible as it enables the modeling of task preemption and
resource conflict. At the same time, compared with the 3D matrix representation [6], the proposed
scheme reduces the size of the search space and thus accelerates the search process. In addition,
as the EBS only makes new assignments at events, it is able to keep the implementation of tasks
in a more stable manner. Second, different from the GA and TS approaches developed in the
existing studies, we proposed an ACO approach. ACO was proposed by Dorigo, Dorigo and
Gambardella [4] in the early 1990s and by now has been successfully applied to various
combinatorial optimization problems.

As ACO builds solutions in a step-by-step manner and enables the use of problem-based
heuristics to guide the search direction of ants, it is possible to design useful heuristics to
direct the ants to schedule the critical tasks as early as possible and to assign the project tasks
to suitable employees with required skills. Therefore, ACO promises to converge fast and
perform well on the considered problem. It is believed that experimental results show that the
proposed approach is promising.

LITERATURE SURVEY
The proposed project intends to propose a representation scheme with a novel event-based
scheduler and an ant colony optimization approach for the aforementioned problem. In order
to better illustrate why the representation scheme and the EBS are designed, briefly review
the existing (software) project planning models in this section.
2.1 The Resource Constrained Project Scheduling Problem Model
The RCPSP is a classic model in project management which is NP-hard [10], [40]. It
involves scheduling the tasks of a project subject to precedence and resource constraints. To
build a schedule, one needs to determine an order of tasks which forms a task list
{tp1, tp2,., tpn};
Where {p1, p2,....,pn} is a permutation of (1;2;...;n). The task list defines the tasks priorities
to consume resources when resource conflict occurs [10].
Although the RCPSP is important and widely used, it only focuses on the issue of project
scheduling and does not take the issue of employee allocation into account. Therefore, the
RCPSP is still inadequate for modeling the software project planning problem.
2.2 Employee Allocation Models
Employee allocation problems have attracted a considerable amount of research effort in
recent years and various models like nurse rostering and personnel planning have been
proposed. There are also some studies that focus on the employee allocation problem in
software projects. In these models, the problem of how to assign employees to different
workstations (or tasks/time periods) is addressed. The optimization objective is to minimize
the number of constraint violations or to minimize project duration and cost. Though the
objectives of these models are quite different, they usually describe a plan for the problem by
6

an employee allocation matrix. For example, in [5], the employee allocation matrix is
described by

Where Whij means the working hours of the i th employee for tj. These employee allocation
models are helpful for managing human resources. However, they lack the consideration of
task scheduling. To plan a software project, the project manager has to decide not only the
allocation of human resources but also the start and finish time of each task. As the working
duration of a task is dependent on the employees assigned to the task, separating task
scheduling and employee allocation as two independent activities is considered to be
unsuitable [6]. In addition, an employee allocation matrix like (10) has no information about
how to deal with resource conflict. As a result, the employee allocation models for software
project planning have to implicitly assume that a task can be conducted by an unlimited
number of employees and an employee can be assigned to an unlimited number of tasks at
one time, which is usually not the case in practice [6].
2.3 Multi skill Scheduling Models
Considering the fact that software development involves a group of employees with different
skills, Bellenguez and Neron extended the traditional RCPSP model to propose a multi-skill
project scheduling model for software project planning. The model follows the framework of
the RCPSP for task scheduling and regards different combinations of employees as different
alternative modes for the implementation of a task. Tabu search and branch and bound
algorithms were also developed for the problem. In a recent work, Yannibelli and Amandi
further developed a representation scheme for the problem by combining the task list
7

representation (9) and the employee allocation matrix (10). Compared with the models
aforementioned, as the multi-skill scheduling model is derived from the original RCPSP and
couples the modeling of employees with various skills, it provides a more practical way for
software project planning as it can deal with both the problems of task scheduling and
employee allocation. But, since the model assumes that an employee can only be assigned to
a task at one time and no task preemption is allowed, the flexibility of human resource
allocation is reduced. Under such restriction, if any one of the employees assigned to a task is
busy with other activities, the whole team has to wait until that employee is released. This
situation may reduce the resource efficiency of the project.
2.4 The Time-Line-Based Model
To model the task scheduling and human resource allocation problem in a more flexible way,
Chang et al. [6] considered task scheduling and employee allocation together and developed a
time-line-based model. Different from the previous approaches, the time-line-based model
introduces the time-line axis to solution representation and thus a feasible plan is described as
a 3D employee allocation matrix:

th

Where wh ij is the working hours of the i employee for tj at time t. The 3D representation is
able to overcome the disadvantages of the RCPSP and the employee allocation models. But it
also brings in two new problems. First, as workloads are assigned period-by-period instead of
8

task-by-task, the plans produced by this model may assign two completely different groups of
employees to the same task in different periods. As a result, the task may be implemented in a
desultory manner, which is inefficient. Second, as the representation size of a schedule is enlarged
from a 2D matrix to a 3D one, the search space of the problem significantly increases.

2.5 Description of Employees

Software development is a people-intensive activity. To manage employees, an employee
database is needed to record the employees information of wages, skills, and working
constraints. The problem of employee allocation is to assign employees to suitable tasks so
that the tasks can be done efficiently. Suppose m employees are involved in the project, for
the ith employee (i=1, 2,..., m) the following attributes are considered.

Bsi The basic salary for the employee per time period (e.g., month).
Hsi The salary for the employees per-hour normal work.
ohsi The salary for the employees per-hour overtime work.
nh Legal normal working hours per month.
maxhi Maximum possible working hours per month of the employee for the project.
[joini, leavei ]The time window when the employee is available for the project. .
1

{s i, s I,...,s

}The skill list for the employee, where is the number of skills and

s i [0,5] is the proficiency score of the jth skill. Here the skills can be documenting,
j

C++ programming, GUI design, and any other technical abilities. s i= 0 means the
j

employee does not have the skill and s i= 5 means the employee is masterly on that
skill.
Basic salaries are paid to regular employees every month regardless of the workloads the
employees devote to the project. On the other hand, per-hour normal work salaries are paid
according to the working hours. Usually, there are two types of employees: regular ones and
9

temporary ones. Regular employees have stable basic salaries, while temporary ones do not
have basic salaries but have much higher per-hour working salaries.
Let us suppose that the ith employee devotes hours
t

hours to the project at the tth month

(hours i <= maxhi). If hours i is larger than the legal normal working hours nh, it implies that
the employee works overtime for the project. The salary salary

for the ith employee at the

tth month is calculated by

+
={

+ . + (

) , <

>

2.6 Description of Tasks

In a software project, tasks can be any activity involved in software construction, for
example, class design, programming, and testing. A commonly used technique for task
description is the task precedence graph (TPG) [6], [5]. A TPG is an acyclic directed graph
G(T,A). The set of nodes T(t1,t2,..., tn) corresponds to the set of tasks, where n is the Number
of tasks in the project. .

Fig No: 2.6 cycle of task description

10

The set of arcs A represents the precedence relations among tasks. An arc (i, j) A means t i is
a direct predecessor task of tj. An example of a TPG is shown in Fig. 1. Under the precedence
constraint defined by the TPG, a task can only start when all of its direct predecessor tasks
have finished. The problem of task scheduling is to construct an efficient timetable for the
implementation of tasks subject to the precedence constraints. For a task t j (j= 1, 2,...,n), the
following attributes are considered
pmj The estimated work effort of the task in person months. Several famous methods, for
example, the COCOMO models [7], [8], can be adopted for work effort estimation.
SKj The set of skills required by the task. . max headj The maximum headcount for the
task. In application, as too many employees working on the same task will incur higher
communication overhead and result in low efficiency, it is necessary to limit the number of
employees for a task. According to [6], the maximum headcount can also be estimated based
on the COCOMO model.
deadlinej and penaltyj The deadline and penalty of the task. In practice, it is common to
define deadlines for milestone tasks. If the task is delayed, a penalty will be incurred. Based
on the above definitions, suppose
t

wh ij is the number of working hours of the ith employee for tj at the tth month; according to
[6], [8], the achievement At j yielded by the employees for tj at time t can be evaluated by the
following steps:
1. The proficiency profij of the ith employee tj.
2. The total fitness fjk of the employees for tj on tth month.
k

jk

3. Convert f j to a cost driver V=8-round (f .7+0.5), Where the value of V belongs to 17.V=1 means the employees are the most suitable for task and viceversa.
11

4. The achievement Aj for tj on the tth month.

2.7 Planning Objective

As the software project planning problem involves task scheduling and employee allocation,
a plan for a project must specify when the tasks of the project are processed and how the
workloads of employees are assigned to the tasks. More specifically, the plan has to
determine the start time startj and the finish time finishj of each task (j {1,2,.. n}), and the
t

working hours wh ij of all employees i{1,2.m} to the task tj during the time window
t [startj,finish].The plan must satisfy the following constraints:
1. The processing order of tasks must obey the precedence constraint defined by the TPG.
2. The working hours of the ith employee per month must not exceed the limit maxhi .
3. The number of employees assigned to a task tj is limited by the maximum headcount.
4. All tasks have to be complete. In other words, for a task tj, the sum of the
achievements for tj during the time window [startj;finishj] must be satisfied.
The proposed project considers cost minimization as the objective function.
Where the first item is the salary expenditure and the second item is the total penalty search
space of the problem significantly increases.
12

2.8 REPRESENTATION AND THE EVENT-BASED SCHEDULER

To overcome the deficiencies of the above-mentioned models, the proposed project proposes
a representation scheme with a novel event-based scheduler. Similarly to the representation in
Yannibelli and Amandis recent work [18] for the multi-skill scheduling problem, we
combine the task list representation (9) and the employee allocation matrix representation
(10) so that both the problems of task scheduling and human resource allocation are
addressed. The representation scheme is given by

Similarly to (9), the task list in (12) also specifies the priorities of tasks in the schedule.
However, differently from Yannibelli and Amandis scheme [18] that directly uses the
employee allocation matrix (10), the proposed representation scheme in (12) uses the planned
employee allocation matrix. More specifically, the whij in (10) is the actual working hours of
the ith employee for tj. But the pwhij in (12) is only the originally planned working hours of
the ith employee for tj. Because the multiskill scheduling model has various restrictions and
reduces the flexibility of human resource allocation, to relax such restrictions and enable task
preemption we no longer fix the working hours of the ith employee for t j during the
t

processing course of tj as pwhij. Instead, the actual working hours wh ij during the time
t [startj,finishj] should be adjusted according to the urgency of tasks and the amount of
available resources. To adjust the planned working hours pwh ij to the actual working hours
whtij, we propose the EBS in the proposed project.

13

The EBS is characterized by making new assignments at events. We regard the time t as an event
if t satisfies any one of the following three conditions: 1) t = 1 is the beginning of the project, 2)
any employee joins or leaves the project at t, or 3) any task just finished in the previous time
period and the corresponding resources become released and available at t. The EBS adjusts a
plan in the form of (12) into an actual timetable by two rules. First, if there is resource conflict
between two tasks, the task that appears earlier in the task list has a higher priority to use the
resource. That is, assuming that the ith employee is originally planned to simultaneously dedicate
pwhij and pwhik of his working hours to tj and tk, respectively, if pwhij
+pwhik > maxhi, the employee will first dedicate his working hours to the task with a higher
priority. Second, new workload assignments are only made when events occur. If no employees
join or leave the project or no human resource is released by the tasks just finished, the workload
assignments remain the same as the previous time period. The pseudocode of the EBS is given in
the beginning, the start time of the project and the time when employees join or leave the project
are set as events. Then the scheduler assigns workloads in chronological

14

order with the growing of time t. If t is an event, the scheduler reassigns the actual workloads
according to the priority of a task defined by the task list and the originally planned
workloads given in (12) (lines 6-16). Otherwise, if t is not an event, the workloads at t remain
the same as those at t1 (line 19). After allocating the actual workloads at t, the achievement
t

A j of tj at t is calculated by (2)-(4) (line 21). If there is any task finished at t, the time t+1 is
set as an event because the resources assigned to these tasks can all be released at t1. These
steps run repeatedly until all tasks of the project have been finished. If there are local
refinement steps in lines 17 and 24. The local refinement steps are designed to further
improve performance of the plan. It is based on two ideas.
First, in practice, regular employees are usually expected to work more for the project so that the
costs for hiring extra employees can be saved. Therefore, the refinement step in line 17 is to let
regular employees dedicate their normal working hours to the project. More specifically,
for all regular employees i, if the assignment in lines 7-16 satisfies hours ti = =1 > 0,

15

hours i < maxhi, and hours i < nh , it means that the ith employee is planned to work for the
project at time t but not all of his normal working hours are dedicated. In this case, according to
the order defined by the task list, we find the first task t j from the task list that satisfies wht ij

> 0 and update whtij to

+(

),

< ,

+(

),

In this way, the ith employee can dedicate all of his normal working hours nh to the project.
Second, if a task tj is finished at time t, it is possible that there are redundant assignments at t.
In other words, if some workloads are released, task tj may still be finished at t. To reduce
cost, it is necessary to reduce such redundant assignments. Redundant assignments are
released as follows.
t

Step a: Arrange the employees that work for tj at time t (i.e., wh ij > 0) in ascending order of
their proficiency scores profij in task tj. Proficiency scores are defined in (2).
Step b: Select the first employee from the order given in step a and denote the employee as u.
t

Step c: Repeatedly set wh uj=wh uj-nh. Unit percent% and test whether tj can be complete at
t

time t under this assignment until wh uj =0 or tj cannot be complete. Here, although the
working hours of employees can be continuous variables, setting the working hours to a very
precise value like 159.5 hours/month is meaningless. Therefore, we only test the situation
when a certain percentage unitpercent of the normal working hours are reduced. According to
the discussion of workload discretization in [6], we set unitpercent=25 in this project.
t

Step d: If wh uj=0, set the next employee in the order given in step a as the employee u and go
t

to step c. If tj cannot be complete at time t, reset wh uj =wh uj+nh. unitpercent% to make sure
16

that tj can be finished, and the refinement procedure is ended. Compared with the RCPSP and
the employee allocation models, as the proposed representation scheme combines the task list
and the employee allocation matrix it is able to deal with both the issues of task scheduling
and employee allocation. In addition, with the EBS, the problems of task preemption and
resource conflict can be addressed. Compared with the time-line-based model [6] that uses a
3D matrix with size m*n*nd, the proposed scheme only uses a task list of length n and a
matrix of size m*n for representation. In other words, the proposed scheme reduces the
representation size from O( m. n. end) to O( m. n), and thus reduces the size of search space.
As new assignments are only made at events, the project can be executed in a more stable
way. More fundamentally, an essential difference between the proposed scheme and the
existing methods is the granularity of planning. The RCPSP and the employee allocation
models make plans with the granularity to task. Thus, they can only make plans with each
task having a fixed workload assignment and cannot deal with task preemption. On the other
hand, the time-line-based model makes plans with the granularity to each time period.
Though the model is flexible, the plan is too fine-grained and thus the problems of a large
search space and desultory workload assignments are incurred. In contrast, the proposed
scheme makes plans with the granularity to event. In this way, the scheme has sufficient
information for modeling task preemption and reduces the search space as well.

17

2.9 A NT COLONY OPTIMIZATION APPROACH

To solve the software project planning problem, the proposed project proposes an ACO approach.
The underlying idea of ACO is to simulate the foraging behavior of ants. When ants search for
food, they usually deposit a special chemical on the path they travel through. This kind of
chemical, which is called pheromone, serves as a medium for ants to communicate with each
other. By sensing the concentration of pheromone, other ants can follow the path to find the food.
Inspired by this swarm intelligence phenomenon, ACO was developed by Dorigo et al. [3] and
has been successfully applied to various optimization problems.

Fig No: 2.9 ACO Algorithm

18

3. SYSTEM ANALYSIS

3.1 EXISTING SYSTEM

In software project is a people-intensive activity and its related resources are mainly human
resources. Different software project tasks require employees with different skills, and skill
proficiency of employees significantly influences the efficiency of project execution. As such,
assigning employees to the best-fitted tasks is challenging for software project managers, and
human resource allocation has become a crucial part in software project planning. Techniques like
PERT and CPM lack the consideration of resource allocation and scheduling models like the
RCPSP do not consider the allocation of employees with various skills. Therefore, this technique
usually regard task scheduling and human resource allocation as two separated activities and
leave the job of human resource allocation to be done by project managers manually so resulting
is inefficient resource allocation and poor management performance.

EXISTING TECHNIQUE

Program Evaluation and Review Technique (PERT)

Critical Path Method (CPM)

DISADVANTAGES

Very large search space or have to restrict the flexibility

Inefficient resource allocation

Poor management performance

Allocate the same task different groups of employees in different periods

19

3.2 PROPOSED SYSTEM

In this model we develop a practical and effective approach for the task scheduling and
human resource allocation problem in software project planning with an ant colony
optimization (ACO) algorithm. In this method have the following features. These features are
representation scheme is composed of a task list and a planned employee allocation matrix.
The task list defines the priorities of tasks to consume resources, and the planned employee
allocation matrix specifies the originally planned workload assignments. In this way, the
representation takes both the issues of task scheduling and resource allocation into account.
Another one is, we are using an ACO approach. As ACO builds solutions in a step-by-step
manner and enables the use of problem-based heuristics to guide the search direction of ants,
it is possible to design useful heuristics to direct the ants to schedule the critical tasks as early
as possible and to assign the project tasks to suitable employees with required skills.
PROPOSED TECHNIQUE

Ant Colony Optimization (ACO) Algorithm

ADVANTAGES

To reduces the size of the search space and thus accelerates the search process.

Lower costs and more stable workload assignments

It is used to reduce the flexibility of the resource allocation.

20

3.3 TECHNICAL REQUIREMENTS

SOFTWARE REQUIREMENT

Operating system

: Windows7

Front End

: Java, Tomcat server 7.0, Net beans.

Backend

: MySql

HARDWARE REQUIREMENT

Processor

: Pentium Dual Core 2.00GHZ

Hard disk

: 40 GB

Mouse

: Logitech.

RAM

: 2GB(minimum)

Keyboard

: 110 keys enhanced.

3.4 TOOLS
TECHNOLOGIES USED
3.4.1 Introduction to Java:
Java has been around since 1991, developed by a small team of Sun Microsystems
developers in a project originally called the Green project. The intent of the project was to
develop a platform-independent software technology that would be used in the consumer
electronics industry. The language that the team created was originally called Oak.
The first implementation of Oak was in a PDA-type device called Star Seven (*7) that
consisted of the Oak language, an operating system called GreenOS, a user interface, and
hardware. The name *7 was derived from the telephone sequence that was used in the team's

21

office and that was dialed in order to answer any ringing telephone from any other phone in
the office.
Around the time the First Person project was floundering in consumer electronics, a
new craze was gaining momentum in America; the craze was called "Web surfing." The
World Wide Web, a name applied to the Internet's millions of linked HTML documents was
suddenly becoming popular for use by the masses. The reason for this was the introduction of
a graphical Web browser called Mosaic, developed by ncSA. The browser simplified Web
browsing by combining text and graphics into a single interface to eliminate the need for
users to learn many confusing UNIX and DOS commands. Navigating around the Web was
much easier using Mosaic.
It has only been since 1994 that Oak technology has been applied to the Web. In 1994,
two Sun developers created the first version of Hot Java, and then called Web Runner, which
is a graphical browser for the Web that exists today. The browser was coded entirely in the
Oak language, by this time called Java. Soon after, the Java compiler was rewritten in the
Java language from its original C code, thus proving that Java could be used effectively as an
application language. Sun introduced Java in May 1995 at the Sun World 95 convention.

Web surfing has become an enormously popular practice among millions of computer
users. Until Java, however, the content of information on the Internet has been a bland series
of HTML documents. Web users are hungry for applications that are interactive, that users
can execute no matter what hardware or software platform they are using, and that travel
across heterogeneous networks and do not spread viruses to their computers. Java can create
such applications.

22

The Java programming language is a high-level language that can be characterized by

all of the following buzzwords:

Simple

Architecture neutral

Object oriented

Portable

Distributed

High performance

Interpreted

Multithreaded

Robust

Dynamic

Secure
With most programming languages, you either compile or interpret a program so that

you can run it on your computer. The Java programming language is unusual in that a
program is both compiled and interpreted. With the compiler, first you translate a program
into an intermediate language called Java byte codes the platform-independent codes
interpreted by the interpreter on the Java platform. The interpreter parses and runs each Java
byte code instruction on the computer. Compilation happens just once; interpretation occurs
each time the program is executed. The following figure illustrates how this works.

23

Figure 3.4.1: Working Of Java

You can think of Java bytecodes as the machine code instructions for the java virtual
machine (Java VM). Every Java interpreter, whether its a development tool or a Web browser

that can run applets, is an implementation of the Java VM. Java bytecodes help make write
once, run anywhere possible. You can compile your program into bytecodes on any platform
that has a Java compiler. The bytecodes can then be run on any implementation of the Java
VM. That means that as long as a computer has a Java VM, the same program written in the
Java programming language can run on Windows 2000, a Solaris workstation, or on an iMac.
3.4.2 The Java Platform:
A platform is the hardware or software environment in which a program runs. Weve
already mentioned some of the most popular platforms like Windows 2000, Linux, Solaris,
and MacOS. Most platforms can be described as a combination of the operating system and
hardware. The Java platform differs from most other platforms in that its a software-only
platform that runs on top of other hardware-based platforms.
The Java platform has two components:
The java virtual machine (Java VM)
The java application programming interface (Java API)
Youve already been introduced to the Java VM. Its the base for the Java platform
and is ported onto various hardware-based platforms.
The Java API is a large collection of ready-made software components that provide
many useful capabilities, such as graphical user interface (GUI) widgets. The Java API is
grouped into libraries of related classes and interfaces; these libraries are known as packages.
24

The next section, What Can Java Technology Do? highlights what functionality some of the
packages in the Java API provide.
The following figure depicts a program thats running on the Java platform. As the
figure shows, the Java API and the virtual machine insulate the program from the hardware.

Figure 3.4.2: The Java Platform

Native code is code that after you compile it, the compiled code runs on a specific
hardware platform. As a platform-independent environment, the Java platform can be a bit
slower than native code. However, smart compilers, well-tuned interpreters, and just-in-time
bytecode compilers can bring performance close to that of native code without threatening
portability.
3.4.3 Working of Java:
For those who are new to object-oriented programming, the concept of a class will be new
to you. Simplistically, a class is the definition for a segment of code that can contain both data
and functions. When the interpreter executes a class, it looks for a particular method by the name
of main, which will sound familiar to C programmers. The main method is passed as a parameter
an array of strings (similar to the argv[] of C), and is declared as a static method.

To output text from the program, execute the println method of System.out, which is
javas output stream. UNIX users will appreciate the theory behind such a stream, as it is

25

actually standard output. For those who are instead used to the Wintel platform, it will write
the string passed to it to the users program.
3.4.4 Swing:
Introduction to Swing:
Swing contains all the components. Its a big library, but its designed to have
appropriate complexity for the task at hand if something is simple, you dont have to write
much code but as you try to do more your code becomes increasingly complex. This means
an easy entry point, but youve got the power if you need it.
Swing has great depth. This section does not attempt to be comprehensive, but instead
introduces the power and simplicity of Swing to get you started using the library. Please be
aware that what you see here is intended to be simple. If you need to do more, then Swing
can probably give you what you want if youre willing to do the research by hunting through
the online documentation from Sun.
3.4.5 Benefits of Swing:
Swing components are Beans, so they can be used in any development environment
that supports Beans. Swing provides a full set of UI components. For speed, all the
components are lightweight and Swing is written entirely in Java for portability.
Swing could be called orthogonality of use; that is, once you pick up the general
ideas about the library you can apply them everywhere. Primarily because of the Beans
naming conventions.
Keyboard navigation is automatic you can use a Swing application without the mouse,
but you dont have to do any extra programming. Scrolling support is effortless you simply

26

wrap your component in a JScrollPane as you add it to your form. Other features such as tool
tips typically require a single line of code to implement.
Swing also supports something called pluggable look and feel, which means that
the appearance of the UI can be dynamically changed to suit the expectations of users
working under different platforms and operating systems. Its even possible to invent your
own look and feel.
3.4.6 Domain Description:
Data mining involves the use of sophisticated data analysis tools to discover
previously unknown, valid patterns and relationships in large data sets. These tools can
include statistical models, mathematical algorithms, and machine learning methods
(algorithms that improve their performance automatically through experience, such as neural
networks or decision trees). Consequently, data mining consists of more than collecting and
managing data, it also includes analysis and prediction.
Data mining can be performed on data represented in quantitative, textual, or multimedia
forms. Data mining applications can use a variety of parameters to examine the data. They
include association (patterns where one event is connected to another event, such as purchasing a
pen and purchasing paper), sequence or path analysis (patterns where one event leads to another
event, such as the birth of a child and purchasing diapers), classification (identification of new
patterns, such as coincidences between duct tape purchases and plastic sheeting purchases),
clustering (finding and visually documenting groups of previously unknown facts, such as
geographic location and brand preferences), and forecasting (discovering patterns from which one
can make reasonable predictions regarding future activities, such as the prediction that people
who join an athletic club may take exercise classes)

27

Figure 3.4.6 knowledge discovery process

3.4.7 Data Mining Uses:

Data mining is used for a variety of purposes in both the private and public sectors.

Industries such as banking, insurance, medicine, and retailing commonly use data
mining to reduce costs, enhance research, and increase sales. For example, the
insurance and banking industries use data mining applications to detect fraud and
assist in risk assessment (e.g., credit scoring).

Using customer data collected over several years, companies can develop models that
predict whether a customer is a good credit risk, or whether an accident claim may be
fraudulent and should be investigated more closely.

28

The medical community sometimes uses data mining to help predict the effectiveness
of a procedure or medicine.

Pharmaceutical firms use data mining of chemical compounds and genetic material to
help guide research on new treatments for diseases.

Retailers can use information collected through affinity programs (e.g., shoppers club
cards, frequent flyer points, contests) to assess the effectiveness of product selection and
placement decisions, coupon offers, and which products are often purchased together.
3.4.8 FEASIBILITY STUDY:
Introduction:
A feasibility analysis involves a detailed assessment of the need, value and practicality of a
p systems development. Feasibility analysis n forms the transparent decisions at crucial
points during the developmental process as we determine whether it is operationally,
economically and technically realistic to proceed with a particular course of action.
Feasibility analysis can be used in each of the steps to assess the financial, technical and
operational capacity to proceed with particular activities.
3.4.9 Types of feasibility:
A feasibility analysis usually involves a thorough assessment of the financial
(value), technical (practicality), and operational (need) aspects of a proposal. In systems
development projects, business managers are primarily responsible for assessing the
operational feasibility of the system, and information technology (IT) analysts are responsible
for assessing technical feasibility. Both then work together to prepare a costbenefit analysis
of the proposed system to determine its economic feasibility.

29

OPERATIONAL FEASIBILITY:
A systems development project is likely to be operationally feasible if it meets
the 'needs' and expectations of the organization. User acceptance is an important determinant of
operational feasibility. It requires careful consideration of: corporate culture, staff resistance or
receptivity to change, management support for the new system, the nature and level of user
involvement in the development and implementation of the system; direct and indirect impacts of
the new system on work practices anticipated performance and outcomes of the new system
compared with the existing system training requirements and other change management
strategies; and pay back periods (ie trade-off between long-term organizational benefits and
short-term inefficiencies during system development and implementation).

ECONOMICAL FEASIBILITY:
This study is carried out to check the economic impact that the system will have on
the organization. The amount of fund that the company can pour into the research and
development of the system is limited. The expenditures must be justified. Thus the developed
system as well within the budget and this was achieved because most of the technologies
used are freely available. Only the customized products had to be purchased.
TECHNICAL FEASIBILITY:
This study is carried out to check the technical feasibility, that is, the technical
requirements of the system. Any system developed must not have a high demand on the
available technical resources. This will lead to high demands on the available technical
resources. This will lead to high demands being placed on the client. The developed system
must have a modest requirement, as only minimal or null changes are required for
implementing this system.

30

SOCIAL FEASIBILITY:
The aspect of study is to check the level of acceptance of the system by the user. This
includes the process of training the user to use the system efficiently. The user must not feel
threatened by the system, instead must accept it as a necessity. The level of acceptance by the
users solely depends on the methods that are employed to educate the user about the system
and to make him familiar with it. His level of confidence must be raised so that he is also able
to make some constructive criticism, which is welcomed, as he is the final user of the system.

31

4. REQUIREMENT ANALYSIS
4.1 Requirements analysis and specification.
System boundaries should be defined and clearly specified in this activity, in a Task based
approach requirement analysis also implies that it is necessary to analyze whether
requirements can be fulfilled with available components.
Availability of existing components is also considered in requirement specification. Analysis
have to be aware of the components that can possibly be reused. It is likely that appropriate
components fulfils all the similar requirement, in such cases one possibility is to negotiate the
requirements and modify them to be able to use the existing system components to keep with
task based approach and utilize its advantages. The main motive of this phase is to make the
solution as crystal clear as possible.
The systems services, constraints and goals are established (i. e a specification what the system is
supposed to do). In this phase one important activity is to analyze the possibility of realizing the
solutions that will meet these requirements. In a task based approach this implies that it is
necessary to analyze whether these requirements can be fulfilled by available components. This
means that the requirements engineers must be aware of components that can possibly be used.
Since it is not likely that appropriate components can always be found, there is a risk that the new
components have to be implemented. To keep the task-based approach one possibility is to
negotiate the requirements and them to be able to use the existing components.

4.2 Analysis and Designing of the System Architecture

The design phase starts with an architectural design of the system followed by more detailed
design of the system. During this phase a decision has to be made about the possible use of the

32

event based scheduler model and Ant colony optimization algorithm as this decision plays a
crucial role in the architecture design of the system as well as the quality of the system.
Similar to the requirements specification phase the system specification and design is
strongly related to the availability of the components. The potential components are
complying with a particular model. One could assume that it would be possible to used
components implemented in different kinds of technologies, but in practice it is very difficult
to achieve interoperability between different kinds of models. Every models requires a
particular architectural framework, and the application is supposed to use this framework.
This directly has impact on architectural decisions.
4.3 Implementation
Finding candidate component as per requirement is the main focus of this phase.
Theoretically no coding is required during this phase but practically coding is usually
required as all functionality is rarely found in a component and some functionality need to be
coded which is not provided by the component. When building Task based system, an ideal
case is build an application by direct integration of components, i.e. directly connecting
components. The glue code is a code that specifies this connection. In practice the role of
the glue code will also include adaption of the components themselves are already build and
tested. However the component tests in isolation are not sufficient. Often design units will be
implemented as assemblies of several components and possibly a glue code. These
assemblies must be tested separately, since an assembly of correct components may be
incorrect although the components themselves are correct.

33

4.4 System Integration

The integration process includes integration of standard infrastructure components that build
a component framework and the application components. The integration of a particular
component into a system is called a deployment. This is a very important and critical phase of
CBSE as at this point components integration most likely occurs because of lack of
communication, capability issue, if the component is not made for the architecture. It is like if
we want to build a car by integrating different car parts. System quality and functionality
need to be validated and verified in this phase. To know the effectiveness of the assembled
components a metrics is usually developed.
In difference to the requirements System design Unit design Unit implementation Unit test
system Test system Integration operation & maintenance select Adapt test Find Evaluate
System development component development entire system integration a component
deployment is a mechanism for integration of particular components- it includes download
and registering of the component.

4.5 Functional and Non-Functional Requirements:

4.5.1 Functoinal Requirements:
a. Inputs:
Browsing and uploading of files.
b. Processing:
Cluster server: There are 3 cluster servers Cluster server1 stores files of server1.Cluster
server2 stores files of server2. Cluster server3 stores files of server3.
Load server: Stores all files

34

Slip server cluster:

Browses the file

Selects the path

Download the fie

Output: SIP user agent clients select file and location to download the file. To download the
selected file server will send file to the SIP user agent.

4.5.2

Non Functional Requirements

Performance is measured in terms of the output provided by the application.

Requirement specification plays an important part in the analysis of a system. Only when
the requirement specifications are properly given, it is possible to design a system, which will fit
into required environment. It rests largely in the part of users of the existing system to give the
requirement specifications because they are the people who finally use the system.

The requirement specification for any system can be broadly stated as given below:

The system should be able to interface with the existing system.

The system should be accurate.

The system should be better than existing system.

Portability: It should run on specified platforms successfully. To achieve this

we should test the product on all platforms before launching the product. If our
project runs successfully on different platforms then our system is portable in
nature.

Reliability: The system should perform its intended functions under specified
conditions. If our system satisfies all the specified conditions then it is
Reliable in nature.

Reusability: The system should be extremely reusable as a whole or part. Make

the system modularize and make sure that modules are loosely coupled. This
35

project is having reusability nature because we can reuse whole or part of this
project on other systems.

Robustness: The system on the whole should be robust enough to perform

well under different circumstances without any inconsistencies.

Testability: The product of a given development phase should satisfy the

conditions imposed at the start of that phase.

Usability: It should be perfect and comfortable for users to work.

Security: The system is completely based on the security. This system will
provide security base on the password.

4.6 Testing
Since components are developed by the third party the need for the component verification is
apparent since the system developers typically have no control over component quality or
component functions.
4.7 System Verification and Validation.
The standard test and verification techniques are used here. The specific problem for
component-based approach is location of error, especially when components are of black
box and delivered from different vendors. Typically a component can exhibit an error, but
the cause of malfunction lies in another component. Constructional interfaces play an
important role in checking the proper input and output from components. These interfaces
enable a specification of input and output and checking the correctness of data.
4.8 Operational Support and Maintenance
The maintenance process includes some steps that are similar to the integration process: A new or
modified component is deployed into the system. Also it may be necessary to change the glue
code. It is similar to any other software released of a traditionally software development
methodology. Released is made in such a way that it is suitable for delivery and installation.
36

While maintenance phase is usually involved replacement of old/obsolete component with

the new component to the system Testing and verification have to be done to check the proper
integration of the component into the system. In most of the cases an existing component will
be modified or a new version of the same component will be integrated into the system. Once
again new problems caused by the incompatibility between components, or by broken
dependencies may occur. This means, one again that the system must be verified.

37

5. SOFTWARE REQUIREMENT SPECIFICATIONS

The SRS describes the function and performance requirements of the employee tasks and
allocation of human resources to the particular task in the effective model for software project
planning and scheduling with an event-based scheduler and an ant colony optimization algorithm.
In our project development we consider my SQL as the back end of the server and all the
necessary documents and tasks list and tables are maintained in a database. As concerned to scope
of the product, it is essential element for education institutes, software project management,
medical research, software industry. The product will avoid the mismanagement of allocation of
human resources and provide a secured way of developing a project in any company or any
institution developing the project and securely maintains all the documents.

5.1 Scope of the Developed Project

In future research, it will be interesting to consider employee experience and the
training model to make the considered problem more comprehensive. Including uncertainty
treatment in the software project planning model is also a promising research topic. In
addition, since the model proposed in this paper provides a flexible and effective way for
managing human resources, it is promising to apply the proposed approach to other complex
human-centric projects like consulting projects.
5.2 Overview of document
For the rest of the document, we first of all have defined the overall product. Then, we have
given the software requirements, followed by a brief description of the product components
and features.

38

5.3 Overall description product perspective

Effective model for software project planning with event-based scheduler and ant colony
optimization algorithm is a standalone system. It aims to replace the existing model for
software project planning by providing an enhancement over their existing features.
5.4 Product functions
Allows the client to enter the necessary details of the particular project. The admin can view
the particular project, allot employee to work on the particular project, assign module and if
there no available or employee ready to work on the project the admin can also recruit new
employee. The employee can start his work view the amount of project completion time-totime.
5.5 Module-Description
We have three Modules

Admin
User
Task

ADMIN:

Admin Module is Responsible for creating new employees with responsible skills and working details

USER:
User module is responsible for checking tasks whether it is completed or not and total time
remaining for completion of project and assigning new tasks for users.
TASKS:
The TASK module is contains complete SRS of the project that the user is going to create, it
divides the SRS into different parts for completion of project in within time
39

Task contains
No of Modules
Priority
Time for each module
Modules status

5.6 Operating Environment

Client Side Requirement:
OS: Window 9
Software Packages: Net beans, java, My SQL, Tomcat Apache server.
5.7 User view of product use
The client and enter all required projects to be done. It contains an admin page where user
can view, recruit, allot project, assign modules to employees and view the update of
completion of work.
5.8 Software Quality Attributes Business Rules
The basic fact here is the material for upload and download is totally dependent on the users
direction and network has no responsibility for that matter. It only provides a medium of
transport. Its up users sense of morality in which manner he exploits the system.

40

6. SYSTEM DESIGN

6.1 SYSTEM ARCHITECTURE

The software architecture of a program or computing system is the structure or structures of
the system, which comprise software components, the externally visible properties of those
components and the relationships among them.
6.2 PROCESS MODEL
The unified process model is adapted in this software development approach for building a
efficient and task based system. Booch, Jacobson, Rumbaugh 1999. Lifetime of a software
product in cycles: Birth, childhood, adulthood, old-age, death. Product maturity stages each
cycle has phases, culminating in a new release (c.f. Spiral model)
Inception identify core use cases, and use to make architecture and design tradeoffs.
Estimate and schedule project from derived knowledge.
Elaboration capture detailed user requirements. Make detailed design, decide on build vs.
buy.
Construction components are bought or built, and integrated.
Transition release a mature version that satisfies acceptance criteria.
Agile methods, extreme programming (XP)
XP = Extreme Programming emphasizes: Individuals and interactions Over processes and
tools working software, over documentation

Customer collaboration

Over contract negotiation

Responding to change

Over following a plan

41

Programming in pairs

Test driven development

Continuous planning, change, delivery Shared project metaphors, coding standards and
ownership of code
No overtime! (Yeah right!)
Advantages

Lightweight methods suit small-medium size projects

Produces good team cohesion

Emphasizes final product Iterative Test based approach to requirements and quality
assurance

42

6.3 UML DIAGRAMS

6.3.1 Use-Case diagram:
A use case is a set of scenarios that describing an interaction between a user and a
system. A use case diagram displays the relationship among actors and use cases. The two
main components of a use case diagram are use cases and actors.

Contents:

Use cases
Actors
Dependency, Generalization, and association relationships
System boundary

Fig No: 6.3.1 Use case diagram

43

6.3.2 Class diagram.

Class diagrams are widely used to describe the types of objects in a system and their
relationships. Class diagrams model class structure and contents using design elements such as
classes, packages and objects. Class diagrams describe three different perspectives when
designing a system, conceptual, specification, and implementation. These perspectives become
evident as the diagram is created and help solidify the design. Class diagrams are arguably the
most used UML diagram type. It is the main building block of any object oriented solution. It
shows the classes in a system, attributes and operations of each class and the relationship between
each class. In most modeling tools a class has three parts, name at the top, attributes in the middle
and operations or methods at the bottom. In large systems with many classes related classes are
grouped together to create class diagrams. Different relationships between diagrams are show by
different types of Arrows. Below is an image of a class diagram. Follow the scenario. The
processes are represented vertically and interactions are show as arrows. This article explains the
purpose and the basics of Sequence diagrams.

Fig No: 6.3.2 Class Diagram

UML Class Diagram with Relationships

44

6.3.3 Sequence Diagram

Sequence diagrams in UML shows how object interact with each other and the order those
interactions occur. Its important to note that they show the interactions for a particular

Fig No: 6.3.3 Sequence Diagram

45

6.3.4 Collaboration diagram

Communication diagram was called collaboration diagram in UML 1. It is similar to
sequence diagrams but the focus is on messages passed between objects. The same
information can be represented using a sequence diagram and different objects. Click here to
understand the differences using an example.

Fig No: 6.3.4 Collaboration Diagram

46

6.3.5 Activity diagram

Activity diagrams describe the workflow behavior of a system. Activity diagrams are
similar to state diagrams because activities are the state of doing something. The diagrams
describe the state of activities by showing the sequence of activities performed. Activity
diagrams can show activities that are conditional or parallel.

Admin
Fig No: 6.3.5 Activity Diagram
47

6.3.6 Component Diagram

A component diagram displays the structural relationship of components of a software

system. These are mostly used when working with complex systems that has many
components. Components communicate with each other using interfaces. The interfaces are
linked using connectors. Below images shows a component diagram.

Fig No: 6.3.6 Component Diagram

48

6.3.7 Deployment Diagram

A deployment diagrams shows the hardware of your system and the software in those hardware.
Deployment diagrams are useful when your software solution is deployed across multiple
machines with each having a unique configuration. Below is an example deployment diagram.

Fig No: 6.3.7 Deployment Diagram

49

7. IMPLEMENTATION
7.1 PSEUDO CODE
ADMIN.JSP
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8" />
<title>Software Development</title>
<link type="text/css" href="menu.css" rel="stylesheet" />
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="menu.js"></script>
<link rel="stylesheet" href="style.css" />

<link href='http://fonts.googleapis.com/css?family=Oleo+Script' rel='stylesheet'

type='text/css'>
<script type="text/javascript" src="jquery-1.7.min.js"></script>
<script type="text/javascript" src="jquery/jquery.js">
</script>
<script type="text/javascript">
$(document).ready(function(){
$("#login").click(function(){
var action = $("#lg-form").attr('action');
var form_data = {
username: $("#username").val(),
password: $("#password").val(),
is_ajax: 1
};

50

$.ajax({
type: "POST",
url: action, data:
form_data,
success: function(response)
{
if(response == "success")
$("#lg-form").slideUp('slow', function(){
$("#message").html('<p class="success">You have logged in successfully!
</p><p>Redirecting....</p>');
});
else
$("#message").html('<p class="error">ERROR: Invalid username and/or password.</p>');
}
});
return false;
});
});
</script>
<script> $(document).ready(function(){
$('.sim-micro-desktop').hide(); $('.simmini-desktop').hide(); $('.sim-maxidesktop').hide(); $('.sim-megadesktop').hide(); $('.phone-smartmicro-desktop').hide(); $('.phonesmart-mini-desktop').hide();

51

$('.phone-smart-desktop').hide(); $
('.phone-smart-maxi-desktop').hide();
$('form#lg-form').click(function(){ if($
('.sim-micro-btn').is(":checked")){

$('.sim-micro-desktop').show();
} else {
$('.sim-micro-desktop').hide();
}
if($('.sim-mini-btn').is(":checked"))
{ $('.sim-mini-desktop').show();

} else { $('.sim-minidesktop').hide();
}
if($('.sim-maxi-btn').is(":checked"))
{ $('.sim-maxi-desktop').show();

} else { $('.sim-maxidesktop').hide();
}
if($('.sim-mega-btn').is(":checked"))
{ $('.sim-mega-desktop').show();

} else {
}
$('.sim-mega-desktop').hide(); if($
('.phone-smart-micro-btn').is(":checked")){

$('.phone-smart-micro-desktop').show();
} else {
$('.phone-smart-micro-desktop').hide();
52

if($('.phone-smart-mini-btn').is(":checked")){ $
('.phone-smart-mini-desktop').show();

} else { $('.phone-smart-minidesktop').hide();
}
if($('.phone-smart-btn').is(":checked")){ $
('.phone-smart-desktop').show();

} else { $('.phone-smartdesktop').hide();
}
if($('.phone-smart-maxi-btn').is(":checked")){ $
('.phone-smart-maxi-desktop').show();

} else { $('.phone-smart-maxidesktop').hide();
}
});
});
</script>
</head>
<body bgcolor="red">
<div style="height: 150px; width: 1350px; background-color: #D2691E;">
<br> <center> <font color="#DEB887"> <h1> Ant Colony Optimization for
Software Project Scheduling</h1><h1> and</h1><h1> Staffing
with an Event-Based Scheduler</h1></font></center>

</div>
53

<style type="text/css">
*
{ margin:0;
padding:0;

}
html
{ background:wheat; }
body {
margin:0px auto;
width:1350px;
height:600px;
background:wheat ;
overflow:hidden;
}
div#menu {
}
div#copyright { display:
none; } input#gobutton{
cursor:pointer; /*forces the cursor to change to a hand when the button is
hovered*/ padding:5px 25px; /*add some padding to the inside of the button*/
background:#D2691E; /*the colour of the button*/
border:1px solid #33842a; /*required or the default border for the browser will
appear*/ /*give the button curved corners, alter the size as required*/
-moz-border-radius: 10px;
-webkit-border-radius: 10px;
border-radius: 10px;
/*give the button a drop shadow*/ -webkitbox-shadow: 0 0 4px rgba(0,0,0, .75);

54

-moz-box-shadow: 0 0 4px rgba(0,0,0, .75);

box-shadow: 0 0 4px rgba(0,0,0, .75);
/*style the text*/
color:#f3f3f3;
font-size:1.1em;

}
/***NOW STYLE THE BUTTON'S HOVER AND FOCUS STATES***/
input#gobutton:hover, input#gobutton:focus{
background-color :#399630; /*make the background a little darker*/
/*reduce the drop shadow size to give a pushed button effect*/
-webkit-box-shadow: 0 0 1px rgba(0,0,0, .75);
-moz-box-shadow: 0 0 1px rgba(0,0,0, .75);
box-shadow: 0 0 1px rgba(0,0,0, .75);

}
</style>
<style type="text/css">
div1 {
position: absolute;
left: 10px;

top: 40px; backgroundcolor: #f1f1f1; width:

280px;
padding: 10px;
color: black;

border: #0000cc 2px dashed;

display: none;
}
55

</style>
<script language="JavaScript">
function setVisibility(id, visibility) {

document.getElementById(id).style.display = visibility;
}
</script>
<div id="menu"> <ul
class="menu">
<li><a href="#" class="parent"><span>Home</span></a>
<li><a href="#" class="parent"><span>Login</span></a>

</li>
<li><a href="#"><span>Support</span></a></li>
<li class="last"><a href="#"><span>Contacts</span></a></li>
<li class="last"><a href="index.jsp"><span>Logout</span></a></li>
</ul>
</div>
<table align="center"
width="1350"> <tr>
<td align="center">
<table align="center">
<tr>
<td align="center">
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

<img src="images/admin1.gif" height="300" width="300" >

56

</td>
</tr>
</table>
</td>
<td align="-center">
<table align="center" >
<tr>
<td align="center">
<body>
<div class="lg-container">
<%
try
{
String q=request.getQueryString();
if(q.equalsIgnoreCase("namefail"))
{%>

<marquee>
<font color='red'> User name already Exist Please Select Another User Name
</marquee>
<%} }
catch(Exception e1)

{
e1.printStackTrace();
}%>
<h1>Employee
details</h1> <hr><hr>
<form action="detailscon.jsp" id="lg-form" name="lg-form" method="post">
57

<div>
<select name="emp">
<option>---Select---</option>

<option value="developer">Software Developer</option>

<option value="trainer">Software Trainer</option>
</select>
</div>
<div>
<label for="password">Name :</label>
<input type="text" name="name" id="name"
placeholder="Employee Name" />
</div>
<div>
<label for="password">Basic Salary :</label>
<input type="text" name="basicsal" id="name"
placeholder="Basic Salary" />
</div>
<div>
<label for="password">Salary For Hour :</label>
<input type="text" name="salhour" id="name"
placeholder="Salary For Hour(" />
</div>
<div>
<label for="password">Normal working hours :</label>
<input type="text" name="workinghrs" id="name"
placeholder="Normal Working kours" />
</div>

58

<hr><hr>
<h3>Employee Skills</h3>
<hr><hr>
<div>
<label
for="password">JAVA
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs
p; :&nbsp;&nbsp;&nbsp;</label> <label><input type="radio" name="group1" class="simmicro-btn" value="java"/></label><br>
<label
for="password">.NET
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs
p;&nbsp;&nbsp; :&nbsp;&nbsp;&nbsp;</label> <label><input type="radio" name="group1"
class="sim-mini-btn" value=".net"/></label> <br>
<label
for="password">PHP
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs
p;&nbsp;&nbsp; :&nbsp;&nbsp;&nbsp;</label><label><input type="radio" name="group1"
class="sim-maxi-btn" value="php"/></label><br>
<label
for="password">ANDROID
&nbsp;&nbsp;&nbsp;&nbsp;:&nbsp;&nbsp;&nbsp;</label> <label><input type="radio"
name="group1" class="sim-mega-btn" value="android"/></label><br>
<hr><hr>
<h3>Employee Experience</h3>
<hr><hr>
<la
<div class="billpay-internet-add-ons">
<div class="sim-micro-desktop">
<div>
Core
Java&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

<input type="checkbox" name="subtech" value="corejava">

</div>
<div>
59

Servlets
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs
p;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

<input type="checkbox" name="subtech" value="servlet">

</div>
<div>
Jsp
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs
p;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

&nbsp;&nbsp;&nbsp;
<input type="checkbox" name="subtech" value="jsp">
</div>
<div>
Frame Works &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<input type="checkbox" name="subtech" value="frame">
</div>
</div>
<div class="sim-mini-desktop">

<div>

C#
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs
p;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<input type="checkbox" name="subtech" value="c#">
</div>
<div>
Asp
.Net
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs
p;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp
<input type="checkbox" name="subtech" value="asp.net">
</div>
60

<div>
Ado
.NET
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs
p;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<input type="checkbox" name="subtech" value="ado.net">
</div>
</div>
<div class="sim-maxi-desktop">

<div>
PHP
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs
p;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

<input type="checkbox" name="subtech" value="phptech">

</div>
</div>
<div class="sim-mega-desktop">
<div>
Android
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbs
p;&nbsp;

<input type="checkbox" name="subtech" value="androidtech">

</div>
</div>
</div>
<div>
<input id="gobutton" type="submit" value="Go!" /> <!--the text in the quotes after value will
appear on the button-->
</div>
</div>
61

</form>
<div id="message"></div>
</div>
</td>
</tr>
</table>
</td>
</tr>
</table>
<div id="copyright">Copyright &copy; 2013 <a href="http://apycom.com/">Apycom jQuery
Menus</a></div>
</body>
</html>
CLIENT.JAVA
public class Client extends javax.swing.JFrame {

/**
* Creates new form Client
*/
public Client()
{ initComponents
();
}
/**
*

This method is called from within the constructor to initialize the form.

WARNING: Do NOT modify this code. The content of this method is always

regenerated by the Form Editor.

*/

62

@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

jPanel1 = new javax.swing.JPanel(); jLabel1

= new javax.swing.JLabel(); jLabel2 = new
javax.swing.JLabel(); jLabel3 = new
javax.swing.JLabel(); jLabel4 = new
javax.swing.JLabel(); jTextField1 = new
javax.swing.JTextField(); jLabel5 = new
javax.swing.JLabel(); jTextField2 = new
javax.swing.JTextField(); jButton1 = new
javax.swing.JButton(); jButton2 = new
javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jPanel1.setBackground(new java.awt.Color(255, 204, 153));

jPanel1.setBorder(javax.swing.BorderFactory.createLineBorder(new java.awt.Color(0,
0, 0)));
jPanel1.setForeground(new java.awt.Color(255, 0, 204));

jLabel1.setFont(new java.awt.Font("Viner Hand ITC", 1, 18)); // NOI18N

jLabel1.setForeground(new java.awt.Color(0, 153, 51));
jLabel1.setText(" Ant Colony Optimization for Software Project Scheduling and Staffing
with an Event-Based Scheduler");

63

jLabel2.setIcon(new javax.swing.ImageIcon(getClass().getResource("/download.jpg")));
// NOI18N
jLabel2.setText("jLabel2");

jLabel3.setFont(new java.awt.Font("Viner Hand ITC", 3, 24)); // NOI18N

jLabel3.setForeground(java.awt.Color.red);
jLabel3.setText("Client Login");

jLabel4.setFont(new java.awt.Font("Viner Hand ITC", 1, 18)); // NOI18N

jLabel4.setForeground(new java.awt.Color(28, 124, 24));
jLabel4.setText("User Name :");

jTextField1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField1ActionPerformed(evt);
}
});

jLabel5.setFont(new java.awt.Font("Viner Hand ITC", 3, 18)); // NOI18N

jLabel5.setForeground(new java.awt.Color(0, 153, 0));
jLabel5.setText("Password :");

jTextField2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jTextField2ActionPerformed(evt);
}
});

64

jButton1.setText("jButton1");

jButton2.setFont(new java.awt.Font("Viner Hand ITC", 2, 18)); // NOI18N

jButton2.setForeground(new java.awt.Color(51, 153, 0));
jButton2.setText("Login");
jButton2.addActionListener(new java.awt.event.ActionListener()
{ public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton2ActionPerformed(evt);
}
});

javax.swing.GroupLayout jPanel1Layout = new

javax.swing.GroupLayout(jPanel1); jPanel1.setLayout(jPanel1Layout);
jPanel1Layout.setHorizontalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel1Layout.createSequentialGroup()
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADI
NG)
.addGroup(jPanel1Layout.createSequentialGroup()
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADI
NG)
.addGroup(jPanel1Layout.createSequentialGroup()
.addGap(642, 642, 642)
.addComponent(jButton1))
.addGroup(jPanel1Layout.createSequentialGroup()

65

.addGap(114, 114, 114)

.addComponent(jLabel2, javax.swing.GroupLayout.PREFERRED_SIZE,
281, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(207, 207, 207)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADI
NG, false)

.addComponent(jLabel5, javax.swing.GroupLayout.DEFAULT_SIZE,
134, Short.MAX_VALUE)
.addComponent(jLabel4, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADI
NG, false)

.addComponent(jTextField1)
.addComponent(jTextField2,
javax.swing.GroupLayout.DEFAULT_SIZE, 164, Short.MAX_VALUE))))
.addGap(0, 0, Short.MAX_VALUE))
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel1Layout.createSequentialGroup()
.addContainerGap()
.addComponent(jLabel1, javax.swing.GroupLayout.DEFAULT_SIZE, 1005,
Short.MAX_VALUE)))
.addContainerGap())
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel1Layout.createSequentialGroup()
.addGap(0, 0, Short.MAX_VALUE)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADI
NG)

66

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel1Layout.createSequentialGroup()
.addComponent(jLabel3, javax.swing.GroupLayout.PREFERRED_SIZE, 210,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(163, 163, 163))
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
jPanel1Layout.createSequentialGroup()
.addComponent(jButton2, javax.swing.GroupLayout.PREFERRED_SIZE, 84,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(158, 158, 158))))
);
jPanel1Layout.setVerticalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(jPanel1Layout.createSequentialGroup()
.addGap(39, 39, 39)
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 68,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(97, 97, 97)
.addComponent(jLabel3, javax.swing.GroupLayout.PREFERRED_SIZE, 71,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADI
NG)
.addComponent(jLabel2)
.addGroup(jPanel1Layout.createSequentialGroup()
.addGap(53, 53, 53)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASEL
INE)

67

.addComponent(jLabel4, javax.swing.GroupLayout.PREFERRED_SIZE,
37, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jTextField1,
javax.swing.GroupLayout.PREFERRED_SIZE, 28,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(18, 18, 18)
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASEL
INE)
.addComponent(jLabel5, javax.swing.GroupLayout.PREFERRED_SIZE,
37, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jTextField2,
javax.swing.GroupLayout.PREFERRED_SIZE, 29,
javax.swing.GroupLayout.PREFERRED_SIZE))))
.addGap(2, 2, 2)
.addComponent(jButton2, javax.swing.GroupLayout.PREFERRED_SIZE, 34,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(547, 547, 547)
.addComponent(jButton1)
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))
);
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
68

.addGroup(layout.createSequentialGroup()
.addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE, 636,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(0, 0, Short.MAX_VALUE))
);
pack();
}// </editor-fold>
private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}
private void jTextField2ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt)
{ // TODO add your handling code here:
String name=jTextField1.getText();
String pwd=jTextField2.getText();

if(name.equalsIgnoreCase("client") && pwd.equalsIgnoreCase("client"))

{
ClientHome ch=new ClientHome();
ch.show();
}
}

/**
* @param args the command line arguments
*/

69

public static void main(String args[]) {

/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName()))
{ javax.swing.UIManager.setLookAndFeel(info.getClassName(
)); break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(Client.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(Client.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(Client.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(Client.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);
}
//</editor-fold>
/* Create and display the form */

70

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new Client().setVisible(true);
}
});
}

/Variables declaration - do not modify

private javax.swing.JButton
jButton1; private
javax.swing.JButton jButton2;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JPanel jPanel1;

private javax.swing.JTextField jTextField1;

private javax.swing.JTextField jTextField2;
/
}

End of variables declaration

71

DATABASECONNECTION.JAVA
package databaseconnection; import
java.sql.*;

public class databasecon

{
static Connection con;
public static Connection getconnection()
{
try
{
Class.forName("com.mysql.jdbc.Driver");
con =
DriverManager.getConnection("jdbc:mysql://localhost:3306/antcolony","root","root");
}
catch(Exception e)
{
System.out.println("class error");
}
return con;
}

72

8. SCREEN SHOTS

Fig No: 8.1: This screen shot shows that as soon as the program is started the client tries to
login and enter his tasks.

73

This Screen shot describes in this way the client enter his details to login.

74

Fig No: 8.2 This Screen shot show the page in which client select to enter his requirement.

75

Fig No: 8.3 This Screen shot shows how client enters his requirement and duration of time for the
project completion.

76

This Screen shot illustrates that the client can also enter other requirement of start the work.

77

Fig No: 8.4 This Screen shot represents that after the client enter his requirements the admin login and
start the work of the client.

78

Fig No: 8.5 This Screen shot shows that an admin area can perform various number of tasks.

79

Fig No: 8.6 This Screen shot shows the number of tasks handling in a company.

80

Fig No: 8.7 This Screen shot tells us that number people working on a particular project and the
person details and specifications.

81

Fig No: 8.8 This Screen shot represents the current project working in a company.

82

Fig No: 8.9 This Screen shot illustrates the assigned modules on the project.

83

This Screen shot draws an information about the admin tasks and the admin can use his tasks in
any order.

84

This Screen shot show how the current project will start working.

85

This Screen shot describes that a particular employee is assigned mainly to the project.

86

Fig No: 8.10 This Screen shot represents that the admin can recruit employee.

87

Fig No: 8.11 This Screen shot we can notice that the employee details are entered when the selection
process is taken place.

88

This Screen shot show that when in consistent details are entered the window wont accept the details.

89

Fig No: 8.12 This Screen shot the employee tries to login with his username and password.

90

This Screen shot it shows that the employee can view his tasks and change his details.

91

This Screen shot describes the employee want to view the tasks.

92

This Screen shot tells us that the information is not accepted when the modules are re-assigned.

93

Fig No: 8.13 This Screen shot describes that project details are kept on track and the
assigned modules start their work.

94

This Screen shot tells us that a module is starting the project.

95

This Screen shot describes that the project working can be viewed.

96

This Screen shot shows that how much amount of project working is completed and how much
amount of work is to be completed.

97

9. CONCLUSION
A new method for solving the software project planning problem has been developed.
The main characteristics of the proposed method are in two aspects. First, the method
introduces an event-based scheduler. Second, the method takes advantage of ACO to solve the
complicated planning problem. Experimental results show that the representation scheme
with the EBS is effective, and the proposed algorithm manages to yield better plans with
lower costs and more stable workload assignments compared with other existing approaches.

98

10. FUTURE ENHANCEMENT

In future research, it will be interesting to consider employee experience and the

training model [6] to make the considered problem more comprehensive. Including
uncertainty treatment in the software project planning model is also a promising research
topic. In addition, since the model proposed in this paper provides a flexible and effective
way for managing human resources, it is promising to apply the proposed approach to other
complex human-centric projects like consulting projects.

99

11.REFERENCES
[1] N. Nan and D.E. Harter, Impact of Budget and Schedule Pressure on Software
Development Cycle Time and Effort, IEEE Trans. Software Eng., vol. 35, no. 5, pp. 624637, Sept./Oct. 2009.
[2] J. Duggan, H. Byrne, and G.J. Lyons, A Task Allocation Optimizer for Software
Construction, IEEE Software, vol. 21, no. 3, pp. 76-82, May/June 2004.
[3] R.-G. Ding and X.-H. Jing, Five Principles of Project Management

in Software

Companies, Project Management Technology (in Chinese), vol. 1, 2003.

[4] A. Barreto, M. de O. Barros, C.M.L. Werner, Staffing a Software Project: A
Constraint Satisfaction and Optimization-Based approach, Computers & Operations
Research, vol. 35, pp. 3073-3089, 2008.
[5] E. Alba and J.F. Chicano, Software Project Management with GAs, Information
Sciences, vol. 177, pp. 2380-2401, 2007.
[6] C.K. Chang, H. Jiang, Y. Di, D. Zhu, and Y. Ge, Time-Line Based Model for Software
Project Scheduling with Genetic Algorithms, Information and Software Technology, vol. 50,
pp. 1142-1154, 2008.
[7] B. Boehm, Software Engineering Economics. Prentice-Hall, 1981.
[8] B. Boehm et al., Software Cost Estimation with COCOMO II. Prentice-Hall, 2000. CHEN
AND ZHANG: ANT COLONY OPTIMIZATION FOR SOFTWARE PROJECT
SCHEDULING AND STAFFING WITH AN EVENT-BASED... 15
Fig. 8. Analysis of the local refinement steps on the instance j301_1.

Fig. 7. Comparison between the structures of the solutions built by different algorithms.
[9] A. Shtub, J.F. Bard, and S. Globerson, Project Management: Processes,
Methodologies, and Economics, second ed. Prentice Hall, 2005.
[10]

P. Brucker, A. Drexl, R. Mohring, K. Neumann, E. Pesch, Resource-

Constrained Project Scheduling: Notation, Classification, Models and Methods

100

10
1