JOB Portal Project Report
JOB Portal Project Report
PROJECT REPORT
ON
“ONLINE JOB PORTAL”
SUBMITTED IN THE PARTIAL FULFILLMENT OF THE REQUIREMENTS
OF
Session (2021-2023)
OF
Session (2021-2023)
Primarily, I would like to thank my faculty members for giving me the opportunity
influence, some way, in my motivation and gratefulness for being part of the
responsible project guide of the institute. I am very thankful to him for his valuable
I wish to thank my parents for their constant encouragement which is like snow, so
after when it falls and longer when it falls and longer when it dwells upon, the
So, my heart full thanks to all friends mainly who supported and encouraged me in
ZUBER AALAM
MCA IV SEM
ROLL NO. 2102820140032
DECLARATION
This is to be certify that this Project Report entitled “ONLINE JOB PORTAL”
my supervision.
The matter embodied in this Project Work has not been submitted earlier for award
and belief.
Date: __/__/____
TABLE OF CONTENTS
1 INTRODUCTION………………………………………………………………1-2
1.3 Definitions…...….…………………………………………………………….........2
2. REQUIREMENTS ANALYSIS........................................................................3-20
3. FEASIBILITY STUDY....................................................................................21-24
4. SYSTEM DESIGN...........................................................................................25-54
4.1 INTRODUCTION..................................................................................................... 25
4.4 ER Diagram…………………………………………………………………………42
6. TESTING..........................................................................................................79-82
7.1 IMPLEMENTATION..................................................................................................85
7.2 Maintenance..................................................................................................... 86
7.3 Cost Estimation Of The Projcrt........................................................................89
8. BIBLIOGRAPHY..................................................................................................94
CHAPTER 1
INTRODUCTION
Online job portal is a web application built in java. It provides the candidates ability to
register to this application and search for jobs, manage their accounts. Each candidate
will have their own account with their own home page.
On the other hand companies that are willing to publish the jobs for their company to
candidates can register to the job portal and get their own account created and can
post jobs to portal’s database .
Registered companies can add or remove jobs and these jobs can be seen by various
candidates and they can contact the company person for the job. Main aim of this
web application is to make a good web application that can make this job search
option easy and accessible to everyone who are interested.
1.2 MODULES
1. Admin.
2. Job Seekers.
3. Companies
This system enables the Recruiting company to login to the system and create a
vacancy and post it on the web. The Recruiting company can associate jobseekers with a
vacancy and Schedule the interview. He is able to search on jobseeker number and
Vacancy number.
This system enables the jobseekers to login, to view all the vacancies and to view
the applicant and vacancy details. He is also able to search on interview date, number and
vacancy number.
The Job Seekers can register and create a profile. He/She can search and apply for
jobs online. He could view his interview details and application status.
Requirement Analysis
3. Gauging how the end-users would operate the system (in terms of general
experience in using computer hardware or software), what the system would be
used for etc.
Another view outlines a phased approach to the process. This approach breaks systems
analysis into 5 phases:
Scope definition
Problem analysis
Requirements analysis
Logical design
Decision analysis
Use case are a widely-used systems analysis modeling tool for identifying and
expressing the functional requirements of a system. Each use case is a business scenario or
event for which the system must provide a defined response. Use cases evolved out of
object-oriented analysis.
Information gathering is usually the first phase of the software development project.
The purpose of this phase is to identify and document the exact requirements for the
system. The user’s request identifies the need for a new information system and on
investigation re-defined the new problem to be based on MIS, which supports
management. The objective is to determine whether the request is valid and feasible before
a recommendation is made to build a new or existing manual system continues.
1. JDK 1.7
NetBeans 7.0.1
2. Database
MySQL Database Server 5.1.37
3. Web Server
Tomcat 7.0.14
4. Application Server
GlassFish v3.1
5. Operating System
Windows 7 / Vista / XP sp3 / Linux Fedora 14
1. Presentation Layer
Swing
2. Database Layer
SQL
3. Business Layer
Exception Handling
Multithreading
Collections Framework
JDBC (Java Database Connectivity)
Servlets
JSP (Java Server Pages)
HTML Documents
CSS
HTML tags were originally designed to define the content of a document. They were
supposed to say "This is a header", "This is a paragraph", "This is a table", by using tags
like <h1>, <p>, <table>, and so on. The layout of the document was supposed to be taken
care of by the browser, without using any formatting tags.
As the two major browsers - Netscape and Internet Explorer - continued to add new HTML
tags and attributes (like the <font> tag and the color attribute) to the original HTML
specification, it became more and more difficult to create Web sites where the content of
HTML documents was clearly separated from the document's presentation layout.
To solve this problem, the World Wide Web Consortium (W3C) - the non profit, standard
setting consortium, responsible for standardizing HTML - created STYLES in addition to
HTML 4.0.
Styles sheets define HOW HTML elements are to be displayed, just like the font tag and
the color attribute in HTML 3.2. Styles are normally saved in external .css files. External
style sheets enable you to change the appearance and layout of all the pages in your Web,
just by editing one single CSS document.
JavaScript
JavaScript is used in millions of Web pages to improve the design, validate forms, detect
browsers, create cookies, and much more. JavaScript is the most popular scripting
language on the internet, and works in all major browsers, such as Internet Explorer,
Firefox, and Opera.
Scripts in the head section: Scripts to be executed when they are called, or when an event
is triggered, go in the head section. When you place a script in the head section, you will
ensure that the script is loaded before anyone uses it.
Scripts in the body section: Scripts to be executed when the page loads go in the body
section. When you place a script in the body section it generates the content of the page.
Using an External JavaScript: When you might want to run the same JavaScript on
several pages, without having to write the same script on every page, then you can write a
JavaScript in an external file. Save the external JavaScript file with a .js file extension. The
external script cannot contain the <script> tag. To use the external script, point to the J1.js
file in the "src" attribute of the <script> tag:
Java Technology
The Java programming language is a high-level language that can be characterized by all
of the following characteristics
Simple
Object oriented
Distributed
Multithreaded
Architecture neutral
Portable
High performance
Robust
In the Java programming language, all source code is first written in plain text files ending
with the .java extension. Those source files are then compiled into .class files by the javac
compiler. A .class file does not contain code that is native to your processor; it instead
contains bytecodes — the machine language of the Java Virtual Machine1 (Java VM). The
java launcher tool then runs your application with an instance of the Java Virtual Machine.
An overview of the software development process.
Because the Java VM is available on many different operating systems, the same .class
files are capable of running on Microsoft Windows, the Solaris TM
Operating System
(Solaris OS), Linux, or Mac OS. Some virtual machines, such as the Java HotSpot virtual
machine, perform additional steps at runtime to give your application a performance
boost.
The API is a large collection of ready-made software components that provide many useful
capabilities. It is grouped into libraries of related classes and interfaces; these libraries are
known as packages.
The API and Java Virtual Machine insulate the program from the
underlying hardware.
Every full implementation of the Java platform gives you the following features:
Development Tools: The development tools provide means for compiling, running,
debugging, and documenting your applications. The main tools are the javac
compiler, the java launcher, and the javadoc documentation tool.
Application Programming Interface (API): The API provides the core
functionality of the Java programming language. It offers a wide array of useful
classes ready for use in your own applications. It spans everything from basic
objects, to networking and security, to XML generation and database access, etc.
Deployment Technologies: The JDK software provides standard mechanisms such
as the Java Web Start software and Java Plug-In software for deploying your
applications to end users.
User Interface Toolkits: The Swing and Java 2D toolkits make it possible to
create sophisticated Graphical User Interfaces (GUIs).
Integration Libraries: Integration libraries such as the Java IDL, JDBC, JNDI,
Java RMI, and Java Remote Method Invocation over Internet Inter-ORB Protocol
Technology (Java RMI-IIOP Technology) enable database access and manipulation
of remote objects.
Java - Exception Handling
When an error occurs within a method, the method creates an object and hands it
off to the runtime system. The object, called an exception object, contains information
about the error, including its type and the state of the program when the error occurred.
Creating an exception object and handing it to the runtime system is called throwing an
exception.
The runtime system searches the call stack for a method that contains a block of
code that can handle the exception. This block of code is called an exception handler. The
search begins with the method in which the error occurred and proceeds through the call
stack in the reverse order in which the methods were called. When an appropriate handler
is found, the runtime system passes the exception to the handler. An exception handler is
considered appropriate if the type of the exception object thrown matches the type that can
be handled by the handler.
The exception handler chosen is said to catch the exception. If the runtime system
exhaustively searches all the methods on the call stack without finding an appropriate
exception handler, as shown in the next figure, the runtime system (and, consequently, the
program) terminates.
A program can catch exceptions by using a combination of the try, catch, and
finally blocks.
The try block identifies a block of code in which an exception can occur.
The catch block identifies a block of code, known as an exception handler, that can
handle a particular type of exception.
The finally block identifies a block of code that is guaranteed to execute, and is the right
place to close files, recover resources, and otherwise clean up after the code enclosed in the
try block.
Java – Multithreading
Threads are called lightweight processes. Threads exist within a process — every
process has at least one. Threads share the process's resources, including memory and open
files. This makes for efficient, but potentially problematic, communication.
Each thread is associated with an instance of the class Thread. There are two
basic strategies for using Thread objects to create a concurrent application.
To directly control thread creation and management, simply instantiate Thread each
time the application needs to initiate an asynchronous task.
To abstract thread management from the rest of your application, pass the
application's tasks to an executor.
Java - JDBC
The JDBC API is a Java API that can access any kind of tabular data, especially
data stored in a Relational Database.
JDBC helps you to write java applications that manage these programming activities:
The JDBC API supports both two-tier and three-tier processing models for database
access.
In the two-tier model, a Java application talks directly to the data source. This requires a
JDBC driver that can communicate with the particular data source being accessed. A user's
commands are delivered to the database or other data source, and the results of those
statements are sent back to the user. The data source may be located on another machine to
which the user is connected via a network. This is referred to as a client/server
configuration, with the user's machine as the client, and the machine housing the data
source as the server.
In the three-tier model, commands are sent to a "middle tier" of services, which then sends
the commands to the data source. The data source processes the commands and sends the
results back to the middle tier, which then sends them to the user. MIS directors find the
three-tier model very attractive.
Figure 2: Three-tier Architecture for Data Access.
Web Components
Java web components are either servlets or pages created using JSP technology (JSP
pages).
Servlets are Java programming language classes that dynamically process requests and
construct responses.
JSP pages are text-based documents that execute as servlets but allow a more natural
approach to creating static content.
The web tier might include a JavaBeans component to manage the user input and
send that input to enterprise beans running in the business tier for processing, as shown:
Business Components
Business code, which is logic that solves or meets the needs of a particular business
domain is handled by enterprise beans running in the business tier.
Following figure shows how an enterprise bean receives data from client programs,
processes it (if necessary), and sends it to the enterprise information system tier for storage.
An enterprise bean also retrieves data from storage, processes it (if necessary), and sends it
back to the client program:
Enterprise JavaBeans Technology
There are two kinds of enterprise beans: session beans and message-driven beans.
A session bean represents a transient conversation with a client. When the client finishes
executing, the session bean and its data are gone. A message-driven bean combines
features of a session bean and a message listener, allowing a business component to
receive messages asynchronously. Commonly, these are Java Message Service (JMS)
messages.
Java servlet technology lets you define HTTP-specific servlet classes. A servlet
class extends the capabilities of servers that host applications that are accessed by way of a
request-response programming model. Although servlets can respond to any type of
request, they are commonly used to extend the applications hosted by web servers.
Feasibility Study
The following is the process diagram for feasibility analysis. In the diagram,
the feasibility analysis starts with the user set of requirements. With this, the existing
system is also observed. The next step is to check for the deficiencies in the existing
system. By evaluating the above points a fresh idea is conceived to define and quantify the
required goals. Besides that, a set of alternatives and their feasibility is also considered in
case of any failure in the proposed system. Thus, feasibility study is an important part in
software development.
PROCESS DIAGRAM FOR FEASIBILITY ANALYSIS
In the SDLC (Systems Development Life Cycle) of our project we maintained a number
of feasibility checkpoints between the two phases of the SDLC.
Technical feasibility determines whether the work for the project can be
done with the existing equipment, software technology and available personnel. Technical
feasibility is concerned with specifying equipment and software that will satisfy the user
requirement.
This project is feasible on technical remarks also, as the proposed system is
more beneficiary in terms of having a sound proof system with new technical components
installed on the system. The proposed system can run on any machines supporting
Windows and Internet services and works on the best software and hardware that had
been used while designing the system so it would be feasible in all technical terms of
feasibility. The technologies such as JAVA (JSP, Servlet), JavaScript and the compatible
H/Ws are so familiar with the today’s knowledge based industry that anyone can easily be
compatible to the proposed environment.
The technologies used are matured enough so that they can be applied to
our problems. The practicality of the solution we have developed is proved with the use of
the technologies we have chosen. The technologies such as JAVA (JSP, Servlet),
JavaScript and the compatible H/Ws are so familiar with the today’s knowledge based
industry that anyone can easily be compatible to the proposed environment.
We first make sure that whether the required technologies are available to
us or nor. If they are available then we must ask if we have the capacity. For instance,
“Will our current Printer be able to handle the new reports and forms required of a new
system?
We classified the costs of Online job portal according to the phase in which
they occur. As we know that the system development costs are usually one-time costs that
will not recur after the project has been completed. For calculating the Development costs
we evaluated certain cost categories viz.
Payback analysis
Return on Investment:
Net Present value
Cost-based study: It is important to identify cost and benefit factors, which can be
categorized as follows: 1. Development costs; and 2. Operating costs. This is an
analysis of the costs to be incurred in the system and the benefits derivable out of the
system.
Time-based study: This is an analysis of the time required to achieve a return on
investments. The future value of a project is also a factor.
People are inherently resistant to change and computers have been known to
facilitate change. There is always some reluctance among the users against the introduction
of new system but they were told that this system would eliminate the unnecessary
overhead of database migration and conversion, which presently had to be carried out on
daily basis to facilitate transactions between the different departments. The objective this
feasibility phase is to take the operational staff into confidence. As the success of a good
system depends upon the willingness of the operating staff, they were taken into full
confidence that the new proposed system would make their jobs easier, relieve them from
the unnecessary overheads and reduce the possibility of errors creeping into the system.
CHAPTER 4
SYSTEM DESIGN
4.1 Introduction
After the analysis phase we have with us the details of the existing system and
the requirements of the user for the new system. This phase diverts focus from the problem
domain to the solution domain. It acts as a bridge between the requirement phase and its
solution. The design phase focuses on the detailed implementation of the system
recommended in the feasibility study.
Systems design is the process or art of defining the architecture, components,
modules, interfaces, and data for a system to satisfy specified requirements. There is some
overlap with the disciplines of systems analysis, systems architecture and systems
engineering.
Object-oriented analysis and design (OOAD) methods are becoming the most
widely used methods for computer system design. The UML has become the standard
language used in Object-oriented analysis and design. It is widely used for modeling
software systems and is increasingly used for high designing non-software systems and
organizations.
Physical design
The physical design relates to the actual input and output processes of the
system. This is laid down in terms of how data is input into a system, how it is
verified/authenticated, how it is processed, and how it is displayed as output.
Physical design, in this context, does not refer to the tangible physical design of
an information system. To use an analogy, a personal computer's physical design involves
input via a keyboard, processing within the CPU, and output via a monitor, printer, etc. It
would not concern the actual layout of the tangible hardware, which for a PC would be a
monitor, CPU, motherboard, hard drive, modems, video/graphics cards, USB slots, etc.
Level 0(Context-Level)
Level 1(User)
Level 1(Company)
Level 1(Admin)
Level 2(User)
Level 2(Company)
Level 2(Admin)
ER Diagram
4.3 DATABASE DESIGN
BIRTH
OF USER
OF COLLEGE
NAME
RESUME
4. Table Name: INTERVIEW CALL : -
EMAIL
5. Table Name: : -JOB POST
REQUIRED
POSTING
COMPANY.
FEEDBACK
SENDER
EVENT
REQUIRED
QUESTION 1
SEQURITY
QUESTION 1
QUESTION 2
SEQURITY
QUESTION 2
COMPANY
OF COMPANY
POSTING
COMPANY
COMPANY
COMPANY
CODE DESIGN
Code design for the system follows the following pattern. The java programs for the accessing the
database server consists of functions that retrieve data and return that data in the required format.
These java functions are put into classes. These classes are identified by the module which they
service. The classes are all part of a package. This package is used in the JSP scripting to declare
objects of a particular class. Once the objects have been declared, the functions of that object can
be easily accessed by a normal “objectName.functionName” kind of call to it. The function
performs the necessary tasks and then returns the data to the JSP script. The web server then
processes these data and prepares an HTML file to be displayed to the user. This process is
depicted in the figure.
DATABASE SERVER
Login Servlet:
package project;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class Login extends HttpServlet
{
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet Login</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Servlet Login at " + request.getContextPath() + "</h1>");
out.println("</body>");
out.println("</html>");
}
catch(Exception e)
{
out.println("exception in register servlet "+e);
}
finally
{
out.close();
}
}
package project;
import java.sql.Connection;
import java.sql.DriverManager;
public class Dbconnect
{
public static Connection con=null;
public static Connection getConnect()
{
try
{
Class.forName("com.mysql.jdbc.Driver");
con=DriverManager.getConnection("jdbc:mysql://localhost:3306
/jobs","root","root");
}
catch(Exception e)
{
System.out.println("EXCEPTION IN CONNECT :- "+e);
}
return con;
}
}
package project;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class jobpost extends HttpServlet
{
protected void processRequest(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException
{
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
String driver="com.mysql.jdbc.Driver";
String url="jdbc:mysql://localhost:3306/";
String database="jobs";
String username="root";
String pass="root";
String profile=request.getParameter("profile");
String id=request.getParameter("jobid");
String email=request.getParameter("email");
String company=request.getParameter("company");
String place=request.getParameter("place");
String experience=request.getParameter("experience");
String salary=request.getParameter("salary");
String day=request.getParameter("day");
String month=request.getParameter("month");
String year=request.getParameter("year");
String industry=request.getParameter("industry");
String details=request.getParameter("description");
String date= day + "-" + month + "-" + year;
String insertquery="INSERT INTO jobs.jobpost (profile, id, company, place,
experience, salary, `date`, description, industry, email) VALUES ('"+profile+"', '"+id+"',
'"+company+"','"+place+"','"+experience+"','"+salary+"','"+date+"','"+details+"','"+industry
+"','"+email+"')";
try
{
Connection c=Dbconnect.getConnect();
Statement st=c.createStatement();
st.executeUpdate(insertquery);
RequestDispatcher rdp=request.getRequestDispatcher("sucjobpost.jsp");
rdp.forward(request,response);
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet register</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Servlet register at " + request.getContextPath() + "</h1>");
out.println("</body>");
out.println("</html>");
}
catch(Exception e)
{
out.println("Exception : " + e);
}
finally {
out.close();
}
}
}
package project;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class editaccount extends HttpServlet
{
protected void processRequest(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException
{
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
String driver="com.mysql.jdbc.Driver";
String url="jdbc:mysql://localhost:3306/";
String database="jobs";
String username="root";
String pass="root";
String mail=request.getParameter("mail");
String email=request.getParameter("email");
String firstname=request.getParameter("firstname");
String lastname=request.getParameter("lastname");
String location=request.getParameter("location");
String mobileno=request.getParameter("mobileno");
String address=request.getParameter("address");
String gender=request.getParameter("gender");
String industry=request.getParameter("industry");
String function=request.getParameter("function");
String skills=request.getParameter("skills");
try {
/*
* TODO output your page here. You may use following sample code.
*/
Connection c=Dbconnect.getConnect();
Statement st=c.createStatement();
Statement st1=c.createStatement();
st.executeUpdate(modquery);
st1.executeUpdate(mod);
HttpSession ses=request.getSession();
ses.setAttribute("email", email);
RequestDispatcher rdp=request.getRequestDispatcher("Home.jsp");
rdp.forward(request, response);
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet register</title>");
out.println("</head>");
out.println("<body>");
out.println("email: " + mail + "<br/>");
out.println("<h1>Servlet register at " + request.getContextPath() + "</h1>");
out.println("</body>");
out.println("</html>");
}
catch(Exception e)
{
out.println("Exception : " + e);
}
finally {
out.close();
}
}
}
CHAPTER 10
TESTING
Black box testing method was used for system testing. The black box testing
usually demonstrates that software functions are operational; that the input is properly
accepted and the output is correctly produced; and that integrity of external information
(databases) is maintained.
Causes of Errors
Communication gap between the developer and the business decision maker: A
communication gap between the developer and the business decision maker is normally
due to subtle differences between them. The differences can be classified into five
broad areas: Thought process, Background and Experience, Interest, Priorities,
Language.
Time provided to a developer to complete the project: A common source of errors
in projects comes from time constraints in delivering a product. To keep to the
schedule, features can be cut. To keep the features, the schedule can be slipped. Failing
to adjust the feature set or schedule when problems are discovered can lead to rushed
work and flawed systems.
Over Commitment by the developer: High enthusiasm can lead to over commitment
by the developer. In these situations, developers are usually unable to adhere to
deadlines or quality due to lack of resources or required skills on
the team.
Insufficient testing and quality control: Insufficient testing is also a major source of
breakdown of e-commerce systems during operations, as testing must be done during
all phases of development.
Inadequate requirements gathering: A short time to market results in developers
starting work on the Web site development without truly understanding the business
and technical requirements. Also, developers may create client-side scripts using
language that may not work on some client browsers.
Keeping pace with the fast changing Technology: New technologies are constantly
introduced. There may not be adequate time to develop expertise in the new
technologies. This is a problem for two reasons. First, the technology may not be
properly implemented. Second, the technology may not integrate well with the existing
environment.
Testing Principles
Kinds of Testing:
Black Box Testing- Not based on any knowledge of internal designs or code. Tests are
based on requirements and functionality.
White Box Testing- Based on the knowledge of the internal logic of an application’s code.
Tests are based on coverage of code statements, branches, paths and statements.
Unit Testing- The most ‘micro’ scale of testing; to test particular functions and code
modules. Typically done by the programmer and not by the testers, as it requires detailed
knowledge of the internal program design and code. Not always easily done unless the
application has a well-designed architecture with tight code; may require developing test
driver modules or test harnesses.
Acceptance Testing- Final testing based on the specifications of the end user or customer
or based on use by end-users/ customers over some limited period of time.
Unit The various functions within each program and the program blocks are
tested for proper working.
Testing
Integration Testing Integration testing is done to test the functionality and interfacing
between the modules.
Top-Down Implementation: -
Top down implementation begins with the user-invoked module and works
toward the modules that do not call any other modules. The implementation may precede
depth-first or breadth-first.
Bottom-Up Implementation: -
Implementation begins with modules that do not call any other modules and
works toward the main program. Test harness (see below) is used to test individual
modules. The main module constitutes the final test harness.
Stub Programming:
Stub programming is the implementation analogue of top-down and stepwise refinement. It
supports incremental program development by allowing forerror and improvement. A stub
program is a stripped-down, skeleton version of a final program. It doesn't implement
details of the algorithm or fulfill all the job requirements. However, it does contain rough
versions of all subprograms and their parameter lists. Furthermore, it can be compiled and
run. Extensive use of procedures and parameter are the difference between stub programs
and prototypes. Quick and dirty prototypes should be improved--they should be rewritten.
A stub program helps demonstrates that a program's structure is plausible. Its procedures
and functions are unsophisticated versions of their final forms, but they allow limited use of
the entire program. In particular, it may work for a limited data set. Often the high-level
procedures are ready to call lower-level code, even if the more detailed subprograms
haven't even been written. Such sections of code are commented out. The comment
brackets can be moved, call-by-call, as the underlying procedures are actually written.
Once the software is delivered and deployed, then maintenance phase starts.
Software requires maintenance because there are some residual errors remaining in the
system that must be removed as they discovered. Maintenance involves understanding the
existing software (code and related documents), understanding the effect of change, making
the changes, testing the new changes, and retesting the old parts that were not changed. The
complexity of the maintenance task makes maintenance the most costly activity in the life
of software product.
It is believed that almost all software that is developed has residual errors, or bugs, in them.
These errors need to be removed when discovered that leads to the software change. This is
called Corrective Maintenance. Corrective maintenance means repairing, processing or
performance failures or making alterations because of previously ill-defined problems.
Software undergoes change frequently even without bugs because the software must be
upgraded and enhanced to include more features and provide more services. This also
requires modification of the software. The changed software changes the environment,
which in turn requires further change. This phenomenon is called the “law of software
evaluation”. Maintenance due to this phenomenon is called adaptive maintenance.
Adaptive maintenance means changing the program function. Perfect maintenance means
enhancing the performance or modifying the programs according to the user’s additional or
changing needs. The keys to reduce the need for maintenance are:
X
Feasibility Requirement System Detailed Coding and Accepted
Analysis Design Design Testing Software
4.5
4
3.5
3
2.5
2
1.5
1
0.5
0
Feasibility Req. Ana. Sys. Des. Det. Des. Code & T. Accep.
S/w
Design 30%
Coding 50%
The cost of correcting errors of different phases is not the same and depends on when the
error is detected and corrected.
One can perform cost estimation at any point in the software life cycle. As the
cost of the project depends on the nature and characteristics of the project, at any point, the
accuracy of the estimate will depend on the amount of reliable information we have about
the final product. The figure depicted below shows the accuracy of the cost estimation.
On Size estimation of Schedule and Cost of the Project: this approach implies
that size is the primary factor for cost; other factors have lesser effect. Here we will discuss
one such model called the Constructive Cost Model (COCOMO) developed by Boehm.
This model also estimates the total effort in terms of person-months of the technical project
staff. The basic steps of this model are as follows: -
Obtain the initial estimate of the development effort from the estimate of
thousands of delivered lines of source code (KDLOC).
Determine a set of multiplying factors from different attributes of the
project.
Adjust the effort estimate by multiplying the initial estimate with all the
multiplying factors.
The initial estimate also called nominal estimate is determined by an equation of
the form used in the static single-variable models, using KDLOC as the measure of size. To
determine the initial effort Ei in person-months the equation used is of the type
Ei = a*(KDLOC)b
In COCOMO model the values of constants a and b are different with different
type of projects. As our project is Organic type the values of a and b are 3.2 and 1.05
respectively. The total thousand delivered code (KDLOC) of our system has been estimated
as around 2.
Now the final efforts estimate, E, of our project is obtained by multiplying the initial
estimate by the EAF.
i.e., E = EAF*Ei
The project duration is estimated for an Organic project by the formula
D = 2.5 * E0.38 .
13. BIBLIOGRAPHY
The following books were used extensively for the project development and implementation.
1. Chuck Musciano and Bill Kennedy (1998) “HTML: The Definitive Guide” O’Reilly &
Associates Ltd
2. George Koch and Kevin Loney. (1997) “Oracle 8, The Complete Reference” Oracle Press
Edition.
3. Herbert Schildt (2001) “The Complete Java Reference” Tata McGraw-Hill Publishing
Company Limited.
4. Marty Hall (2000) “Core Servlets and JavaServer Pages” Sun MicroSystem Press.
5. Matthew Siple. (1998) “The Complete Guide to Java Database Programming” Tata
McGraw-Hill Publishing Company Limited.
6. Roger S. Pressman (1997) “Software Engineering, A Practitioner’s Approach” Tata
McGraw-Hill Publishing Company Limited.
7. Professional JSP, Wrox Publications.
The following Links were searched and exploited extensively for the project development and
implementation.
1. http://java.sun.com/products/jsp
2. http://www.roseindia.com