Introduction.

Introduction

Objectives To define software engineering and explain its importance
To discuss the concepts of software products and software processes To look at some myths and problems in software engineering To define software engineering principles To know software life cycle and process models

1. The Evolving Role of Software
Software is an information transformer producing, managing, acquiring, modifying, displaying, or transmitting information that can be as simple as a single bit or as complex as a multimedia simulation.

1. The Evolving Role of Software
(2) Software is instructions (computer programs) that when executed provide desired function and performance data structures that enable the programs to adequately manipulate information documents that describe the operation and use of the programs

2. Software Characteristics
Software is logical but not physical. Software is developed or engineered. Software doesn’t “wear out.” Software development is based on hardware and operating system. Most software is custom-built.

3. History

4. Software Crisis A set of problems that are encountered in the software development emerge in the end of 60s’ Example：IBM600 OS development about 6000 人年 USD500,000,000 1000 new errors in each new version

5. Why Do Software Projects Fail?
Factors % 1. Incomplete Requirements % 2. Lack of User Involvement % 3. Lack of Resources % 4. Unrealistic Expectations % 5. Lack of Executive Support 9.3% 6. Changing Requirements & Specifications 8.7% 7. Lack of Planning % 8. Didn‘t Need It Any Longer 7.5% 9. Lack of IT Management % 10. Technology Illiteracy % 11. Others % Source: Standish Group 1995

6. What is software engineering?
(1) Software engineering is the discipline concerned with the application of theory, knowledge, and practice for effectively and efficiently building software system that satisfy the requirements of users and customers. S.E. is applicable to small, medium, and large-scale systems. It encompasses all phases of the life cycle of a software system. ---- From ACM & IEEE Computing Curricula 2001

S.E. employs engineering methods, processes, techniques, and measurement; It benefits from the use of tools for managing software development; analyzing and modeling software artefacts; assessing and controlling quality; and for ensuring a disciplined, controlled approach to software evolution and reuse.

The elements of software engineering are applicable to the development of software in any computing application domain where professionalism, quality, schedule and cost are important in producing software system.

(2) Software Engineering is the establishment & use of sound engineering principles in order to obtain economically software that is reliable & work efficiently on real machines --- Fritz Bauer, 1969, NATO

(3) Software Engineering studies how to produce software that: Meets user requirements Why software projects fail? Works correctly and reliably Produces correct results for all circumstances System fails gracefully System is secure (esp. important in web-based environment)

Is easy to Use (GUI) Maintain (i.e. modify and upgrade) to meet user changing needs Is delivered on time Is within budget (optional but gaining importance) Modules can be reused

(4) Designing, building and maintaining large software systems —I. Sommerville

(5) Multi-person construction of multi-version software —D.L. Parnas

(6) Technological and managerial discipline of software products that are developed and modified on time and within cost estimates —R. Fairley

(7) The technology encompasses a process, a set for methods, and an array of tools that we call software engineering.

(8) Software engineering includes every phase of the software life cycle, from requirements to retirement. It also includes human aspects, such as team organisation; economic aspects; and legal aspects, such as copyright law.

(9) Software engineering is a discipline whose aim is the production of fault-free software, that is delivered on time, within budget, and that satisfies the user’s needs.

7. Software Products Generic products
Stand-alone systems which are produced by a development organisation and sold on the open market to any customer Bespoke (customised) products Systems which are commissioned by a specific customer and developed specially by some contractor Most software expenditure is on generic products but most development effort is on bespoke systems

8. Software Products Attributes
Maintainability It should be possible for the software to evolve to meet changing requirements Dependability The software should not cause physical or economic damage in the event of failure Efficiency The software should not make wasteful use of system resources Usability Software should have an appropriate user interface and documentation

9. Importance of product characteristics
The relative importance of these characteristics depends on the product and the environment in which it is to be used In some cases, some attributes may dominate In safety-critical real-time systems, key attributes may be dependability and efficiency Costs tend to rise exponentially if very high levels of any one attribute are required

10. Software Processes Structured set of activities required to deve-lop a software system Specification Design and Development Validation Evolution Activities vary depending on the organisation and the type of system being developed Must be explicitly modelled if it is to be managed

