SOFTWARE DESIGN QUIZ AND PRELIM

Software

Computer programs and associated documentation such as requirements, design models and user manuals

Bespoke

software developed for a single customer according to their specification

Software Engineering

is an engineering discipline that is concerned with all aspects of software production.

Software Engineers

should adopt a systematic and organised approach to their work and use appropriate tools and techniques depending on the problem to be solved, the development constraints and the resources available

Computer Science Theories

are still insufficient to act as a complete underpinning for software engineering (unlike e.g. physics and electrical engineering)

Specification

Development

Validation

Evolution

Generic Activities in all software processes

Software process

a simplified representation of a software process, presented from a specific perspective

Workflow perspective

Data-flow perspective

Role/action perspective

examples of process perspectives

waterfall

iterative development

component-based software engineering

generic process models

Software engineering methods

Structured approaches to software development which include system models, notations, rules, design advice and process guidance

Model descriptions

Descriptions of graphical models which should be produced

Rules

Constraints applied to system models

Recommendations

Advice on good design practice

Process guidance

What activities to follow

Computer-Aided Software Engineering

CASE

CASE

Software systems that are intended to provide automated support for software process activities

CASE systems

often used for method support

Upper-CASE

Tools to support the early process activities of requirements and design

Lower-CASE

Tools to support later activities such as programming, debugging and testing

good software

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

Maintainability

Software must evolve to meet changing needs

Dependability

Software must be trustworthy

Efficiency

Software should not make wasteful use of system resources;

Acceptability

Software must accepted by the users for which it was designed. This means it must be understandable, usable and compatible with other systems

heterogeneity, delivery and trust

key challenges facing software engineering

Heterogeneity

Developing techniques for building software that can cope with heterogeneous platforms and execution environments

Delivery

Developing techniques that lead to faster delivery of software

Trust

Developing techniques that demonstrate that software can be trusted by its users

Confidentiality

Engineers should normally respect the confidentiality of their employers or clients irrespective of whether or not a formal confidentiality agreement has been signed

Competence

Engineers should not misrepresent their level of competence. They should not knowingly accept work which is outwith their competence

Intellectual property rights

Engineers should be aware of local laws governing the use of intellectual property such as patents, copyright, etc. They should be careful to ensure that the intellectual property of employers and clients is protected

Computer misuse

Software engineers should not use their technical skills to misuse other people’s computers. Computer misuse ranges from relatively trivial (game playing on an employer’s machine, say) to extremely serious (dissemination of viruses).

Public

Software engineers shall act consistently with the public interest.

Client and Employer

Software engineers shall act in a manner that is in the best interests of their client and employer consistent with the public interest

Product

Software engineers shall ensure that their products and related modifications meet the highest professional standards possible

Judgment

Software engineers shall maintain integrity and independence in their professional judgment

Management

Software engineering managers and leaders shall subscribe to and promote an ethical approach to the management of software development and maintenance

Profession

Software engineers shall advance the integrity and reputation of the profession consistent with the public interestCollea

Colleagues

Software engineers shall be fair to and supportive of their colleagues.

Self

Software engineers shall participate in lifelong learning regarding the practice of their profession and shall promote an ethical approach to the practice of the profession

Public
Client and Employer

Product

Judgment

Management

Profession

Colleagues

Self

Code of ethics-principles

Ethical Dilemmas

Disagreement in principle with the policies of senior management.

software process model

is an abstract representation of a process. It presents a description of a process from some particular perspective

waterfall model

Separate and distinct phases of specification and development.

evolutionary development

Specification, development and validation are interleaved

component-based software engineering

The system is assembled from existing components.

waterfall method

evolutionary development

component-based software engineering

generic software process models

waterfall model phases

its phases are:

requirements analysis and definition

systems and software design

implementation and unit testing

integration and system testing

operation and maintenance

difficulty for changes

waterfall method main drawback

Exploratory development

Objective is to work with customers and to evolve a final system from an initial outline specification. Should start with well-understood requirements and add new features as proposed by the customer

throw-away prototyping

Objective is to understand the system requirements. Should start with poorly understood requirements to clarify what is really needed

commercial-off-the-shelf

COTS

Component-based software engineering

Based on systematic reuse where systems are integrated from existing components or COTS (Commercial-off-the-shelf) systems.

Component analysis

Requirements modification

System design with reuse

Development and integration

Process stages of Component-based software engineering

Process iteration

System requirements ALWAYS evolve in the course of a project so process iteration where earlier stages are reworked is always part of the process for large systems

iteration

can be applied to any of the generic process modelsin

incremental delivery

spiral development

two related approaches on process iteration

Incremental delivery

Rather than deliver 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

incremental delivery

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

Customer value

can be delivered with each increment so system functionality is available earlier

Early increments

act as a prototype to help elicit requirements for later increments

testing

The highest priority system services tend to receive the most __________

Extreme programming

An approach to development based on the development and delivery of very small increments of functionalitye

extreme programming

relies on constant code improvement, user involvement in the development team and pairwise programming

spiral development

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.

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

objective setting

Specific objectives for the phase are identified

risk assessment and reduction

risks are assessed and activities put in place to reduce the key risksde

development and validation

a development model for the system is chosen which can be any of the generic modelspl

planning

the project is reviewed and the next phase of the spiral is planned

software specification

software design and implementation

software validation

software evolution

process activities

software specification

The process of establishing what services are required and the constraints on the system’s operation and development

feasibility study

requirements elicitation and analysis

requirements specification

requirements validation

Requirements engineering process

implementation

The process of converting the system specification into an executable systems

software design

design a software structure that realises the specificationoi

implementation

translate thsi structure into an executable program

architectural design

abstract specification

interface design

component design

data structure design

algorithm design

Design process activities

structured methods

Systematic approaches to developing a software design.

The design is usually documented as a set of graphical models

object model

sequence model

state transition model

structural model

data-flow model

possible models for structured methods

programming and debugging

Translating a design into a program and removing errors from that program

programming

a personal activity - there is no generic programming process

programmers

they carry out some program testign to discover faults in the program and remove these faults in the debugging process

verification and validation

is intended to show that a system conforms to its specification and meets the requirements of the system customer

system testing

involves executing the system with test cases that are derived from the specification of the real data to be processed by the system

component or unit testing

system testing

acceptance testing

testing stages

software evolution

software is inherently flexible and can change.

Rational unified process

a modern process model derived from the work on the UML and associated process

Inception

Elaboration

Construction

Transition

RUP phases

inception

Establish the business case for the system.

elaboration

Develop an understanding of the problem domain and the system architecture.

construction

System design, programming and testing

transition

Deploy the system in its operating environment

Develop software iteratively

manage requirements

use component-based architectures

visually model software

verify software quality

control changes to software

RUP good practice

Computer-aided software engineering (CASE)

is software to support software development and evolution processes

Case technology

has led to significant improvements in the software process. However, these are not the order of magnitude improvements that were once predicted

CASE classification

helps us understand the different types of CASE tools and their support for process activities.

Functional perspective

Tools are classified according to their specific function

Process perspective

Tools are classified according to process activities that are supported

integration perspective

Tools are classified according to their organisation into integrated units