The description of process given here is intended to cover both
complete software applications and
individual software components.
Topics include:
-
The general elements of a software engineering discipline
-
The phases of any significant software development
project
-
Personnel involved
-
Ongoing activities regardless of the phase
-
Software process models
-
The importance of a disciplined process
For experienced software developers, the component-level process is
often less conspicuous, involving well-established and automated
patterns of thinking. This does not diminish its importance.
Software developers need good automated thinking habits to free their
minds for dealing with more complex issues.
Elements of a Software Engineering Discipline
Abstraction
• Encapsulation of information through OOP, for example
Analysis and Design Methods and Notations
• Use of design patterns, UML
User Interface Prototyping
• Help user and developer agree on requirements and
software functions
Software Architecture
• Strive for independence of parts through modularity
Software Process
Software Reuse
Measurement (Metrics)
• Quantifying project goals to evaluate progress
(number of bugs per 100 lines of code, for example)
Tools and Integreated Environments
• Netbeans, for example
Phases of Software Development
The software development
phases shown next are common to all
significant software development projects.
How they fit into an overall process differs according to the
process
model used.
Requirements Analysis and Definition
• See
Software Engineering Values
System Design
• High-level software architecture
Program Design
• User-oriented: UML class and interaction diagrams
• Implementation-oriented: internal structure
and algorithm design
Program Implementation
• Writing and compiling code for the individual
software components and their test software
Unit Testing
• Testing individual units, for example, classes
Integration Testing
• Testing collaboration of units within modules
System Testing
• Testing all modules together
System Delivery
• Package and deliver bundles of the software and its
documentation to the purchaser
Maintenance/Evolution
• Fix defects or adapt software to new needs
In large organizations, different software phases may involve different
people playing different roles.
In smaller organizations, people may play multiple roles.
Next we show the major software development roles.
Other Software Personnel
Librarians:
Prepare and store documents used during the life of the system:
- Requirements specifications
- Design descriptions
- Program documentation
- Training manuals
- Test data and schedules, etc.
Configuration Managers:
- Maintain cross references among requirements,
design, implementation, and tests
- Coordinate different versions of software across
platforms, and from one release to another
The following software development activities cannot be isolated to a
single phase, and are repeated throughout the development process.
-
Risk Analysis
-
Planning
-
Verification and Validation
-
Documentation
Risk analysis is a management activity that attempts to identify aspects
of the development process that have a significant chance of
failing.
After risks are identified, managers have several options:
- Cancellation of the project
- Change in goals or how resources are allocated
Planning is a management activity that determines the specific
project goals and allocates adequate resources for the various
phases:
- Time: calendar time or person-months
- People: full-time equivalents
- Work and meeting space
- Development hardware and software
Risk analysis can be viewed as preparation for planning.
For phases with high risk, managers may
- Allocate more time or people
- Allocate more skilled people
- Devote time to training people
All phases of development should involve ensuring that
the products of the various phases meet their objectives.
- Validation: the process of ensuring that
the requirements and designs solve the customer's
problem
-
Verification: the process of ensuring that
the design and implementation conform to the requirements
through:
- Reviews and code walk-throughs
- Testing:
-
Black-box testing: Testing how
software meets its client-oriented specifications, without
regard to implementation
-
White-box testing: Using knowledge of
implementation to exercise all paths of control in programs
-
Formal or analytic verification
Documentation provides instructions and information needed for the
installation, use, and maintenance of software.
- User Documentation: Important, but not the
only kind
- Code Documentation: Because of the
importance of maintenance, the documentation of components for use by
other developers is essential
Software process models are general approaches for organizing a project
into activities.
-
Help the project manager and his or her team to decide:
-
What work should be done
-
In what sequence to perform the work
-
The models should be seen as aids to thinking, not rigid prescriptions
of the way to do things
-
Each project ends up with its own unique plan
-
Does not acknowledge the importance of working out the
requirements and the design before implementing a system
-
There is no explicit recognition of the need for
systematic testing and other forms of quality assurance
-
The above problems make the cost of developing and
maintaining software very high
A software process must involve all of the phases already identified.
However, the phase transitions must be controlled, or the process
will be chaotic as shown below.
-
Suggests that software engineers should work in a series of stages
-
Each stage should involve quality assurance (verification and
validation)
-
Accounts for the importance of requirements, design and quality
assurance
-
Recognizes, to a limited extent, that you sometimes have to step back
to earlier stages
-
Implies that you should attempt to complete a given stage before
moving on to the next stage
-
Does not account for the fact that requirements
constantly change
-
Means that customers cannot use anything until
the entire system is complete
-
Makes no allowances for prototyping
-
Implies that you can get the requirements right by simply writing them
down and reviewing them
-
Implies that once the product is finished, everything else is
maintenance
-
In practice, neither users nor developers know in advance all the
factors that affect desired outcome
-
Thus considerable "thrashing" between one activity and back may take
place in order to gain knowledge about the problem
-
One way to control such thrashing: develop a partial product
and allow customers and developers to examine it for feasibility
-
Advantage: revisions made at requirements stage rather than the more
costly testing stage
-
The partially developed product is a prototype
If a prototype is used in the Waterfall Model, it is usually thrown
away.
In the Prototyping Model, the prototype becomes the product:
The
Phased-Release model allows customers to use software while
it is being developed:
-
After requirements gathering and planning, the project should be
broken into separate subprojects, or phases
-
Each phase can be released to customers when ready
-
Parts of the system will be available earlier than when using a strict
waterfall approach
-
However, it continues to suggest that all requirements be finalized at
the start of development
Phased releases reduce the wait time for software to be delivered:
Incremental Development: Deliver complete modules one at a time
Iterative Development: Deliver incomplete modules in a bundle
and improve them over time
The Spiral Model
Explicitly embraces prototyping and an
iterative approach to software development:
• Start by developing a small prototype
• Followed by a mini-waterfall
process, primarily to gather requirements
• Then, the first prototype is reviewed
• In subsequent loops, the project
team performs further requirements, design, implementation and review
• The first thing to do before
embarking on each new loop is risk analysis
• Maintenance is simply a type of
on-going development
The Evolutionary Model
Shows software development as a series of
hills, each representing a separate loop of the spiral:
• Shows that loops, or releases, tend
to overlap each other
• Makes it clear that development work tends to
reach a peak, at around the time of the deadline for completion
• Shows that each prototype or release can take
differing amounts of time to deliver and differing amounts
of effort
Agile approaches encourage the execution of particularly small
iterations in the development cycle.
Agile Software Development
• Well suited for small projects that involve
uncertain, changing requirements and other high risk
• Perspective: Building software is more like
creating a work of art, requiring creativity in design and
craftsmanship in implementation
• There are no Agile "methods" or "processes"; only
Agile teams.
• The most famous agile approach is eXtreme
Programming (XP)
• Another agile methodolgy is Scrum
Extreme Programming
• All stakeholders work closely together
• User stories (looser than use
cases) are written instead of requirement documents
• There must be a series of small and frequent
releases (1 to 3 weeks)
• The project variables
are: scope, resources, time and quality
• Test cases are written before
the software is developed
• A large amount of refactoring
is encouraged
• Pair programming is recommended
Extreme Programming Basic Principles
Rapid Feedback
• Days or weeks rather than months or years
Assume Simplicity
• Solve today's problem simply and trust your ability to
add complexity in the future
Incremental Change, A Little At A Time
• In all areas: planning, design, team formation, learning XP
Embrace Change
Quality Work
• Quality as a variable ranges over “excellent” and
“insanely excellent”
The Concurrent Engineering Model
Explicitly accounts for the
divide and conquer principle:
• Each team works on its own component, typically
following a spiral or evolutionary approach
• There has to be some initial planning, and
periodic integration
Each of the large scale components then goes through design, implementation, integration (putting together subcomponents), and maintenance. They also are in a sense delivered: they are delivered for integration with other large scale components. In short, each of the large scale components can be developed using a smaller scale development process.
A disciplined software process serves two main purposes:
-
Helps developers better understand what they
are doing
-
Helps managers make more accurate predictions about how long a
project will take
-
Predictability is crucial for setting reasonable goals and planning
resource allocation.
As software developers work through a disciplined process, they are
developing a complex mental road map of:
-
The values of the client
-
The concepts that are important to the
client
-
Software patterns for achieving the desired
behavior
-
Implementation methods
Common sense and
experience both support the importance
of this understanding.
Suppose that a software development process has been in progress for
several months or years. Then:
-
One of the development team members has changed jobs so that a
replacement is needed, or
-
The project is behind schedule so management has allocated more people
to work on the project.
So a new member, who knows neither the process nor the client, has been
added to the team.
Will he/she be as effective as the other team members?
Not likely.
Brooks [
Brooks95] has
discussed management problems arising from adding people to a
project that is behind schedule in order to catch up:
-
Often, the result is that the project slips further behind schedule.
-
The reason: The new people do not have a mental road map.
-
In order to acquire it, experienced team members will have to dedicate
some time to bringing them up to speed.
This may seem obvious, but managers have to go through a similar
process to learn how to manage effectively.
A lot of facts are obvious, but that does not mean that you will see
them when they are important:
-
You do not see things that are obvious until you have had experiences
that stress their importance.
-
You also need to recognize that they are important.
When undertaking a new project, software managers must be able to
estimate the resources required so that:
-
A reasonable estimate of cost can be given to the
purchaser
-
Internally, managers can anticipate needs and
coordinate between multiple projects.
A disciplined process is essential for managers to call upon previous
experience in order to make resource estimates:
-
With an undisciplined process, there is too
much variation in how long it takes to accomplish a task among
previous projects, and a reliable estimate cannot be made for new
projects
-
With a disciplined process, managers develop a
better sense of how long it takes to accomplish various kinds of tasks
and what kinds of skills are needed.