11. Process characteristics
(1) Understandability Is the process defined and understandability (2) Visibility Is the process progress externally visible (3) Supportability Can the process be supported by CASE tools (4) Acceptability Is the process acceptable to those involved in it

11. Process characteristics
(5) Reliability Are process errors discovered before they result in product errors (6) Robustness Can the process continue in spite of unexpected problems (7) Maintainability Can the process evolve to meet changing organisational needs (8) Rapidity How fast can the system be produced

12. Software Engineering Myths
(1) A general statement of objectives is sufficient to begin writing programs - we can fill in the details later Poor Up-front definition is the major cause of failed software efforts

(2) If we get behind schedule, we can add more programmers and catch up Brooks Law: “Adding people to a late project makes it later”

(3) Project requirements continually change, but change can be easily accommodated because software is flexible Cost Impact Severe Moderate Minor Planning Design Implementation Occurrence of Change

(4) The only deliverable for a successful project is a working program Plan Requirements Design Data Structures Test Specs Working Program Listings

(5) Once software is “working”, maintenance is minimal and can be handled on a catch-as-you-can basis Budgeted Maintenance Costs Actual Maintenance 10-15% 55-70%

13. Criticisms levelled at Software
(1) Software is Expensive (2) Software capability is less than promised and expected (3) Software deliveries are often late (4) Software cost overruns often occur and are generally late

(5) Software documentation is inappropriate and inadequate (6) Software is often cumbersome to use and system design for human interaction is lacking (7) Software maintenance is complex and error-prone (8) Software products cannot be integrated

(9) Software deliveries cannot be transitioned into a new environment or modified to meet evolving needs (10) Software performance is often unreliable (11) Software requirements often do not ade-quately capture user needs (12) Software often does not perform according to specifications

14. Tools, Methodologies, Techniques and Principles
Methods and techniques Methodologies Tools

15. Software Engineering Principles
Rigor and Formality Separation of Concern Modularity Abstraction Generality Anticipation of Change Incrementally

(1) Rigor and Formality ① Application of well-defined method(s) or technique(s) ② Ensures reliable products, provides cost control, enhances user confidence ③ Different levels of rigor for different systems, different phases of system development, different parts of a system

(2) Separation of Concern
① Many decisions are strongly related and interdependent ② Concentrate on different aspects of a problem separately e.g. software qualities, development process, operating constraints ③ Separation may be based on time, qualities, views, size, level of details etc.

(3) Modularity ① Dividing complex system into simpler components
② Components should be highly cohesive and loosely-coupled ③ Information Hiding (a) Highly Coupled Structure b) Highly-cohesive, Lowly-coupled Structure

(4) Abstraction ① Identify important aspects of a phenomenon and ignore its details ② Different abstractions of the same reality, each serving a different specific purpose ③ Abstraction permeates the whole of system development in programming：high level languages are abstraction of machine code in processes：identify key factors of new system and extrapolate from historical cost profiles of similar systems

(5) Anticipation of Change
① Change is frequent due to bugs-elimination changing user requirements ② Change in the software product as well as the development process ③ Strategy is to consider the likely changes as part of the system design Isolate likely changes in specific portions of software such that changes will be restricted to small portions develop reusable modules, design

(6) Generality, Incrementality
Solution to a generalised problem has more potential for reuse Trade-off involved in choosing a generalised approach ② Incrementally Process that proceeds in a stepwise fashion Applied to the software qualities or the development process

16. Software Life Cycle (1) Requirements:
Identify the needs of the users by interviewing them. (2) Specification or Analysis: Describe what the software system should do to meet the requirements. (3) Design: Describe how the system should perform the required tasks.

16. Software Life Cycle (4) Implementation:
Program various modules of the system. (5) Integration and test: Combine the modules and verify that the whole system works correctly. (6) Maintenance: Maintain the operation of the system, remove bugs as they are discovered. (7) Retirement: Migrate to a new system.

17. Inputs/Outputs of Each Phase

18. Software Life Cycle Process Models
The linear Sequential

The Prototyping

The Rapid Application Development

The Incremental

