skip to main |
skip to sidebar
NOTE: this is similar to the idea of incremental development.. BUT: incremental development delivers a working system to the users, requirements should have been well understood beforehand, and throw-away prototyping we use to explore the requirements, the user just validates it; moreover the lifetime of an increment release may be much longer than the one of our prototype;
Throw-away prototype
-> not delivered to the user, not maintained
-> try out design, options, possible solutions
-> can be used before proper incremental development.. but does not have to
-> system stakeholders can experiment with it on early stages
There're three situations when we may want to use prototyping:
- in requirements engineering process
- in system design process
- in testing process (back-to-back testing: ~we check if the prototype behaves in the same way as the application)
RAD - rapid software development
- is designed to produce useful software quickly; it's iterative; specification, design, development and testing phases interleave. Software is delivered in a series of increments, each including new system functionality; some characteristics:
- processes of specification, design and implementation are concurrent
- incremental, while users and stakeholders are involved in specifying and evaluating each increment => accelerated delivery and users engagement with the system
- system UI often developed using iterative development
BUT: IID => management problems (not cost-effective to produce lots of documentation, unfamiliar technologies), contractual problems (no ready specification), validation problems (no ready specification again), maintenance problems (complex software's structure, people need to know RAD techniques)
-> not for huge systems where teams work in different locations, critical systems (?)
Triangle for "product" => businesses may be willing to accept software delivered quicker but with lower quality and essential functionality (mobile phones)
Three "S":
- Services - what industry is selling; are provided by
- Systems - package of different interacting software
- Software - by creating the software we create some system
Three "P":
- People - we, with different background
- Project
- Process
Software can have various
- function
- application area (e.g. university or a private company)
- operation mode (e.g. how many users at a time)
- scale (e.g. how many lines)
- data representation (e.g. database type, file types)
- software criticality
- software stability
- software product availability
- computer system and environment
- computer resource requirement
- security requirement
- reliability requirement
Triangle for "product"
- size = functionality
- quality
- time
-> this is the reason why we still have problems like during the 'software crisis' ('60)
-> NATO Conference 1969 recommends standardization of the software development process
Triangle for "quality"
- process (as skeleton to help people with different backgrounds;p)
- tools
- people
Sofware processes are in the development phase of the software life-cycle. - ?!
Evolution of s. process models:
- Code-and-fix model ('50)
- Stagewise model (from stage to stage, '60)
- Waterfall model ('70)
- Evolutionary model, Transform model, IID (~'80)
- Spiral model ('80/'90)
- Agile development, XP (~2000)
Types of development
- Plan driven development - document-driven, code-driven, traditional; emphasis on defining the scope, schedule and costs upfront;
- Change-driven development - aim of enabling evolution of product requirements during process of software development; adoption of IID approach;
- Iterative development - often resulting as a internal iteration release (IIR), a stable, integrated, tested partially, complete system; each iteration may considered as a mini-project, produces a subset of the final system;
- Incremental development - adding functionality to the system over several releases to the market; one incremental delivery may be composed of several iterations;
- IID - when the system is developed in several iterations; often called just iterative development;p
NOTICE: in IID increments consist of several iterations each, not the opposite!
* Iterative development - many waterfalls; XP - plenty of waterfalls ;p
There are four fundamental process activities common to all software processes: click
1. Software specification (= requirements engineering)
- the process of establishing what services are required from the system, and identifying the constraints on the system's operation and development; leads to the production of a requirements document that is specification for the system;
Consists of following phases (page 75):
- Feasibility study - ...
- Requirements elicitation and analysis - ...
- Requirements specification - ...
- Requirements validation - ...
These phases are interleaved, they are not carried out in a strict sequence.
2. Software design and implementation
- the process of converting a system specification into an executable system; except from design and programming may also include refinement of the specification (in an evolutionary approach)
a) design - design of a structure that realizes the specification;
-> consists of activities:
- architectural design
- abstract specification
- interface design
- component design
- data structure design
- algorithm design
-> usually documented as a set of graphical models:
- object model
- sequence model
- state transition model (how system's states change)
- structural model
- data-flow model (how data is changed and transformed)
b) implementation - translate this structure into an executable program; remove errors from that program;
debugging != defect testing
debugging: locate error -> design error repair (not to create more bugs!) -> repair error -> retest program
These two activities (design and implementation) are closely related and may be interleaved;
3. Software validation (verification and validation)
- intended to show that a system conforms to its specification and the system meets expectations if the customer buying the system; involves checking proceses: inspections and reviews at each stage of the software process
Testing stages:
- Component (unit) testing - individual components are tested independently; components may be functions or objects, ...
- System testing - the components are integrated; looking for errors resulting from interactions between the components; validating if system meets the functional and non-functional requirements
- Acceptance testing - testing with customer data to check that the system meets the customer's needs
4. Software evolution (= software maintenance)
- software must be changing; this activity is when system is in use;
The specification is developed in conjunction with the software. But this implies contractual problems.
* We can apply these models to any of the generic process models.
* The below models are not completely separate, they're related.
INCREMENTAL DELIVERY
- the software specification, design and implementation are broken down into a series of increments that are each developed in turn
- user requirements of high priority and are developed in early increments
- once increment started the current increment's requirements are frozen (but the later increment's requirements can still evolve)
STAGES:- Define outline requirements
- Assign requirements to increments
- Design system architecture
- Develop system increment
- Validate increment
- Integrate increment
- Validate system
- if system incomplete: go to 4.
-> early increments work as prototypes
-> lower risk of overall project failure
-> highest priority services are most tested, because they're the earliest
-> users can use the system immidiately
-> increments should be of right size - difficult
* a variant of this development is XP development ;p
SPIRAL DEVELOPMENT (by Boehm, 1988)
- the development of the system spirals outwards from an initial outline through to the final developed system
- each loop in the spiral represents a phase in the process
- no fixed phases such as specification or design - loops in the spiral are chosen depending on what is required
- risks are explicitly assessed and resolved throughout the process
http://www.ics.uci.edu/~wscacchi/Software-Process/Images/Spiral-Model-Boehm-1987.gif
Each loop stands for different a phase in software process. For example the first loop could be concerned with system feasibility, second with requirements definition, next one with system designand, and so on.. Additionally, each loop consists of FOUR sectors:
- Objective setting - defining phase objectives; identify constraints on the process; draw up a management plan; identify project risks; define alternative strategies based on that risk;
- Risk assessment and reduction - detailed analysis of every identified project risk; take steps to reduce the risk;
- Development and validation - choose development model (e.g. waterfall if main risk is sub-system integration, evolutionary dev. if user interface risks are dominant, ...)
- Planning - review of the project, decision if we continue to the next cycle, if yes - plans for the next phase
-> explicit recognition of risk
-> we can decide after risk analysis if we want to continue or we should quit
Software process models - they are abstractions, not definitive descriptions of software processes; kind of a framework.. these are the following: click
WATERFALL MODEL:
STAGES:
- Requirements analysis and definition - by consultation with users; system specification
- System and software design - establish overall system architecture
- Implementation and unit testing - software design is realized as a set of program units; verify that each unit meets its specification
- Integration and system testing - units are integrated and tested as a complete system if they meet the requirements
- Operation and maintenance - usually the longest phase; system is in practical use; correcting errors; enhancing services as new requirements are discovered
* documentation is produces at each phase
* phases may overlap
-> it is easy to understand, that's why 60% companies use it
-> hard to change anything once it is underway
-> that's why we have to be 100% sure we understand the requirements, and that they don't change
-> used for large systems, while developed at many sites (it's easier to control them)
-> waterfall model gives control over the communication
EVOLUTIONARY DEVELOPMENT:
- work with customer to evolve a final system from an initial outline specification; two types:
a) Exploratory development - we should start with clearly specified requirements and add new features proposed by the customer;
b) Throw-away prototyping - start with poorly understood user requirements, experiment with the customer requirements to understand them
STAGES:
- Outline description
- concurrently: Specification, Development and Validation
* we get initial version, then many intermediate versions, and in the end the final version
-> lack of process visibility (we don't know where we are)
-> systems are poorly structured
-> may require special skills (e.g. in languages for rapid prototyping)
-> for small or medium size interactive systems or parts of large systems (e.g. user inteface)
-> for short-lifetime systems
COMPONENT-BASED SOFTWARE ENGINEERING (CBSE)
- software reuse;
STAGES:
- Requirements specification
- Component analysis - search for appropriate components
- Requirements modification - modify to reflect the available components; or go to previous step;p
- System design with reuse - design framework for the software
- Development and integration - integrate components, develop what is needed..
- System validation
-> reduces the amount of software to be developed
-> reduces costs and risks
-> faster delivery
-> it may not meet the real needs of the users
-> no full control over the system evolution
COTS - is a term for software or hardware, generally technology or computer products, that are ready-made and available for sale, lease, or license to the general public.
Software life-cycle (5) by Sommerville:
Requirements definition -> System and software design -> Implementation and unit testing -> Integration and system testing -> Operation and maintenance
Software life-cycle (3+2) by Tukiainen:
Birth -> Concept -> Development -> Maintenance (longest) -> Death
..and in the development phase we have one sequence of fundamental process activities; in maintenance phase we have many these sequences.
aa
