Software Engineering Fundamentals
COC2073
Module 2 – Software Process Models
Last Module - Review
Need for Software Engineering Fundamentals
What is Software Engineering?
Software Crisis
Software Engineering Diversity
Problems in Software Development
Well-Engineered Software
Scope of a S/W Life-Cycle Model
2 Software Engineering Fundamentals - COC2073
Module 2 - Agenda
The Waterfall Model The V Model
Spiral Model Agile Software
Development
3 Software Engineering Fundamentals - COC2073
Life Cycles and Process Models
4 Software Engineering Fundamentals - COC2073
Agile Software Development
5 Software Engineering Fundamentals - COC2073
Agile Software Development
Businesses now operate in a global, rapidly
changing environment
They have to respond to
‒ New opportunities and markets
‒ Changing economic conditions
‒ The emergence of competing products and
services
Rapid development and delivery is therefore
now often the most critical requirement for
software systems
6 Software Engineering Fundamentals - COC2073
Agile Software Development
Businesses are willing to trade off software
quality and compromise on requirements to
achieve faster deployment of the software
The businesses are operating in a changing
environment, it is often practically impossible
to derive a complete set of stable software
requirements AGIL
E
7 Software Engineering Fundamentals - COC2073
Agile Software Development
Software development processes that plan on
completely specifying the requirements and
then designing, building, and testing the
system are not geared to rapid software
development AGILE
As the requirements change or as
requirements problems are discovered, the
system design or implementation has to be
reworked and retested
8 Software Engineering Fundamentals - COC2073
Agile Software Development
As a consequence, a conventional waterfall or
specification-based process is usually
prolonged and the final software is delivered
to the customer long after it was originally
specified
AGILE
9 Software Engineering Fundamentals - COC2073
Agile Software Development
IBM introduced incremental development in
the 1980's
The idea really took off in the late 1990's with
the development of the notion of agile
approaches such as:
- Scrum
AGILE
- eXtreme programming (Xp)
10 Software Engineering Fundamentals - COC2073
Agile Software Development
Rapid software development processes are
designed to produce useful software quickly
The software is not developed as a single unit
but as a series of increments, with each
increment including new system functionality
11 Software Engineering Fundamentals - COC2073
ASD - Fundamental Characteristics
1) The processes of specification, design, and
implementation are interleaved
2) The system is developed in a series of
versions
3) System user interfaces are often developed
using an interactive development system
that allows the interface design to be quickly
created by drawing and placing icons on the
interface
12 Software Engineering Fundamentals - COC2073
Agile Methods
In the 1980s and early 1990s, there was a
widespread view that the best way to achieve
better software was:
- Careful project planning
- Formalized quality assurance
- The use of analysis and design methods
- Controlled and difficult software development
processes
- For example control systems for a modern
aircraft
13 Software Engineering Fundamentals - COC2073
Agile Methods
More time is spent on how the system should
be developed than on program development
and testing
Rely on an incremental approach to software
specification, development, and delivery
14 Software Engineering Fundamentals - COC2073
Agile Methods
Best suited to application development where
the system requirements usually change
rapidly during the development process
Intended to deliver working software quickly
to customers, who can then propose new and
changed requirements to be included in later
iterations of the system
15 Software Engineering Fundamentals - COC2073
Agile Approaches
Lightweight approaches to satisfy the
customers with "early and continuous
delivery of valuable software"
Manifesto for Agile Software Development
Individuals & Interactions over Processes & Tools
Working Software over Comprehensive
Documentation
Customer Collaboration over Contract Negotiation
Responding to Change over Following a Plan
16 Software Engineering Fundamentals - COC2073
Principles of Agile Methods
Customer Involvement
Incremental Delivery
People Not Process
Embrace Change
Maintain Simplicity
17 Software Engineering Fundamentals - COC2073
Agile Methods - Difficulties
In practice, the principles underlying agile
methods are sometimes difficult to realize:
1) Willing of a customer to spend time with the
development
2) Individual team members may not have
suitable personalities for the intense
involvement
3) Prioritizing changes can be extremely difficult
4) Maintaining simplicity requires extra work
18 Software Engineering Fundamentals - COC2073
Agile Methods - Applicability
Agile methods have been very successful for
some types of system development:
1) Product development where a software
company is developing a small or medium-sized
product for sale
2) Custom system development within an
organization, where there is a clear commitment
from the customer to become involved in the
development process and where there are not a
lot of external rules and regulations that affect
the software
19 Software Engineering Fundamentals - COC2073
eXtreme Programming (XP)
20 Software Engineering Fundamentals - COC2073
Extreme Programming (XP)
XP, a new software development
methodology, born in the 1999 by Kent Beck
"XP was likely developed to support the
adoption of programming languages such as
Java, Visual Basic, and C#"
Several new versions of a system may be
developed by different programmers,
integrated and tested in a day
21 Software Engineering Fundamentals - COC2073
Extreme Programming (XP)
The purpose of the XP is to create quality
programs in short time frames
XP tends to work best for
‒ Small to medium size development efforts in
environments that have frequent specification
changes
‒ Where near-instant communication is possible
The primary difference of XP is that it focuses
on testing
22 "Test First
Software instead
Engineering of Code
Fundamentals First"
- COC2073
Extreme Programming (XP)
1. Incremental development
‒ Small, frequent releases of the system
2. Customer involvement
‒ Continuous engagement of the customer in the
development team
3. People, not process
‒ Pair programming, collective ownership of the
system code, and a sustainable development
process that does not involve excessively long
working hours
23 Software Engineering Fundamentals - COC2073
Extreme Programming (XP)
4. Change is embraced
‒ Regular system releases to customers, test-first
development, refactoring to avoid code
degeneration, and continuous integration of new
functionality
5. Maintaining simplicity
‒ Constant refactoring that improves code quality
24 Software Engineering Fundamentals - COC2073
The Team
The team works together in a lab space or
open area where collaboration and
communication are maximized
25 Software Engineering Fundamentals - COC2073
XP Release Cycle
Select User Stories for Break Down Stories to
Plan Release
this Release Tasks
Develop/Integrate/Test
Evaluate System Release Software
Software
26 Software Engineering Fundamentals - COC2073
Extreme Programming - Practices
Stories Pair Programming
“Requirements", but Focus on task
not mandatory Clarify ideas
Name + short story Rotate frequently
On index cards Refactoring
Behavior preserving
transformation
Tool support, e.g. Eclipse
Continuous Integration Test-First Programming
Integrate and test often Create tests before code
Automated build system Focus on interface and
Automated regression "what is needed"
tests Gets tests for free
27 Software Engineering Fundamentals - COC2073
Small Releases
28 Software Engineering Fundamentals - COC2073
XP Principles
Incremental
planning
Test-first
Sustainable pace development
Pair programming Simple design
Collective
Small releases
ownership
Continuous
Refactoring
integration
29 Software Engineering Fundamentals - COC2073
Refactoring
Refactoring is the process of making changes
to existing, working code without changing its
external behavior
In other words, changing how it does it, but
not what it does
The goal is to improve the internal structure
30 Software Engineering Fundamentals - COC2073
Pair Programming
Programmers work in pairs to develop the
software
Sit together at the same workstation to
develop the software
The same pairs do not always program
together
Pairs are created dynamically so that all team
members work with each other during the
development process
31 Software Engineering Fundamentals - COC2073
Pair Programming - Advantages
It supports the idea of collective ownership
and responsibility for the system
It acts as an informal review process because
each line of code is looked at by at least two
people
Support refactoring
32 Software Engineering Fundamentals - COC2073
Stories (Scenarios)
Customers are intimately involved in
specifying and prioritizing system
requirements
The customer is part of the development team
and discusses scenarios with team members
Together, they develop a ‘story card’ that
encapsulates the customer needs
The development team then aims to
implement that scenario in a future release of
the software
33 Software Engineering Fundamentals - COC2073
Stories (Scenarios)
The customer prioritizes the stories for
implementation, choosing those stories that
can be used immediately to deliver useful
business support
If changes are required for a system that has
already been delivered, new story cards are
developed and again, the customer decides
whether these changes should have priority
over new functionality
34 Software Engineering Fundamentals - COC2073
Stories (Scenarios)
35 Software Engineering Fundamentals - COC2073
Stories (Scenarios)
Incremental Planning
Requirements are recorded on story cards and determined by
time and priority
36 Software Engineering Fundamentals - COC2073
Requirements Scenarios
User
Customer requirements are
making decisions expressed as
on requirements scenarios or
user stories
The
development The customer
team breaks chooses the stories
them down into based on their
implementation priorities and the
tasks schedule estimates
37 Software Engineering Fundamentals - COC2073
Test-First Programming
The key features of testing in XP are:
1) Test-first development
2) Incremental test development from scenarios
3) User involvement in the test development and
validation
4) The use of automated testing frameworks
38 Software Engineering Fundamentals - COC2073
Test-First Programming
39 Software Engineering Fundamentals - COC2073
Questions
40 Software Engineering Fundamentals - COC2073