The Typical Spiral

The WINWIN Spiral

The Concurrent Process Model

The Component-Based Development

Comparison of Life-Cycle Models
Note: In practice, should combine the strengths of different models to produce good quality software

19. CASE (Computer-Aided Software Engineering)
A good workshop for any -- a Unechanic a carpenter, or a software engineer -- has three primary characteristics: (1) a collection of useful tools that will help in every step of building a product (2) an organized layout that enables tools to be found quickly and used efficiently

(3) a skilled artisan who understands how to use the tools in an effective manner. Software engineers now recognize that they need more and varied tools along with an organized and efficient workshop in which to place the tools.

The workshop for software engineering has been called an integrated project support environment (discussed later in this chapter) and the tools that fill the workshop are coolectively called computer-aided software engineering.

Tools that assist in software analysis, design, implementation, documentation (1) Modeling: tools for drawing charts and diagrams, defining data dictionaries e.g., Rose (Rational), Argo/UML (UC Irvine) (2) Developers’ Workbench: tools that support development tasks (compiling, debugging) e.g., JBuilder, Visual Studio, BoundsChecker

19. CASE (Computer-Aided Software Engineering) Tools
(3) Configuration Management: tools that maintain multiple versions of software e.g. Unix RCS, Visual Source Safe, PVCS (4) Performance Testing: tools that perform load testing (over the web, client-server, etc) e.g. LoadRunner

20. Relative Costs Approximate relative costs of the phases of the software life cycle [Grady 1994] Maintenance is so expensive — a major aspect of software development consists of techniques, tools, and practices that lead to a reduction in maintenance cost

21. The Software Engineering Body of Knowledge
(1) Software Requirements 1) Requirement Engineering Process ① Process Models ② Process Actors ③ Process Support and Management ④ Process Quality and Improvement 2) Requirements Elicitation ① Requirements Sources ② Elicitation Techniques

(1) Software Requirements（Cont.）
3) Requirement Analysis ① Requirements Classification ② Conceptual Modeling ③ Architectural Design and Requirements Allocation ④ Requirements Negotiation 4) Requirements Specification ① Requirements Definition Document ② Software Requirements Specification (SRS) ③ Document Structure and Standards ④ Document Quality

(1) Software Requirements（Cont.）
5) Requirements Validation ① Conduct of Requirements Reviews ② Prototyping ③ Model Validation ④ Acceptance tests 6) Requirements Management ① Change Management ② Requirements Attributes ③ Requirements Tracing

(2) Software Design Software design analyzes software requirements in order to produce a description of the internal structure and organization of a system. 1) Software Design Basic Concepts ① General design concepts ② The context of software design ③ The software design process ④ Enabling techniques 2) Key Issues in Software Design ① Concurrency ② Control and events ③ Distribution ④ Exception Handling ⑤ Interactive systems ⑥ Persistence

(2) Software Design 3) Software Structure and Architecture
① Architectural structures and viewpoints ② Architectural styles and patterns (macro-arch.) ③ Design patterns (micro-arch.) ④ Families of programs and frameworks 4) Software Design Quality Analysis and Evaluation ① Quality attributes ② Quality analysis and evaluation ③ Measures

(2) Software Design 5) Software Design Notations
① Structural descriptions (static) ② Behavioral descriptions (dynamic) 6) Software Design Strategies and Methods ① General strategies ② Function-oriented design ③ OO design ④ Data-centered design ⑤ Other methods

(3) Software Construction
The “translation” of good design into working software. Software construction necessarily produces executable software that is influenced by the scale or size of the software product being constructed. 1) Software Construction Tools Software construction tools include compilers, version control systems, debuggers, code generators, specialized editors, tools for path and coverage analysis, test scaffolding and documentation tools. The best S. C. Tools bridge the gap between methodical computer efficiency and forgetful human creativity. 2) The Role of Integrated Evaluation in Construction The use of unit testing after completion of each well-defined software unit.

