The Software Development

offbeatnothingSoftware and s/w Development

Dec 2, 2013 (3 years and 4 months ago)


The Software Development

Life Cycle

Today We Will:

Go over the different phases of the software
development life cycle.

Introduce the various tools used in each phase.
These tools will be the focus of the course.

Break up into teams to discuss the presentations
and the final projects.

History of SDLC Models

Once upon a time, software development consisted of a
programmer writing code to solve a problem or automate a

Nowadays, systems are so big and complex that teams of
architects, analysts, programmers, testers and users must
work together to create the millions of lines of custom
written code that drive our enterprises.

Note: There are different types of software development that call
for different development strategies. This class focuses on the
development of large
scale enterprise systems. See pg. 33 in book
to see the differences in software development.

How Software Engineering has

Seven factors that have altered software engineering practice:

Criticality of time
market for commercial products

Shifts in the economics of computing: lower hardware costs
and greater development and maintenance costs

Availability of powerful desktop computing

Extensive local and wide
area networking

Availability and adoption of OO technology

GUI’s using windows, icons, menus and pointers

Unpreditability of the waterfall method of software
development (see. Pg. 49 in book)

To manage this, a number of system development life cycle
(SDLC) models have been created: waterfall, fountain, spiral,
build and fix, rapid prototyping, incremental, and synchronize and

The book covers these models in more detail.

What Is the SDLC?

Definition from ComputerWorld

The software/system development life cycle
(SDLC) is the overall process of developing
information systems through a multi
step process
from investigation of initial requirements through
analysis, design, implementation and maintenance.

There are many different models and
methodologies, but each generally consists of a
series of similar defined steps or stages.

Phases of the SDLC

Feasibility study and project planning.

Requirements definition and systems analysis.

Systems and program design.


Unit testing.

Integration and system testing:

Acceptance, installation, deployment.


Phases of the SDLC

Over the years, one thing that has become apparent to most software
engineers is that requirements grow and change throughout the process
and beyond. They are not static.

This calls for considerable feedback and iterative consultation with the
users. Often you will find the need to go back and reiterate earlier
stages a number of times as the project progresses.

In the SDLC process, some activities obviously can't start before

such as you need a design before you can start coding

there is a considerable overlap between some of the activities.

Many argue that the most effective model for dealing with today’s
systems development is the incremental model.

The incremental model divides the product into builds, where sections
of the project are created and tested separately. This approach will
likely find errors in user requirements quickly, since user feedback is
solicited for each stage and because code is tested sooner after it's

This method also allows many teams to work efficiently in parallel.
Teams can do successive compilations (called builds) of the entire
project, bringing together all the current components.

Tools Used in Phases of SDLC:

Project Planning

Feasibility study and project planning:

In this phase, the project manager establishes a high
level view of the
intended project and determines its goals.

The software engineer uses his/her technical expertise to determine the
feasibility of the desired goals and to give cost/time estimates.

Usually the project manager and the software engineer(s) meet with the
users to generate a high
level project plan. (see pg. 118 in book) Gantt
charts are often used to track progress in the project plan. (see pg. 88)

As requirements are gathered and specific tasks assigned, this project plan
is refined.

Popular tools used in this phase:

Microsoft project is the industry standard for maintaining project
plans. We will not use this tool in class for two reasons:

This phase of the SDLC is really the responsibility of the project
manager, not the software engineer, although sometimes the engineer is
the project manager.

MS project is very expensive.

You can keep track of project plans with other tools (even a word doc).

Tools Used in Phases of SDLC:

Requirements Gathering

Requirements definition and analysis:

In this phase, the SE refines project goals into defined functions and
operations for the intended application. He/she constantly analyzes end
user information needs and transforms this information into models used
by the programmers.

UML is the standard modeling language used for OO system design. It is
a very powerful modeling language and we could spend several semesters
just talking about UML alone. We will only learn the basics.

Popular tools used in this phase:

Rational rose, TogetherJ, EclipseUML.

We will use EclipseUML for several reasons:

It is free, open software that is integrated with the IDE we will use.

