module code: cst 240 / bit 233 chapter 1: introduction to software development al khawarizmi...

Module Code: CST 240 / BIT 233

Chapter 1: Introduction to Software Development

Al Khawarizmi International College,Abu Dhabi, U.A.E

At the end of this chapter the student should be able to:

1. Analyze the process models and their stages in the production of software development.

2. Differentiate generic and bespoke products for software development.

3. Discuss the professional responsibilities of software developers.

chapter 1:Introduction to Software Development 2

1.1 Terminologies – Software, Software Engineering, Software Development

1.2 Software Products1.3 Software Process Models1.4 Process Iteration1.5 Professional Responsibility


Software is a collection of ◦ computer programs◦ Procedures◦ rules &◦ all associated documentation


Software Engineering is concerned with Theories, Methods, Tools

These are needed to develop the software for computers.


Software Engineers Should adopt a systematic and organised

approach to their work Use appropriate tools and techniques depending

on the problem to be solved, the development constraints and the resources available.


The objective of software engineering is to produce software products.

Software products are software systems delivered to a customer with the documentation which describes how to install and use the system.


Generic Product Bespoke Product


chapter 1:Introduction to Software Development

• Generic Readymade Standalone

product developed not for any specific client but for all.

Requirements are developed within the development organization.

Relatively cheap to buy. They are generally flexible Example:

Ms Word, Photoshop.

• Bespoke Customized product

developed for a particular customer.

Requirements are produced in conjunction with the client and often serve as the basis for a contract.

Often quite expensive. Not flexible. Example:

KADS-Khawarizmi Associate Degree System

9

The software should deliver the required functionality and performance to the user and should be maintainable, dependable and acceptable.

1. Maintainability2. Dependability3. Efficiency4. Acceptability


1. Maintainability:The system or the software should be flexible in order to make future changes requested by the customer.

2. Dependability: It includes the following attributes:A-Reliability: System should not generate errors, and results are carefully calculated.B-Security: It won't let any one enter the system, except for those who are authorized.C-Safety: Software should not make any harmful effect to other programs or files.

Dependable software should not cause physical or Dependable software should not cause physical or economic damage to in case of system failure.economic damage to in case of system failure.

chapter 1:Introduction to Software

Development 11

3. EfficiencySoftware should not waste system resources such as memory and processor cycles.

4. AcceptabilitySoftware must be accepted by the users for whom its designed. This means it must be understandable, usable and compatible with other systems.


is a set of activities and associated results set of activities and associated results which produce a software product

These activities are mostly carried out by Software Engineers.

Computer-aided software Engineering (CASE) tools may be used to help with some process activities.


1. Software Specification2. Software development3. Software Validation4. Software evolution


Software SpecificationThe functionality of the software and the regulations on its operation should be defined.

Software developmentSoftware is designed and codes written to fulfill the customer requirement

Software ValidationSoftware must be checked to ensure that it does what the customer wants.

Software evolutionThe software must evolve to meet changing needs of the customer.


◦ Waterfall Model◦ Evolutionary Development

◦ Boehm’s Spiral Model◦ Incremental Development



Requirements

definition

System andsoftware design

Implementationand unit testing

Integration andsystem testing

Operation and

maintenance

17

Requirements analysis and definition

The system's services, constraints and goals are established by consultation with system users.

User requirement specification is a document produced at the end of the requirement analysis that defines what is required of the computer system.




System and software design • The design stage translate the user

requirement into a representation of the proposed system.

• System design gives the overall system architecture.

• Software Design involves identifying and describing the fundamental software system and their relationship.

19

Implementation and unit testing Software design is converted into set of

programs or program units. During implementation Unit testing is

carried out. Unit testing involves verifying that each

unit meets its specification.



20

Integration & system testing Individual program units are

integrated and tested as a complete system to ensure it meets software requirement.

System is delivered to the customer after this.



21

Operation and maintenance Longest Life cycle Involves correcting error identified after

the system is installed and put into practical use.

Improving the implementation of system unit

Enhancing the system requirement as new requirements are discovered.

Note: Documentation has to be done at every stage.



22

1. This model reflects engineering practice. 2.The stages are overlapped and feed

information to each other. 3. Waterfall model reflects good visibility

through its separated activities and documentation generated at the end of each activity.

4. Provides better quality control 5. Helps in Cost controlling



23

Because of the iteration it's difficult to identify management checkpoints for planning and reporting. So it's normal to freeze one of the stages, like the specification and design, which will cause the system not to do what the user wants.

It may lead to a badly structured system.



24

The delivered system sometimes doesn't meet the customer's requirements.

Each stage in the process reveals new understanding of the previous stages, that requires the earlier stages to be revised.



25

This model is only appropriate when the requirements are well-understood and changes will be fairly limited during the design process.

Business systems have stable requirements. The waterfall model is mostly used for large

systems engineering projects where a system is developed at several sites.



26



Specifications

Development

Validation

Initial Version