3) The Standards in Construction Software construction is particularly sensitive to the selection of standards , which directly affects such construction-critical issues as programming languages, databases, communication methods, platforms, and tools. 4) Manual and Automated Construction Manual Construction means solving complex problems in a language that a computer can execute. Automated construction thus refers to software construction in which an automated tool or environment is primarily responsible for overall coordination of the software construction process. An important goal of software engineering is to move construction continually towards higher levels of automation.

5) Construction Language Programming languages are the most flexible type of construction languages, but they also contain the least information about both application areas and development processes, and so require the most training and skill to use effectively. 6) Principles of Organization  Reduction of Complexity Remove, Automation, Localization of Complexity  Anticipation of Diversity There is no such things as an unchanging software construction.  Structuring for Validation Structuring for validation means building software in such fashion that such errors and omissions can be ferreted out more easily during unit testing.  Use of External Standards

7) Styles of Construction  Linguistic Linguistic construction languages make statements of intent in the form of sentences that resemble natural languages such as English or French.  Formal Formal construction methods rely less on intuitive, everyday meanings of words and text strings, and more on definitions that are backed up by precise, unambiguous, and fully formal(or mathematical) definitions.  Visual The visual interface is powerful not only as a way of organizing information for presentation to a human, but also as a way of conceiving and navigating the overall design of a complex software system.

8) Synthesis Techniques that reduce complexity in linguistic construction include:  Design patterns  Software templates  Functions, procedures and code blocks  Objects and data structures  Encapsulation and abstract data types  Component libraries and frameworks  High-level and domain-specific languages  Physical organization of source code  Files, libraries and formal inspections

(4) Software Testing 1) Testing Basic Concepts and Definitions
① Testing-Related Terminology Definitions of testing and related terminology ② Theoretical Foundations Test selection criteria/Test adequacy criteria (or stopping rules） Testing effectiveness/Objectives for testing Testing for defect removal The oracle problem Theoretical and practical limitations of testing The problem of infeasible paths Testability

(4) Software Testing ③ Relationships of Testing to Other Activities
Testing vs. Static Analysis Techniques Testing vs. Correctness Proofs and Formal Verification Testing vs. Debugging Testing vs. Programming Testing within SQA Testing within Clearness Testing and Certification 2) Test Levels ① The Target of the Test Unit testing Integration testing System testing

(4) Software Testing ② Objectives of Testing
Acceptance/qualification testing Installation testing Alpha and Beta testing Conformance testing/Functional testing/Correctness testing Reliability achievement and evaluation by testing Regression testing Performance testing Stress testing Back-to-back testing Recovery testing Configuration testing Usability testing

(4) Software Testing 3) Test Techniques
① Base on which tests are generated Based on Tester’s intuition and experience Ad hoc Specification-based Equivalence partitioning Boundary-value analysis Decision table Finite-state machine-based Testing from formal specifications Random testing

(4) Software Testing Code-Based Fault-Based Usage-Based
Reference models for code-based testing (flow graph, call graph) Control flow-based criteria Data flow-based criteria Fault-Based Error guessing Mutation testing Usage-Based Operational profile SRET(Software Reliability Engineering Testing)

(4) Software Testing Based on Nature of Application
Object-oriented testing Component-based testing Web-based testing GUI testing Testing of concurrent programs Protocol conformance testing Testing of distributed systems Testing of real-time systems Testing of scientific software

(4) Software Testing ② Ignorance or knowledge of implementation
Black-box techniques Equivalence partitioning Boundary-value analysis Decision table Finite-state machine-based Testing from formal specifications Error guessing Random testing Operational profile SRET

(4) Software Testing ③ Selecting and combining techniques
White-box techniques Reference models for code-based testing (flow graph, call graph) Control flow-based criteria Data flow-based criteria Mutation testing ③ Selecting and combining techniques Functional and structural Coverage and operational/Saturation effect

(4) Software Testing 4) Test-Related Measures
① Evaluation of the Program Under Test Program measurements to aid in planning and designing testing Types, classification and statistics of faults Remaining number of defects/Fault density Life test, reliability evaluation Reliability growth models

(4) Software Testing ② Evaluation of the Tests Performed
Coverage/thoroughness measures Fault seeding Mutation score Comparison and relative effectiveness of different techniques