It is easier to learn than some of the other tools.

Tools Used in Phases of SDLC:

System and Program Design

System and program design.

System and program design are slightly different.

In system design, the engineer designs the system components and how
they will interact. This includes the presentation layer pieces (e.G. Screen
layouts), the business logic layer pieces (business rules), and the data layer
pieces (data access processes). The SE will determine what technologies
should be used in each layer.

Program design is system design at a finer level. Here the flow and
structure of the actual program code is specified. For example, senior
programmers/analysts will take the UML model and write pseudo
detailing the classes, methods, interfaces, package design, etc. More
junior programmers will take this pseudo
code and transform it into actual
code (e.g. with java).

Popular tools used in this phase:

Visio is a very popular tool for drawing flow charts and etc. For program

Rational rose, TogetherJ, and EclipseUML are excellent resources for
class diagrams. They all have the ability to transform changes to a UML
model into code and vice
versa. We will use EclipseUML for this phase.

Tools Used in Phases of SDLC:



This is where the real code is written based on the system and program

IDE’s (Integrated Development Environments) provide many helpful tools
that assist programmers in this phase of development.

Examples of these views include:

Varying views, debuggers, code completion, code organization, color
schemes, and built
in plug
ins to help with other phases.

Application Servers are needed to run servlets (Java’s version of server
side program). The engineer will write code in the IDE for objects that
will execute in the application server.

Source code repositories are tools used to manage source code among
several developers. They allow developers to check code out (preventing
other developers from modifying that program). They also maintain
version control allowing developers to see what changes were made by
other developers.

Tools Used in Phases of SDLC:

Implementation (cont.)

Popular tools used in this phase:


Eclipse, Visual Café, Visual Age, JDeveloper, Kawa

We are going to use Eclipse, which is shareware from the Jakarta project.
Eclipse is an IDE that has many plug
ins for the other tools we will be using.

Application Servers:

WebLogic, WebSphere, Tomcat

Although WebLogic and WebSphere control most of the market in larger
companies, most smaller companies use Tomcat, which is shareware from the
Jakarta project. All app servers vary in different respects, but almost all work
the same way for basic functionality. So, by learning one, it is easier to learn
the others.

We will use Tomcat because it is an industry standard, it is easier to work with
than most app servers, and it is free.

Source code repository and version control systems

CVS, ClearCase, PVCS, etc.

We are going to use CVS, which is also from the Jakarta project. CVS is an
industry leader in SCM tools and is shareware.

Tools Used in Phases of SDLC:



Testing is an extremely important part of system development. Many companies
have teams dedicated to testing and QA alone.

There are different levels of testing that are needed throughout the SDLC.

Unit testing

This includes the testing of individual components. You have complete control
over the test data and test cases and you run the tests yourself.

Integration testing

In this stage of testing, the SE often collaborate with a small number of other
developers to test the integration of various system components.

System testing.

Brings all the pieces together into a special testing environment, then checks for
errors, bugs and interoperability. These tests are often performed by a QA team.

Popular tools used in this phase:

JUnit is used for unit and integration testing.

This is a very popular tool in the J2EE world. It is free shareware from the Jakarta
project. It has the ability to set up testing plans for individual components including
regression testing.

We will use this for our unit and integration testing.

Tools Used in Phases of SDLC:


Delivery and Deployment

This is the final stage of initial development, where the software is put
into production and runs actual business.

This part of the project is most often done by a build engineer, but
software engineers should be familiar with the deployment tools used by
the build engineer.

The SE will often use the same tool for development and testing.

Popular tools used in this phase:

Ant, Make

We will use Ant, a shareware tool from the Jakarta project.

It is an industry
standard in the OO development community.

It is free.

It is easier to use than Make.

It is integrated with Eclipse.

Tools Used in Phases of SDLC


What happens during the rest of the software's life: changes,
correction, additions, moves to a different computing platform and
more. This, the least glamorous and perhaps most important step of
all, goes on seemingly forever.

Most junior developers start here to learn the systems.

Popular tools used in this phase:

All of the tools above