IntermediateVersions

Final Version

Outline Definition

The idea is based on developing an initial implementation, exposing this to the user comments, and refining this through many versions until the final system is developed. It can be used when the domain is not very well understood.

Concurrent activities

27


Outline Requirements

Evolutionary Prototyping

Throw-away prototyping

Executable prototype

+ System specification

Delivered system

There are two types of evolutionary development:

Al Khawarizmi International College,AL AIN, U.A.E

28

1- Exploratory development / Evolutionary Prototyping:

The objective of this process is to work with customer to explore their requirements and deliver a final system.

It starts with the user requirement which is best understood and has high priority. Later low priority and unclear requirements are developed after the requirements are well understood.



29

2- Throw away prototype: Prototype is build to understand the

customer requirement and discarded after obtaining a better requirement definition. Then a new system is developed based on the specifications derived from the throwaway prototype.

It has a very short life-time.



30

Evolutionary Development is more effective because it meets the direct needs of the customer, more than the waterfall model.



31

1- The process is not visible: Managers need regular documentations to evaluate the progress, but the software in this model is developed quickly and it won't be cost effective to produce documents for every version produced.

2- System is poorly structured: Continues changes in software, corrupts the software structure. So changing the software in future become more difficult and costly. chapter 1:Introduction to Software

Development


32

3- Special tools and techniques may be required: Evolutionary development requires rapid development for which special tools and techniques may be required and not all team members may have the skill to use them.



33

1- The small systems. 2- With short lifetime systems. 3- Subsystems that are part of larger

systems.



34

Boehm’s Spiral Model Incremental Development



35

Process is represented as a spiral rather than as a sequence of activities with backtracking.

Each loop in the spiral represents a phase in the process.

There are 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.



36


Progressthrough

steps

CumulativecostDetermine

objectives,alternative,constraints

Riskanaly-sis

Prototype

Riskanalysis

Riskanalysis

Riskanalysis

1 2 3Prototype Prototype Operational

PrototypeSimulations, models, benchmarks

Detaileddesign

CodeUnittest

Integrationand testAcceptance

testImplemen-tation

Design validationand verification

Softwareproductdesign

Softwarerequirement

Requirementvalidation

Developmentplan

Integrationand test plan

Plan next phases

Develop, verify next-level product

Evaluate alternativesidentify, resolve risks

Requirements planlife-cycle planReview

Commitment

partition


37

Each loop represents a phase: Loop1: Feasibility Loop2: User requirements Loop3: Design Loop4: Implementation Loop5: Maintenance There is no fixed number of phases in this

model, rather this is considered by the management of the software process.



38

A cycle starts going clockwise.


Objectives SettingRisk analysis and risk

reduction planning

Plan next cycle Development and validation


39

Each loop in the spiral is split into four sectors:

1- Objectives setting: Specific objectives for the phase are identified.

2- Risk assessment & reduction: Identify risk and develop plans to reduce them.

3- Developing & Validation: A development model for the system is chosen which can be any of the generic models

4- Planning: The project is reviewed and the next phase of the spiral is planned.



40

Spiral model includes other process models. ◦ Prototyping may be used in one spiral to resolve

requirement uncertainties and hence reduce risk.◦ This may be followed by a conventional waterfall

model where each loop corresponds to the different stages of the waterfall model.



41

Rather than delivering the system as a single delivery, the development and delivery is broken down into increments with each increment delivering part of the required functionality.

User requirements are prioritised and the highest priority requirements are included in early increments.



42

Once the development of an increment is started, the requirements are frozen though requirements for later increments can continue to evolve.

It’s a model that combines the advantages of evolutionary development and large scale (large system) development control.



43


Validateincrement

Develop systemincrement

Design systemarchitecture

Integrateincrement

Validatesystem

Define outline requirements

Assign requirements to increments

System incomplete

Finalsystem


44

Customers do not have to wait until the entire system is delivered. The first increment satisfies their main requirements so the software can be immediately used.

Early increments act as a prototype to help obtain requirements for later increments.

Lower risk of overall project failure. The highest priority system services tend to

receive the most testing.



45

Increments should be relatively small( not more than 20,000 lines of code) and

each increment should deliver some system functionality. It may be difficult to map the customer's requirements onto increments of right size.

Difficult to identify common facilities that all increment require.



46

Software engineers must behave in professionally responsible way.

The areas in which standards in behavior should be considered are:

1-Confidentiality: Engineers should normally respect the confidentiality of their employees or clients whether or not a formal confidentiality agreement has been signed.

2- Competence: Engineers should not accept work which is beyond their competence.



47

.

3-Intellectual property rights: Engineers should be aware of local laws such as patents, copyright, and so on. They should be careful to ensure the intellectual property of employers and clients is protected.

4-Computer misuse: Software engineers should not use their technical skills to misuse other people's computers.



48

module code: cst 240 / bit 233 chapter 1: introduction to software development al khawarizmi...

Documents