(4) Software Testing 5) Managing the Test Process
① Management Concerns Attitudes/Egoless programming Test process Test documentation and working-products Internal vs. independent test team Cost/effort estimation and other process metrics Termination Test reuse and test patterns

(4) Software Testing ② Test Activities Planning Test case generation
Test environment development Execution Test results evaluation Problem reporting/Test log Defect tracking

(5) Software Maintenance
1) Basic Concepts ① Definitions and Terminology ② Majority of maintenance Costs ③ The Nature of Maintenance ④ Evolution of Software ⑤ Need for Maintenance ⑥ Categories of Maintenance 2) Maintenance Process ① Process Models ② Maintenance Activities

(5) Software Maintenance
3) Key Issues in Software Maintenance ① Technical ② Management ③ Cost and Estimation ④ Software Maintenance Measurement 4) Techniques for Maintenance ① Program Comprehension ② Re-engineering ③ Reverse Engineering ④ Impact Analysis

(6) Software Configuration Management
1) Management of the SCM Process ① Organizational Context for SCM ② Constraints and Guidance for SCM ③ Planning for SCM Organization and Responsibilities SCM Resources and Schedules Tool Selection and Implementation Vendor/Subcontractor Control Interface Control ④ Configuration Management Plan

⑤ Surveillande of Software Configuration Management SCM Metrics and Measurement In-Process Audits of SCM 2) Software Configuration Identification ① Identifying Items to be Controlled Software Configuration Software Configuration Items Software Configuration Item Relationship Software Versions Baselines Acquiring ② Software Library

3) Software Configuration Control ① Requesting, Evaluating and Approving Software Changes Software Configuration Control Board Software Change Request Process ② Implementing Software Changes ③ Deviations and Waivers 4) Software Configuration Status Accounting ① Software Configuration Status Information ② Software Configuration Status Reporting

5) Software Configuration Auditing ① Software Functional Configuration Audit ② Software Physical Configuration Audit ③ In-Process Audits of a Software Baseline 6) Software Release Management and Delivery ① Software Building ② Software Release management

(7) Software Engineering Management
1) Organizational Management ① Policy Management ② Personnel Management ③ Communication Management ④ Portfolio Management ⑤ Procurement Management 2) Process/Project Management/Project Integration/ Scope/Time/Cost/Quality/Human Resource/ Communications/Risks

(7) Software Engineering Management
3) Software Engineering Measurement ① Goals ② Measurement Selection ③ Measuring Software and its Development ④ Collection of data ⑤ Software Metric Models

(8) Software Engineering Process
1) Software Engineering Process Concepts ① Themes ② Terminology 2) Process Infrastructure ① Software Engineering Process Group ② Experience Factory 3) Process Measurement ① Methodology in Process Measurement ② Process Measurement Paradigms

4) Process Definition ① Types of Process Definitions ② Life Cycle Framework Models ③ Software Life Cycle Process Models ④ Notations for Process Definitions ⑤ Process Definition Methods ⑥ Automation 5) Qualitative Process Analysis ① Process Definition Review ② Root Cause Analysis

6) Process Implementation and Change ① Paradigms for Process Implementation and Change ② Guidelines for Process Implementation and Change ③ Evaluating the Outcome of Process Implementation and Change

(9) Software Engineering Tools and Methods
1) Software Tools ① Software Requirements Tools Requirements modeling Traceability ② Software Design Tools ③ Software Construction Tools Program editors Compilers Interpreters Debuggers

④ Software Testing Tools Test generators Test execution frameworks Test evaluation Test management Performance analysis ⑤ Software Maintenance Tools Comprehension Re-engineering

⑥ Software Engineering Process Tools Process modeling Process management Integrated CASE environments Process-centered software engineering environments ⑦ Software Quality Tools Inspection Static analysis

⑧ Software Configuration Management Tools Defect, enhancement, issue and problem tracking Version management Release and build ⑨ Software Engineering Management Tools Project planning and tracking Risk management Measurement

⑩ Infrastructure Support Tools Interpersonal communication Information retrieval System administrative and support 11 Miscellaneous Tool Issues Tool integration techniques Meta tools Tool evaluation

2) Software Methods ① Heuristic Methods Structured methods Data-oriented methods Object-oriented methods Domain specific methods ② Formal Methods Specification language Refinement Verification

③ Prototyping Methods Styles Prototyping target Evaluation techniques ④ Miscellaneous Method Issues Method evaluation

(10) Software Quality 1) Software Quality Concepts ① Value of Quality
② Functionality ③ Reliability ④ Efficiency ⑤ Usability ⑥ Maintainability ⑦ Portability ⑧ Dependability ⑨ Other Qualities

(10) Software Quality 2) Definition & Planning for Quality ① Overall
② SQA (Software Quality Assurance) ③ VV (Verification & Validation) ④ Independent V&V ⑤ Hazard, threat anal. ⑥ Risk assessment ⑦ Performance analysis 3) Techniques Requiring Two or More People ① Audit ② Inspection ③ Review ④ Walkthrough

(10) Software Quality 4) Support to Other Techniques
Change Impact Anal. Checklists Complexity Analysis Coverage Analysis Consistency Analysis Criticality Analysis Hazard Analysis Sensitivity Analysis Slicing Test documents Tool evaluation Traceability Analysis Threat Analysis

(10) Software Quality 5) Testing Special to SQA or V&V
Conformance Test Configuration Test Certification Testing Reliability Testing Safety Testing Security Testing Statistical Testing Usability Testing Test Monitoring Test Witnessing

(10) Software Quality 6) Defect Finding Techniques Algorithm Analysis
Boundary Value Anal. Change Impact Anal. Checklists Consistency Analysis Control Flow Analysis Database Analysis Data Flow Analysis Distrib. Arch. Assess Evaluation of Docts.: Concept, Reqmts. Evaluation of Docts.: User, Installation

(10) Software Quality Event Tree Analysis Fault Tree Analysis
Graphical Analysis Hazard Analysis Interface Analysis Formal Proofs Mutation Analysis Perform. Monitoring Prototyping Reading Regression Analysis Simulation Sizing & Timing Anal. Threat Analysis

(10) Software Quality 7) Measurement in Software Quality Analysis
Benchmarks, profiles, etc. Company Metric Progs. Costing Customer satisfaction Data Collection process Debugging Defect Analysis Defect Classif. And Descr. Defect Features Example of applied GQM Experimentation: Framework

(10) Software Quality GQM Methods Metrics Models Prediction
Prod. Features: O/O Metrics Prod. Features: Structure Product Features: Size Quality Attributes Quality Character. Meas. Reliabl. Models & Meas. Scales

(10) Software Quality SQA & V&V reports * Statistical tests
Statistical Analysis & measurement Test coverage Theory Trend analysis When to stop testing *

Conclusion Software is composed of programs, data, and documents.
The intent of software engineering is to provide a framework for building software with higher quality. Software engineering is concerned with the theories, methods and tools for developing, managing and evolving software products

Conclusion Software products consist of programs，documentation and services. The software life cycle includes requirement, analysis, design, implementation, integration, test, maintenance. The software process consists of those activities involved in software development.

Conclusion There are six main process models:
The linear sequential model; The prototyping model; The RAD model; Evolutionary model; Component-Based model; The formal methods model;

Question 1. Software is the differentiating characteristic in many computer-based products and systems. Provide examples of two or three products and at least one system in which software, not hardware, is the differentiating element. 2. Which of the software engineering paradigms presented in this part do you think would be most effective? Why?

Question 3. Provide five examples of software development projects that would be amenable to prototyping. Name two or three applications that would be more difficult to prototype. 4. As you move outward along the process flow path of the spiral model, what can you say about the software that is being developed or maintained?

Question 5. Many people believe that the only way in which order of magnitude improvements in software quality and productivity will be achieved is through component-based development. Find three or four recent papers on the subject and summarise them for the class. 6. Describe the concurrent development model in your own words.

7. Provide three examples of fourth generation techniques.
8. Which is more important -- the product or the process?

Introduction.

Similar presentations

Presentation on theme: "Introduction."— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Introduction.

Similar presentations

Presentation on theme: "Introduction."— Presentation transcript:

Similar presentations

About project

Feedback