software engineering book
3. Contingency plans
Following these strategies means that you are prepared for the worst and have a strategy in place to deal with it. An example of a contingency strategy is the strategy for organizational financial problems
Acceptance testing
'alpha testing'
As the cost of a project is only loosely related to the price quoted to a customer
'pricing to win' is a commonly used strategy
user requirement vs system requirement
'user requirements' to mean the high-level abstract requirements and 'system requirements' to mean the detailed description of what the system
Extreme programming involves a number of practices, ..
3. People, not process, are supported through pair programming, collective ownership of the system code, and a sustainable development process that does not involve excessively long working hours.
Agile Software Development
A method for software development that uses new approaches, focusing on close collaboration between programming teams and business experts
costs associated with reuse:.
2. Where applicable, the costs of buying the reusable software. For large off-theshelf systems, these costs can be very high.
relation between one non functional requirement and many functional requirement
A single non-functional requirement, such as a security requirement, may generate a number of related functional requirements that define new system services that are required.
Release management
A system release is a version of a software system that is distributed to customers.
incremental specification are inherent
Because incremental specification is inherent in agile methods, writing contracts for this type of development may be difficult.
For example, say an organization intends to introduce a new software-testing tool
Before introducing the tool, you record the number of software defects discovered in a given time
Application frameworks
Collections of abstract and concrete classes are adapted and extended to create application systems
Feasibility study
An estimate is made of whether the identified user needs may be satisfied using current software and hardware technologies
Application frameworks..
Early enthusiasts for object-oriented development suggested that one of the key benefits of using an object-oriented approach was that objects could be reused in different systems
Implementation issues
Software engineering includes all of the activities involved in software development from the initial requirements of the system through to maintenance and management of the deployed system
what does software engineering support
Software engineering is intended to support professional software development, rather than individual programming
Managing people
The people working in a software organization are its greatest assets. I
requirements engineering (RE)
The process of finding out, analyzing, documenting and checking these services and constraints
there are software engineering fundamentals that apply to all types of software system.
Understanding and managing the software specification and requirements (what the software should do) are important
The development schedule for the software
If the software has to be developed quickly, you should try to reuse off-the-shelf systems rather than individual components.
Increased maintenance costs
If the source code of a reused software system or component is not available, then maintenance costs may be higher because the reused elements of the system may become increasingly incompatible with system changes.
Description client-server
In a client-server architecture, the functionality of the system is organized into services, with each service delivered from a separate server. Clients are users of these services and access servers to make use of them.
Effective use of specialists
Instead of doing the same work over and over again, application specialists can develop reusable software that encapsulates their knowledge.
3. Inclusion
People contribute effectively when they feel that others listen to them and take account of their proposals. It is important to develop a working environment where all views, even those of the most junior staff, are considered
1. Consistency
People in a project team should all be treated in a comparable way. No one expects all rewards to be identical but people should not feel that their contribution to the organization is undervalued.
Creating, maintaining, and using a component library
Populating a reusable component library and ensuring the software developers can use this library can be expensive. Development processes have to be adapted to ensure that the library is used.
example of risk .
Requirements change> Project and product >There will be a larger number of changes to the requirements than anticipated.
3. Different stakeholders have different requirements and they may express these in different ways
Requirements engineers have to discover all potential sources of requirements and discover commonalities and conflict.
Change management for software products (e.g., a CAD system product) rather than systems that
are specifically developed for a certain customer, has to be handled in a slightly different way
, use case diagrams should use lines without arrowes
arrows as arrows in the UML indicate the direction of flow of messages
The UML does not support data-flow diagrams
as they were originally proposed and used for modeling data processing
2. Minimization strategies
following these strategies means that the impact of the risk will be reduced. An example of a risk minimization strategy is the strategy for staff illness
Frameworks support design reuse in that they provide a skeleton architecture
for the application as well as the reuse of specific classes in the system
1. The probability of the risk
ight be assessed as very low ( 10%), low (10-25%), moderate (25-50%), high (50-75%), or very high ( 75%).
Incremental development
in some form is now the most common approach for the development of application systems
Examples of product metrics
include the system size, measured in lines of code, or the number of methods associated with each object class.
An association is a link between classes that
indicates that there is a relationship between these classes. each class may have to have some knowledge of its associated class
The rectangle on the dotted lines
indicates the lifeline of the object concerned (i.e., the time that object instance is involved in the computation).
Therefore whatever software process model is used,
it is essential that it can accommodate changes to the software being developed.
developing the software incrementally
it is cheaper and easier to make changes in the software as it is being developed.
After a change request has been submitted,
it is checked to ensure that it is valid.
This layered approach supports the incremental development of systems
layer is developed, some of the services provided by that layer may be made available to users
The checker may be from a customer or application support team
or, for internal requests, may be a member of the development team
Risk monitoring
s the process of checking that your assumptions about the product, process, and business risks have not changed
The MVC pattern
separates elements of a system, allowing them to change independently
3. A structural perspective,
where you model the organization of a system or the structure of the data that is processed by the system.
Component design
where you take each system component and design how it will operate
Configuration management is sometimes considered to be part of software quality management
with the same manager having both quality management and configuration management responsibilities
User and system requirements
write requirements at different levels of detail because different readers use them in different ways
Developers check out components from the public repository
y into their private workspace and may change these as they wish in their private workspace
Validation
Validating requirements locally with users - through mock-ups and scenario-based models - will reduce the risk of starting development on the basis of an incomplete or inaccurate specification of the static elements of the system
Non-functional requirements
are requirements that are not directly concerned with the specific services delivered by the system to its users.
The MDA method recommends that three types of abstract system model should be produced:
1. A computation independent model (CIM) that models the important domain abstractions used in the system.
The first step in scoping many projects is a feasibility study and this is very often a technical rather than a commercial decision. Examples include:
1. A technical study to see if a legacy database contains accurate enough data to allow an enhancement. 2. A pilot to evaluate the feasibility of reverse-engineering an existing process
most users of the UML thought that five diagram types could represent the essentials of a system:
1. Activity diagrams 2. Use case diagrams 3. Sequence diagrams 4. Class diagrams 5. State diagrams
There are three basic methods for estimating the scale of the problem
1. Guesses (estimates made by experienced practitioners) 2. Revisions of previous guesses (based on the actual effort required to deliver similar projects) 3. Statistical manipulation of guesses, where the guesses become parameters of a calculation
Although each framework includes slightly different functionality, most web application frameworks support the following features:
1. Security WAFs may include classes to help implement user authentication (login) and access control to ensure that users can only access permitted functionality in the system.
I have assumed that the sequence of actions in using the microwave is:
1. Select the power level (either half power or full power). 2. Input the cooking time using a numeric keypad. 3. Press Start and the food is cooked for the given time.
For a company involved in software development, there are two open source issues that have to be considered:
1. Should the product that is being developed make use of open source components? 2. Should an open source approach be used for the software's development?
Important organizational questions for project managers include
1. Should the project manager be the technical leader of the group? 2. Who will be involved in making critical technical decisions, and how will these be made?
There are many different software processes but all must include four activities that are fundamental to software engineering:
1. Software specification The functionality of the software and constraints on its operation must be defined. 2. Software design and implementation The software to meet the specification must be produced. 3. Software validation The software must be validated to ensure that it does what the customer wants. 4. Software evolution The software must evolve to meet changing customer needs
There are four fundamental activities that are common to all software processes
1. Software specification, where customers and engineers define the software that is to be produced and the constraints on its operation
here are several reasons why change is inevitable:
1. The business and technical environment of the system always changes after installation
costs associated with reuse:
1. The costs of the time spent in looking for software to reuse and assessing whether or not it meets your needs
Architectural views
1. What views or perspectives are useful when designing and documenting a system's architecture? 2. What notations should be used for describing architectural models?
The main differences between these approaches are as follows:
2. Application frameworks are primarily focused on providing technical rather than domain-specific support
Extreme programming involves a number of practices, .
2. Customer involvement is supported through the continuous engagement of the customer in the development team.
The components at each level in the product line system are as follows:.
3. At the resource management level (level 3) there are components that allow vehicles to be located and despatched, components to update the status of vehicles and equipment, and a component to log details of incidents
During the requirements validation process, different types of checks should be carried out on the requirements in the requirements document..
3. Completeness checks The requirements document should include requirements that define all functions and the constraints intended by the system user.
Although each framework includes slightly different functionality, most web application frameworks support the following features:..
3. Database support Frameworks don't usually include a database but rather assume that a separate database, such as MySQL, will be used. The framework may provide classes that provide an abstract interface to different databases
The effectiveness and efficiency of communications is influenced by...
3. Group composition People with the same personality types (discussed in Section 22.2) may clash and, as a result, communications can be inhibited.
The key stages in this component measurement process are:...
3. Measure component characteristics The selected components are measured and the associated metric values computed.
To use patterns in your design, you need to recognize that any design problem you are facing may have an associated pattern that can be applied,
3. Provide a standard way of accessing the elements in a collection, irrespective of how that collection is implemented (Iterator pattern). 4. Allow for the possibility of extending the functionality of an existing class at run-time (Decorator pattern).
plans normally include the following sections:..
3. Risk analysis This describes possible project risks, the likelihood of these risks arising, and the risk reduction strategies that are proposed
There are four fundamental activities that are common to all software processes
3. Software validation, where the software is checked to ensure that it is what the customer requires.
rapid software development, they share some fundamental characteristics:..
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.
costs associated with reuse:..
3. The costs of adapting and configuring the reusable software components or systems to reflect the requirements of the system that you are developing.
System architectures are often modeled using simple block diagrams
Each box in the diagram represents a component. Boxes within boxes indicate that the component has been decomposed to sub-components.
Principles of Agile Methods....
Embrace change Expect the system requirements to change and so design the system to accommodate these changes.
There are four main activities in the requirements engineering process
Feasibility study Requirements elicitation and analysis Requirements specification Requirements validation
4. Much of the research on software measurement and metrics has focused on code-based metrics and plan-driven development processes.
However, more and more software is now developed by configuring ERP systems or COTS, or by using agile methods. We don't know, therefore, if previous research is applicable to these software development techniques.
3. Organizational risks
Risks that derive from the organizational environment where the software is being developed
The representation of the state is private and cannot be accessed directly from outside the object
Object-oriented design processes involve designing object classes and the relationships between these classes
Structural models
Structural models of software display the organization of a system in terms of the components that make up that system and their relationships
The long-term goal of software measurement is to use measurement in place of reviews to make judgments about software quality
Using software measurement, a system could ideally be assessed using a range of metrics and, from these measurements, a value for the quality of the system could be inferred
Measurement ambiguity
When you collect quantitative data about software and software processes, you have to analyze that data to understand its meaning. It is easy to misinterpret data and to make inferences that are incorrect
Generally, you get around this type of conflict by developing models at different levels of detai
Where there are close links between requirements engineers, designers, and programmers, then abstract models may be all that are required.
The arguments in favor of a plan-driven approach are that early planning allows organizational issues
closely taken into account, and that potential problems and dependencies are discovered before the project starts, rather than once the project is under way
Software process models
is a simplified representation of a software process
A deliverable
is a work product that is delivered to the custome
engineering
is all about selecting the most appropriate method for a set of circumstances so a more creative, less formal approach to development may be effective in some circumstances.
Software engineering
is an engineering discipline that is concerned with all aspects of software production from the early stages of system specification through to maintaining the system after it has gone into use.
,Architectural design,
is concerned with understanding how a system should be organized and designing the overall structure of that system
The definition of a system boundary
is not a value-free judgment.
Project planning
is one of the most important jobs of a software project manager
For some simple systems, software design and implementation
is software engineering, and all other activities are merged with this process.
One of the problems of configuration management
is that different companies talk about the same concepts using different terms.
functional user requirements
define specific facilities to be provided by the system
Aggregation
The UML provides a special type of association between classes called aggregation that means that one object (the whole) is composed of other objects (the parts)
2. As a way of documenting an architecture that has been designed
The aim here is to produce a complete system model that shows the different components in a system, their interfaces, and their connections.
These fundamental notions of process
dependability, requirements, management, and reuse
Market opportunity(fACTOR AFFECT PROJECT PRICING )
development organization may quote a low price because it wishes to move into a new segment of the software market
software development organizations
making sure that people's social, esteem, and self-realization needs are satisfied is most importan
Reuse-oriented approaches rely
on a large base of reusable software components and an integrating framework for the composition of these components.
Once you have drawn up an initial risk management plan,
ou monitor the situation to detect emerging risks.
2. The expected software lifetime If you are developing a long-lifetime system, you should focus on the maintainability of the system
You should not just think about the immediate benefits of reuse but also of the long-term implications
Risk monitoring
You should regularly assess the risk and your plans for risk mitigation and revise these when you learn more about the risk.
class diagrams look like
emantic data models. Semantic data models are used in database design
When expressed as user requirements
functional requirements are usually described in an abstract way that can be understood by system users
Data-driven modeling usefulness
They are particularly useful during the analysis of requirements as they can be used to show end-to-end processing in a system
3. Acceptance testing
This is the final stage in the testing process before the system is accepted for operational use.
This GANTT chart assigns a bar (and therefore resource) to reworking that arises from unsuccessful milestone review
This means that a known level of resources have been scheduled to reworking.
Roles
reflect the responsibilities of the people involved in the process. Examples of roles are project manager
two actors in this use case
the operator who is transferring the data and the patient record system.
the project manager role in risk identification process
the project manager may simply use his or her experience to identify the most probable or critical risks.
Effective risk management makes it easier
to cope with problems and to ensure that these do not lead to unacceptable budget or schedule slippage
2. An interaction perspective
where you model the interactions between a system and its environment or between the components of a system.
5. State diagrams,
which show how the system reacts to internal and external events
There are many different types of application including
. Interactive transaction-based applications These are applications that execute on a remote computer and that are accessed by users from their own PCs or terminals
Interviews may be of two type
1. Closed interviews, where the stakeholder answers a pre-defined set of questions. 2. Open interviews, in which there is no pre-defined agenda. The requirements engineering team explores a range of issues with system stakeholders and hence develop a better understanding of their needs.
four critical factors in people management
1. Consistency 2. Respect 3. Inclusion 4. Honesty
There are two types of technique that can be used to do this:
1. Experience-based techniques The estimate of future effort requirements is based on the manager's experience of past projects and the application domain. Essentially, the manager makes an informed judgment of what the effort requirements are likely to be.
The main arguments for and against MDE are
1. For MDE Model-based engineering allows engineers to think about systems at a high level of abstraction, without concern for the details of their implementation
The effectiveness and efficiency of communications is influenced by,
1. Group size As a group gets bigger, it gets harder for members to communicate effectively
A software prototype can be used in a software development process to help anticipate changes that may be required
1. In the requirements engineering process, a prototype can help with the elicitation and validation of system requirements. 2. In the system design process, a prototype can be used to explore particular software solutions and to support user interface design.
Extreme programming involves a number of practices,
1. Incremental development is supported through small, frequent releases of the system.
plans normally include the following sections:
1. Introduction This briefly describes the objectives of the project and sets out the constraints (e.g., budget, time, etc.) that affect the management of the project.
hree advantages of explicitly designing and documenting software architecture:
1. Stakeholder communication 2. System analysis 3. Large-scale reuse
When you use the UML to develop a design, you will normally develop two kinds of design model:
1. Structural models, 2. Dynamic models,
Most open source licenses are derived from one of three general models:
1. The GNU General Public License (GPL). This is a so-called 'reciprocal' license
During the requirements validation process, different types of checks should be carried out on the requirements in the requirements document
1. Validity checks A user may think that a system is needed to perform certain functions.
Version management systems normally provide a range of features:
1. Version and release identification 2. Storage management 3. Change history recording 4. Independent development 5. Project support
Example of layered
A layered model of a system for sharing copyright documents held in different libraries
Project planning takes place at three stages in a project life cycle.
2. During the project startup phase, when you have to plan who will work on the project, how the project will be broken down into increments, how resources will be allocated across your company
Although each framework includes slightly different functionality, most web application frameworks support the following features:.
2. Dynamic web pages Classes are provided to help you define web page templates and to populate these dynamically with specific data from the system database.
The effectiveness and efficiency of communications is influenced by....
2. Group structure People in informally structured groups communicate more effectively than people in groups with a formal, hierarchical structure
plans normally include the following sections:.
2. Project organization This describes the way in which the development team is organized, the people involved, and their roles in the team.
There are four fundamental activities that are common to all software processes
2. Software development, where the software is designed and programmed.
Project activities are the basic planning element. Each activity has.
3. A deadline by which the activity should be completed. 4. A defined endpoint. This represents the tangible result of completing the activity. This could be a document, the holding of a review meeting, the successful execution of all tests, et
Incremental delivery has a number of advantages:...
4. As the highest-priority services are delivered first and increments then integrated, the most important system services receive the most testing.
Business modelling
Activity diagram Class diagram Use case diagram Data flow diagram
Architectural design decisions
Architectural design is a creative process where you design a system organization that will satisfy the functional and non-functional requirements of a system
You create structural models of a system when you are discussing and designing the system architecture.
Architectural design is a particularly important topic in software engineering and UML component, package, and deployment diagrams may all be used when presenting architectural model
4. Honesty
As a manager, you should always be honest about what is going well and what is going badly in the team
Software Requirements Specifications
escriptions of 'Software Requirements Specification' (SRS) documents can be found in Sommerville, Karl Viegers (see: www.processimpact.com/goodies.shtml) (the RUP-based origin of the outline referenced in Pressman) and, of course, the UP itself.
ricing to win means that a company has some idea of the price that the customer
expects to pay and makes a bid for the contract based on the customer's expected price. This may seem unethical and unbusinesslike, but it does have advantages for both the customer and the system provider
Versions implement proposals for change, corrections of faults, and adaptations
for different hardware and operating systems
The advantage of relying on other systems
for patient information is that you avoid duplicating data
Following this analysis, a separate group should then decide if it is costeffective
from a business perspective to make the change to the software
an object class can be thought of as a
general definition of one kind of system object
Software design and implementation.
involves processes of software design and programming but, if an incremental approach to development is used, may also involve refinement of the software specification
The most important aspect of a system model
is that it leaves out detail
The principal argument against plan-driven development
is that many early decisions have to be revised because of changes to the environment in which the software is to be developed and used
When showing the associations between classes
it is convenient to represent these classes in the simplest possible way.
In agile processes
it is generally accepted that an early stage of the development process should be concerned with establishing an overall system architecture
Reuse-oriented software engineering....
leads to faster delivery of the software
This means that common information will be
maintained in one place only.
4. Tool support Requirements
management involves the processing of large amounts of information about the requirements.
Social and organizational concerns may mean that the position of a system boundary
may be determined by non-technical factors. For example, a system boundary may be deliberately positioned so that the analysis process can all be carried out on one site
Motivation
means organizing the work and the working environment to encourage people to work as effectively as possible
good software engineers are
not necessarily good people managers
n practice, you have to use several knowledge sources to discover object classes.
Object classes, attributes, and operations that are initially identified from the informal system description can be a starting point for the design
The WBS does not in itself carry any timing or inter-dependency information
One good way of informing the design of the GANTT chart is to design a Product Flow Diagram (PFD) linking the outputs of each task
Open source development
Open source development is an approach to software development in which the source code of a software system is published and volunteers are invited to participate in the development process
Reuse-oriented software engineering has the obvious advantage
of reducing the amount of software to be developed and so reducing cost and risks
Codelines normally apply to components
of systems so that there are different versions of each component. A baseline is a definition of a specific system
Real software processes are interleaved sequences
of technical, collaborative, and managerial activities with the overall goal of specifying, designing, implementing, and testing a software system
Your judgment must depend on a combination
of the probability of the risk arising and the effects of that risk
The primary aims of analysis are to ensure the accuracy and completeness of the understanding of the customer's needs, which may influence the scope of the projec
Prioritisation of the specific requirements allows functionality to be allocated to the first or subsequent iterations of the project.
Deltas are usually stored as lists of changed lines and, by applying these automatically,
one version of a component can be created from another
You have to coordinate these parallel tasks
organize the work so that the workforce is used optimally and you don't introduce unnecessary dependencies between the tasks
Relationships between internal and external software.
Reliability related to Cyclomatic Complexity,Program Size in Lines of Code,Number of Error Messages
Relationships between internal and external software..
Reusability related to Depth of Inheritance Tree,Program Size in Lines of Code
Software reuse
Reuse-based software engineering is a software engineering strategy where the development process is geared to reusing existing software
Increased dependability
Reused software, which has been tried and tested in working systems, should be more dependable than new software. Its design and implementation faults should have been found and fixed
An outline of the process of risk management
Risk identification risk analysis risk planning risk monitoring
Risk identification,
Risk identification is the first stage of the risk management process
Risk management
Risk management is one of the most important jobs for a project manager
Business risks
Risks that affect the organization developing or procuring the software.
Project risks
Risks that affect the project schedule or resources
Product risks
Risks that affect the quality or performance of the software being developed
5. Requirements risks
Risks that derive from changes to the customer requirements and the process of managing the requirements change
1. Technology risks
Risks that derive from the software or hardware technologies that are used to develop the system
4. Tools risks
Risks that derive from the software tools and other support software used to develop the system.
Once some decisions on the boundaries of the system have been made
part of the analysis activity is the definition of that context and the dependencies that a system has on its environment.
Non-functional requirements, such as
performance, security, or availability, usually specify or constrain characteristics of the system as a whole
Each process model
represents a process from a particular perspective, and thus provides only partial information about that process.
In software products, the customer is not directly involved in decisions about system evolution,
so the relevance of the change to the customer's business is not an issue.
Use case diagrams give a fairly simple overview of an interaction
so you have to provide more detail to understand what is involved
For mass- market software, it is usually possible to identify two types of release namely major releases,
which deliver significant new functionality, and minor releases, which repair bugs and fix customer problems that have been reported
3. Sequence diagrams
which show interactions between actors and the system and between system components.
Patterns have made a huge impact on object-oriented software design.
As well as being tested solutions to common problems, they have become a vocabulary for talking about a design.
Preparing and distributing a system release is an expensive process, particularly for mass-market software products
As well as the technical work involved in creating a release distribution, advertising and publicity material have to be prepared and marketing strategies put in place to convince customers to buy the new release
The objects and actors involved are listed along the top of the diagram
with a dotted line drawn vertically from these. Interactions between objects are indicated by annotated arrows.
Some of these tasks are carried out in parallel
with different people working on different components of the system.
Accelerated development
Bringing a system to market as early as possible is often more important than overall development costs. Reusing software can speed up system production because both development and validation time may be reduced.
Planning at the proposal stage is inevitably speculative, as you do not usually have a complete set of requirements for the software to be developed
you have to respond to a call for proposals based on a high-level description of the software functionality that is required.
A subsystem model is a useful static model as it shows how a design is organized into logically related groups of objects
I have already shown this type of model in Figure 7.4 to show the subsystems in the weather mapping system
Not-invented-here syndrome
Some software engineers prefer to rewrite components because they believe they can improve on them.
example of risk
Staff turnover Project Experienced staff will leave the project before it is finished.
Some large companies provide a range of reusable components for their customers.
Standards, such as web service standards, have made it easier to develop general services and reuse them across a range of applications.
The UML supports event-based modeling using state diagrams
State diagrams show system states and events that cause transitions from one state to another.
Incremental development.
Incremental development is based on the idea of developing an initial implementation, exposing this to user comment and evolving it through several versions until an adequate system has been developed
2. To identify the system components whose quality is substandard
Measurements can identify individual components with characteristics that deviate from the norm. For example, you can measure components to discover those with the highest complexity.
COTS product reuse
Systems are developed by configuring and integrating existing application systems.
Component-based development
Systems are developed by integrating components (collections of objects) that conform to component-model standards.
Service-oriented systems
Systems are developed by linking shared services, which may be externally provided
example of risk,
Technology change >Business>>> The underlying technology on which the system is built is superseded by new technology.
Plan-driven development and agile development
The essence of a plan-driven approach to a project is that the customer and developer commit to a detailed project plan (specifying and scheduling release of a series of products) before entering the construction phase
Risk Management Process
The method of making, implementing, and monitoring decisions that minimize the adverse effects of risk on an organization.
Reuse
The only significant reuse or software was the reuse of functions and objects in programming language libraries.
The availability of reusable software has increased dramatically
The open source movement has meant that there is a huge reusable code base available at low cost
The availability of reusable software has increased dramatically.
The open source movement has meant that there is a huge reusable code base available at low cost.
Objects include both data and operations to manipulate that data
They may therefore be understood and modified as stand-alone entities.
Each of these use cases should be described in structured natural language
This helps designers identify objects in the system and gives them an understanding of what the system is intended to do
One of the most effective ways of promoting cohesion is to be inclusive.
This means that you should treat group members as responsible and trustworthy, and make information freely available.
Weighted methods per class (WMC)
This is the number of methods in each class, weighted by the complexity of each method. Therefore, a simple method may have a complexity of 1, and a large and complex method a much higher value
Requirements elicitation and analysis
This is the process of deriving the system requirements through observation of existing systems, discussions with potential users and procurers, task analysis, and so on.
the well-known Model-View-Controller pattern
This pattern is the basis of interaction management in many web-based systems
Putting together a group that has the right balance of technical skills, experience, and personalities is a critical management task.
successful groups are more than simply a collection of individuals with the right balance of skills.
Finally, the cost of making the change is estimated,
taking into account the costs of changing related components
stakeholders should also be concerned with non-technical issue
that affect a project's feasibility. According to Figure 1.6 in the previous chapter, the purpose of the inception phase of a UP project is to produce a set of artefacts that allow the two prime project stakeholder groups, the customer(s) and their supplier(s) to determine the feasibility of a new project (or new iteration of an existing project).
Deliverables are work products
that are delivered to the customer (e.g., a requirements document for the system)
The baseline therefore specifies the component versions
that are included in the system plus a specification of the libraries used, configuration files, etc
Many business systems are data processing systems
that are primarily driven by data.
A use case can be taken as a simple scenario
that describes what a user expects from a system.
Risk identification
You should identify possible project, product, and business risks.
It is important that software project managers understand the technical issues
that influence the work of software development
Each use case represents a discrete task
that involves external interaction with a system.
Enterprise Resource Planning (ERP) systems, such as the SAP system, are the best examples of this approach
a large and complex system is adapted for a company by incorporating information about business rules and processes, reports required, and so on
During the architectural design process, system architects have to make a number of structural decisions
that profoundly affect the system and its development process.
If more defects have been found in the same amount of time,
after the tool has been introduced, then you may decide that it provides useful support for the software validation process.
Requirements documents are essential when an outside contractor is developing the software system
agile development methods argue that requirements change so rapidly that a requirements document is out of date as soon as it is written,
As well as subsystem models, you may also design detailed object models, showing
all of the objects in the systems and their associations (inheritance, generalization, aggregation, etc.)
Standardization
also an important first step in introducing new software engineering methods and techniques and good software engineering practice
Architectural design,
architectural design is the first stage in the software design process
A software product line is a set of applications with a common
architecture and shared components, with each application specialized to reflect different requirements
the problems that arise during the requirements engineering process
are a result of failing to make a clear separation between these different levels of description
In a generalization, the attributes and operations associated with higher-level classes
are also associated with the lower-level classes
Customers may use a webpage or e-mail to report bugs. A bug management team then checks that
the bug reports are valid and translates them into formal system change requests.
when the communications subsystem receives a control command, such as shutdown,
the command is picked up by each of the other subsystems, which then shut themselves down in the correct way
Change requests for these products come from the customer support team,
the company marketing team and the developers themselves.
In traditional development processes
the complete schedule is initially developed and then modified as the project progresses
Static metrics help assess
the complexity, understandability, and maintainability of a software system or system components.
Data-flow models are useful because
tracking and documenting how the data associated with a particular process moves through the system helps analysts and designers understand what is going on
To support independent development without interference, version management systems
use the concept of a public repository and a private workspace.
Once the risks have been analyzed and ranked
you should assess which of these risks are most significant
5. Analyze anomalous components When you have identified components that have anomalous values for your chosen metrics,
you should examine them to decide whether or not these anomalous metric values mean that the quality of the component is compromised.
Engineering discipline
Engineers make things work
3. System building This is the process of assembling program components
data, and libraries, and then compiling and linking these to create an executable system
These small requests should be passed to the development team without
detailed analysis, as such an analysis could cost more than implementing the change.
Repository architecture....
Example Figure 6.9 is an example of an IDE where the components use a repository of system design information. Each software tool generates information which is then available for use by other tools.
When planning a project, you should also define milestone
each stage in the project where a progress assessment can be made
Model-driven engineering
Model-driven engineering (MDE) is an approach to software development here models rather than programs are the principal outputs of the development process
Teamwork
Most professional software is developed by project teams that range in size from two to several hundred people
Selecting group members
A manager or team leader's job is to create a cohesive group and organize their group so that they can work together effectively
client-server Example
film and video/DVD library organized as a client-server system
An agile development team does not expect to be constrained by a detailed plan
(although high-level planning may be required by the principle of 'serial in the large, iterative in the small') since the 'constant' is not the product but the timing of the iteration cycle. Functionality is dynamically prioritised and allocated to a planned release.
Because it is a creative process, the activities within the process depend on the type of system being developed
, the background and experience of the system architect, and the specific requirements for the system
For most projects,
, the biggest cost is the effort cost
The UML has a rich syntax for sequence diagrams
, which allows many different kinds of interaction to be modeled
The process activities are:
1. Requirements discovery 2. Requirements classification and organization 3. Requirements prioritization and negotiation 4. Requirements specification
A software metric is a characteristic of a software system, system documentation, or development process that can be objectively measured
. Examples of metrics include the size of a product in lines of code; the Fog index (Gunning, 1962), which is a measure of the readability of a passage of written text
5. Project support A version management system may support the development of several projects, which share components
. In project support systems, such asCVS (Vesperman, 2003), it is possible to check in and check out all of the files associated with a project rather than having to work with one file or directory at a time
The benefits of creating a cohesive group are:
1. The group can establish its own quality standards 2. Individuals learn from and support each other 3. Knowledge is shared Continuity can be maintained if a group member leaves 4. Refactoring and continual improvement is encouraged
Significant factors that should be taken into account in deciding whether or not a change should be approved are:...
4. The costs of making the change If making the change affects many system components (hence increasing the chances of introducing new bugs) and/or takes a lot of time to implement, then the change may be rejected, given the elevated costs involved.
The effectiveness and efficiency of communications is influenced by..
4. The physical work environment The organization of the workplace is a major factor in facilitating or inhibiting communications
fundamental questions about the system:.
4. What will be the fundamental approach used to structure the system? 5. How will the structural components in the system be decomposed into subcomponents? 6. What strategy will be used to control the operation of the components in the system?
Contractual terms
A customer may be willing to allow the developer to retain ownership of the source code and reuse it in other projects. The price charged may then be less than if the software source code is handed over to the customer.
3. Large-scale reuse
A model of a system architecture is a compact, manageable description of how a system is organized and how the components interoperate.
Prototyping
A prototype is an initial version of a software system that is used to demonstrate concepts, try out design options
In a UML activity diagram, arrows represent the flow of work from one activity to another.
A solid bar is used to indicate activity coordination. When the flow from more than one activity leads to a solid bar then all of these activities must be complete before progress is possible
Repository architecture..
Advantages Components can be independent—they do not need to know of the existence of other components. Changes made by one component can be propagated to all components. All data can be managed consistently (e.g., backups done at the same time) as it is all in one place.
Advantages of layered architecture
Advantages of layered architecture
Advantages
Allows the data to change independently of its representation and vice versa. Supports presentation of the same data in different ways with changes made in one representation shown in all of them.
Open source licensing
Although a fundamental principle of open-source development is that source code should be freely available
Artefacts
An output from the project, or 'product', is known in the UP as an 'artefact'. There are many definitions of artefact in different contexts, but the one we will focus on is that it is something that allows another, higher level, product to be constructed.
he design process for information system
Architectural design Interface design Component design Database design
Disadvantages
Can involve additional code and code complexity when the data model and interactions are simple
Change management
Change is a fact of life for large software systems
Coping with change
Change is inevitable in all large software projects
Architectural design
Class diagram Sequence diagram Component diagram Activity or sequence diagram State diagram Deployment diagram
Class diagrams
Class diagrams are used when developing an object-oriented system model to show the classes in a system and the associations between these classes
What are the key challenges facing software engineering?
Coping with increasing diversity, demands for reduced delivery times, and developing trustworthy software.
Data-driven modeling
Data-driven models show the sequence of actions involved in processing input data and generating an associated output
there are software engineering fundamentals that apply to all types of software system
Dependability and performance are important for all types of systems. Software should behave as expected, without failures and should be available for use when it is required
Repository architecture,
Description All data in a system is managed in a central repository that is accessible to all system components. Components do not interact directly, only through the repository
Design and implementation
Design and implementation
Design models
Design or system models, as I discussed in Chapter 5, show the objects or object classes in a system.
2. The build server, which is used to build definitive, executable versions of the system. This interacts closely with the version management system
Developers check in code to the version management system before it is built. The system build may rely on external libraries that are not included in the version management system.
Repository architecture.
Disadvantages The repository is a single point of failure so problems in the repository affect the whole system. May be inefficiencies in organizing all communication through the repository. Distributing the repository across several computers may be difficult
In a wide range of domains, it is now possible to buy off-the-shelf systems (COTS) that can be adapted and tailored to the users' requirements.
For example, if you want to implement a medical records system, you can buy a package that is already used in hospitals
Most software development is a team activity, so situations often arise where different team members work on the same component at the same time
For example, let's say Alice is making some changes to a system, which involves changing components A, B, and C. At the same time, Bob is working on changes and these require making changes to components X, Y, and C
Interviewing
Formal or informal interviews with system stakeholders are part of most requirements engineering processes
functional and non functonal requirement
Functional requirements describe the way the system behaves. Non-functional requirements describe the context within which that system behaviour is delivered.
Generalization
Generalization is an everyday technique that we use to manage complexity
Design patterns...
Generic abstractions that occur across applications are represented as design patterns showing abstract and concrete objects and interactions.
Disadvantages of layered
In practice, providing a clean separation between layers is often difficult and a high-level layer may have to interact directly with lower-level layers rather than through the layer immediately below it. Performance can be a problem because of multiple levels of interpretation of a service request as it is processed at each layer.
. Their configuration management systems and processes have to be designed to provide information about which customers have which releases of the system and the relationship between releases and system versions
In the event of a problem, it may be necessary to reproduce exactly the software that has been delivered to a particular customer
you can see that different baselines use different versions of the components from each codeline
In the diagram, I have shaded the boxes representing components in the baseline definition to indicate that these are actually references to components in a codeline.
software failures are a consequence of two factors:
Increasing demands Low expectations
Principles of Agile Methods.
Incremental delivery The software is developed in increments with the customer specifying the requirements to be included in each increment.
Incremental delivery.
Incremental delivery (Figure 2.10) is an approach to software development where some of the developed increments are delivered to the customer and deployed for use in an operational environment.
Legacy system wrapping
Legacy systems (see Chapter 9) are 'wrapped' by defining a set of interfaces and providing access to these legacy systems through these interfaces.
Length of code,
Length of code has been shown to be one of the most reliable metrics for predicting error-proneness in components
Principles of Agile Methods....;
Maintain simplicity Focus on simplicity in both the software being developed and in the development process. Wherever possible, actively work to eliminate complexity from the system.
Relationships between internal and external software
Maintainability (external )related to Depth of Inheritance Tree ,Cyclomatic Complexity,Program Size in Lines of Code,Length of User Manual
2. System analysis
Making the system architecture explicit at an early stage in the system development requires some analysis.
example of risk .
Management change >>Project >>There will be a change of organizational management with different priorities
2. There are no standards for software metrics or standardized processes for measurement and analysis
Many companies are reluctant to introduce measurement programs until such standards and supporting tools are available.
Risk types and examples
Organizational financial problems force reductions in the project budget (7). Low Catastrophic
Product metrics
Product metrics are predictor metrics that are used to measure internal attributes of a software system
Description of MVC
Separates presentation and interaction from the system data. The system is structured into three logical components that interact with each other. The Model component manages the system data and associated operations on that data
Finding, understanding, and adapting reusable components
Software components have to be discovered in a library, understood and, sometimes, adapted to work in a new environment. Engineers must be reasonably confident of finding a component in the library before they include a component search as part of their normal development process
Sequence Diagram
Shows the timing of interactions between objects as they occur
All aspects of software production
Software engineering is not just concerned with the technical processes of software development. It also includes activities such as software project management and the development of tools, methods, and theories to support software production.
Software measurement and metrics
Software measurement is concerned with deriving a numeric value or profile for an attribute of a software component, system, or process.
What are the fundamental software engineering activities?
Software specification, software development, software validation, and software evolution.
Functional and non-functional requirements
Software system requirements are often classified as functional requirements or nonfunctional requirements
There are many different types of application including
Stand-alone applications These are application systems that run on a local computer, such as a PC
Architectural patterns,,
Standard software architectures that support common types of application systems are used as the basis of applications
1. Development testing
The components making up the system are tested by the people developing the system
Incremental development has three important benefits, compared to the waterfall model:
The cost of accommodating changing customer requirements is reduced. It is easier to get customer feedback on the development work that has been done More rapid delivery and deployment of useful software to the customer is possible, even if all of the functionality has not been included
System context and interactions
The first stage in any software design process is to develop an understanding of the relationships between the software that is being designed and its external environment.
Software evolution
The flexibility of software systems is one of the main reasons why more and more software is being incorporated in large, complex systems
Disadvantages of pipe
The format for data transfer has to be agreed upon between communicating transformations. Each transformation must parse its input and unparse its output to the agreed form.
The UML has a specific type of association to denote generalization
The generalization is shown as an arrowhead pointing up
goal of milestones in software engineering
The goal is to minimise the wasted work that results from re-iteration of previous phases.
Architectural patterns
The idea of patterns as a way of presenting, sharing, and reusing knowledge about software systems is now widely used.
Software design and implementation
The implementation stage of software development is the process of converting a system specification into an executable system
This spiral model accommodates approaches to development where the requirements are developed to different levels of detail.
The number of iterations around the spiral can vary so the spiral can be exited after some or all of the user requirements have been elicited. Agile development can be used instead of prototyping so that the requirements and the system implementation are developed together
Requirements specification..
The requirements are documented and input into the next round of the spiral. Formal or informal requirements documents may be produced,
They are passed directly to the system developer.
The system developer either accepts them or makes a case for why they are not required.
3. Acceptance testing.
The system is tested with data supplied by the system customer rather than with simulated test data.
System requirements are more detailed descriptions of the software system's functions, services, and operational constraints
The system requirements document (sometimes called a functional specification) should define exactly what is to be implemented. It may be part of the contract between the system buyer and the software developers.
a software process
The systematic approach that is used in software engineering is sometimes called
Frameworks are an effective approach to reuse, but are expensive to introduce into software development processes.
They are inherently complex and it can take several months to learn to use them. It can be difficult and expensive to evaluate available frameworks to choose the most appropriate one
Length of identifiers
This is a measure of the average length of identifiers (names for variables, classes, methods, etc.) in a program.
The impact of the change on the rest of the system must be checked
To do this, you have to identify all of the components affected by the change
Version management
Version management (VM) is the process of keeping track of different versions of software components or configuration items and the systems in which these components are used.
Web application frameworks (WAFs) are a more recent and very important typemof framework
WAFs that support the construction of dynamic websites are now widely available. The architecture of a WAF is usually based on the Model-ViewController (MVC) composite pattern
You use knowledge of the application domain to identify other objects, attributes, and services
We know that weather stations are often located in remote places and include various instruments that sometimes go wrong
An MVC framework supports the presentation of data in different ways and allows interaction with each of these presentations.
When the data is modified through one of the presentations, the system model is changed and the controllers associated with each view update their presentation
Specific design decisions may be made as the system is implemented, with problems resolved through informal discussions.
When the links between system specifiers, designers, and programmers are indirect (e.g., where a system is being designed in one part of an organization but implemented elsewhere), then more detailed models are likely to be needed.
pipe and filter used
When used Commonly used in data processing applications (both batch- and transaction-based) where inputs are processed in separate stages to generate related outputs
sequence diagram reading
You read the sequence of interactions from top to bottom
The process then enters a loop
You draw up an estimated schedule for the project and the activities defined in the schedule are initiated or given permission to continue
Risk analysis
You should assess the likelihood and consequences of these risks.
The waterfall model is an example of
a plan-driven process
h plan-based and agile processes need
an initial project schedule, although the level of detail may be less in an agile project plan.
You have to anticipate risks;
understand the impact of these risks on the project, the product, and the business; and take steps to avoid these risks
a software engineer is given a program design for coding and notices
what appears to be possible improvements that could be made to the design
Exchanging profit for opportunity such as:
• entry into new market or working with new client • retention of rights to use code • gaining experience, skills or specialist staff.
It decides whether the change in question is economically justified and prioritizes accepted changes for implementation
Accepted changes are passed back to the development group; rejected change requests are closed and no further action is taken
functional system requirement example
A user shall be able to search the appointments lists for all clinics
three related categories of risk:
Project risks Product risks business risks
what are the output of architectural design
The output of the architectural design process is an architectural model that describes how the system is organized as a set of communicating components
client-server Advantages
The principal advantage of this model is that servers can be distributed across a network. General functionality (e.g., a printing service) can be available to all clients and does not need to be implemented by all service
From a management perspective, the incremental approach has two problems:
The process is not visible System structure tends to degrade as new increments are added.
Use cases are documented using a high-level use case diagram
The set of use cases represents all of the possible interactions that will be described in the system requirements
Behavioral models
Behavioral models are models of the dynamic behavior of the system as it is executing.
Fan-in/Fan-out
Fan-in is a measure of the number of functions or methods that call another function or method (say X). Fan-out is the number of functions that are called by function X
These types of metric are related to different quality attributes
Dynamic metrics help to assess the efficiency and reliability of a program
the bar chart or GANTT chart
Each bar (representing the expected start and finish dates) has an implied or explicit relationship with others - its predecessors and successors. Overlap of parts of two bars means they are concurrent. Most project planning software (such as Microsoft Project) maps 'work to task' as well as 'task to time'
what requirement document include
It should include both the user requirements for a system and a detailed specification of the system requirements
Modeling user interaction is important as it helps to identify user requirements.
Modeling system to system interaction highlights the communication problems that may arise
You need to specify interfaces so that objects and subsystems can be designed in parallel.
Once an interface has been specified, the developers of other objects may assume that interface will be implemented
An example of a product risk
is the failure of a purchased component to perform as expected. This may affect the overall performance of the system so that it is slower than expected.
In modeling systems, it is often useful to examine the classes in a system to see if there is
scope for generalization
Risk identification may be a team process
where a team get together to brainstorm possible risks.
1. To satisfy social needs,
you need to give people time to meet their co-workers and provide places for them to meet
A software process
is a sequence of activities that leads to the production of a software product
Project activities are the basic planning element. Each activity has
1. A duration in calendar days or months. 2. An effort estimate, which reflects the number of person-days or person-months to complete the work.
two questions that should be considered when considering agile methods and maintenance
2. Can agile methods be used effectively for evolving a system in response to customer change requests?
Software engineering ethics.
2. Competence You should not misrepresent your level of competence. You should not knowingly accept work that is outside your competence.
During the requirements validation process, different types of checks should be carried out on the requirements in the requirements document.
2. Consistency checks Requirements in the document should not conflict.
Incremental delivery has a number of advantages:.
2. Customers do not have to wait until the entire system is delivered before they can gain value from it
The waterfall model..
software life cycle
1. System prototyping
where a version of the system or part of the system is developed quickly to check the customer's requirements and the feasibility of some design decisions.
2. Incremental delivery,
where system increments are delivered to the customer for comment and experimentation. This supports both change avoidance and change tolerance.
2. Change tolerance
where the process is designed so that changes can be accommodated at relatively low cost. This normally involves some form of incremental development
As your understanding of the design develops, you refine these ideas about the system objects
The use case description helps to identify objects and operations in the system
here are several reasons why change is inevitable:.
2. The people who pay for a system and the users of that system are rarely the same people. System customers impose requirements because of organizational and budgetary constraints
rapid software development, they share some fundamental characteristics:.
2. The system is developed in a series of versions. End-users and other system stakeholders are involved in specifying and evaluating each version.
Effective interviewers have two characteristics:.
2. They prompt the interviewee to get discussions going using a springboard question, a requirements proposal, or by working together on a prototype system
To minimize misunderstandings when writing natural language requirements, I recommend that you follow some simple guidelines.
2. Use language consistently to distinguish between mandatory and desirable requirements.
The components at each level in the product line system are as follows:.
4. At the database level, as well as the usual transaction management support, there are separate databases of vehicles, equipment, and maps.
Software engineering ethics...
4. Computer misuse You should not use your 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 or other malware).
More and more systems are now being built with a generic product as a base, which is then adapted to suit the requirements of a customer
Enterprise Resource Planning (ERP) systems, such as the SAP system, are the best examples of this approach
extreme programming requirement collection
Extreme Programming (Beck, 1999) collect user requirements incrementally and write these on cards as user stories.
Cost estimate uncertainty
If an organization is unsure of its cost estimate, it may increase its price by a contingency over and above its normal profit.
Requirements volatilitY
If the requirements are likely to change, an organization may lower its price to win a contract. After the contract is awarded, high prices can be charged for changes to the requirements.
Group communications
It is absolutely essential that group members communicate effectively and efficiently with each other and with other project stakeholders
risk identification concern with
It is concerned with identifying the risks that could pose a major threat to the software engineering process, the software being developed, or the development organization
Incremental delivery has a number of advantages:
1. Customers can use the early increments as prototypes and gain experience that informs their requirements for later system increments.
Frameworks are implemented as a collection of concrete and abstract object classes in an object-oriented programming language
Therefore, frameworks are language-specific. There are frameworks available in all of the commonly used object-oriented programming languages (e.g., Java, C#, C++, as well as dynamic languages such as Ruby and Python).
Change management is usually supported by specialized software tools.
These may be relatively simple web-based tools such as Bugzilla, which is used to report problems with many open source systems
External requirements This broad heading covers all requirements that are derived from factors external to the system and its development process.
These may include regulatory requirements that set out what must be done for the system to be approved for use by a regulator, such as a central bank;
Batch processing systems
These are business systems that are designed to process data in large batches.
3. Enterprise application frameworks
These are concerned with specific application domains such as telecommunications or financial systems
Embedded control systems
These are software control systems that control and manage hardware devices
Generic products
These are stand-alone systems that are produced by a development organization and sold on the open market to any customer who is able tobuy them
Functional requirements
These are statements of services the system should provide, how the system should react to particular inputs, and how the systemshould behave in particular situations
Systems for modeling and simulation
These are systems that are developed by scientists and engineers to model physical processes or situations,
Entertainment systems
These are systems that are primarily for personal use and which are intended to entertain the user
2. Middleware integration frameworks
These consist of a set of standards and associated object classes that support component communication and information exchange. Examples of this type of framework include Microsoft's
1. System infrastructure frameworks
These frameworks support the development of system infrastructures such as communications, user interfaces, and compilers
1-Version and release identification Managed versions are assigned identifiers when they are submitted to the system
These identifiers are usually based on the name of the configuration item (e.g., ButtonManager), followed by one or more numbers
functional requirement depend on
These requirements depend on the type of software being developed, the expected users of the software, and the general approach taken by the organization when writing requirements
System requirements are expanded versions of the user requirements that are used by software engineers as the starting point for the system design
They add detail and explain how the user requirements should be provided by the system.
More and more companies see their software as a valuable asset
They are promoting reuse to increase their return on software investments
Businesses now operate in a global, rapidly changing environment
They have to respond to new opportunities and markets, changing economic conditions, and the emergence of competing products and services
Non-functional requirements These are constraints on the services or functions offered by the system.
They include timing constraints, constraints on the development process, and constraints imposed by standards. Non-functional requirements often apply to the system as a whole, rather than individual system features or services.
there are software engineering fundamentals that apply to all types of software system:
They should be developed using a managed and understood development process
no motivation
They will work slowly, be more likely to make mistakes, and will not contribute to the broader goals of the team or the organization
he bar chart or GANTT chart
This consists of rows reflecting the hierarchical organisation of tasks in the 'Work Breakdown Structure' (WBS) with time as the horizontal axis
Requirements validation
This activity checks the requirements for realism, consistency, and completeness
generalization hierarchy
This allows us to infer that different members of these classes have some common characteristics (e.g., squirrels and rats are rodents)
Incremental development
This approach interleaves the activities of specification, development, and validation. The system is developed as a series of versions (increments), with each version adding functionality to the previous version.
Reuse-oriented software engineering
This approach is based on the existence of a significant number of reusable components. The system development process focuses on integrating these components into a system rather than developing them from scratch.
5. Introducing measurement adds additional overhead to processes. This contradicts the aims of agile methods
which recommend the elimination of process activities that are not directly related to program development. Companies that have adopted agile methods are therefore not likely to adopt a metrics program.
1. Activity diagrams
which show the activities involved in a process or in data processing.
2. Use case diagrams,
which show the interactions between a system and its environment.
4. Class diagrams
which show the object classes in the system and the associations between these classes.
3. A development view,
which shows how the software is decomposed for development, that is, it shows the breakdown of the software into components that are implemented by a single developer or development team.
2. A process view
which shows how, at run-time, the system is composed of interacting processes. This view is useful for making judgments about nonfunctional system characteristics such as performance and availability
1. A logical view
which shows the key abstractions in the system as objects or object classes. It should be possible to relate the system requirements to entities in this logical view.
4. A physical view,
which shows the system hardware and how software components are distributed across the processors in the system
Milestones are points in the schedule against
which you can assess progress, for example, the handover of the system for testing.
1. Task-oriented people
who are motivated by the work they do. In software engineering, these are people who are motivated by the intellectual challenge of software development.
2. Self-oriented people
who are principally motivated by personal success and recognition. They are interested in software development as a means of achieving their own goals.
it may be called something like a 'product development group',
who is responsible for making decisions about how a software system should evolve
project plan is created that records the work to be done,
who will do it, the development schedule, and the work products
You estimate the calendar time needed to complete each task, the effort required,
who will work on the tasks that have been identified.
Class diagrams in the UML can be expressed at different levels of detail
When you are developing a model, the first stage is usually to look at the world, identify the essential objects, and represent these as classes
User requirements are statements
in a natural language plus diagrams, of what services the system is expected to provide to system users and the constraints under which it must operate.
Change Management Process
includes change request forms, change request log, analysis of changes, CCB, communication with stakeholders, and updating the affected project planning documents.
If a project is technically advanced
initial estimates will almost certainly be optimistic even when you try to consider all eventualitie
This group should review and approve all change requests, unless the changes simply
involve correcting minor errors on screen displays, webpages, or documents.
Scheduling in plan-driven projects
involves breaking down the total work involved in a project into separate tasks and estimating the time required to complete each task
A software process.
is a set of related activities that leads to the production of a software product
Reuse-based software engineering
is a software engineering strategy where the development process is geared to reusing existing software.
A common problem with non-functional requirements
is that users or customers often propose these requirements as general goals, such as ease of use, the ability of the system to recover from failure, or rapid user response
An example of a project risk
is the loss of an experienced designer. Finding a replacement designer with appropriate skills and experience may take a long time and, consequently, the software design will take longer to comp
Project Scheduling.
is the process of deciding how the work in a project will be organized as separate tasks, and when and how these tasks will be executed
A special kind of milestone
is the production of a project deliverable
The cost of fixing a requirements problem by making a system change
is usually much greater than repairing design or coding errors
Software engineers often have strong technical skills
lack the softer skills that enable them tomotivate and lead a project development team
Software metrics
may be either control metrics or predictor metrics
The system developers themselves may
may have some good ideas about new features that can be added to the system
If you use the identifier, this means that the most recent version
of the component should be used in the baseline
Risk management is particularly important for software projects because
of the inherent uncertainties that most projects face
identify which system components implement specific functional requirements
often more difficult to relate components to non-functional requirements.
At the beginning of a planning process,
ou should assess the constraints affecting the project.
This initial schedule is used to plan how people
will be allocated to projects and to check the progress of the project against its contractual commitments
he software is not developed as a single unit but as a series of increments,
with each increment including new system functionality. Although there are many approaches to rapid software development, they share some fundamental characteristics:
2. Security If security is a critical requirement, a layered structure for the architecture should be used,
with the most critical assets protected in the innermost layers, with a high level of security validation applied to these layers.
To make a judgment about these attributes,
you have to measure some internal attributes of the software (such as its size, complexity, etc.) and assume that these are related to the quality characteristics that you are concerned with.
3. The background, skills, and experience of the development team All reuse technologies are fairly complex
you need quite a lot of time to understand and use them effectively. Therefore, if the development team has skills in a particular area, this is probably where you should focus.
When calculating a price,
you should take broader organizational, economic, political, and business considerations into account,
When you model the interactions of a system with its environment
you should use an abstract approach that does not include too much detail.
When you start designing a system, it can be difficult to know, in advance, if you will need a particular pattern
ystem, it can be difficult to know, in advance, if you will need a particular pattern. Therefore, using patterns in a design process often involves developing a design, experiencing a problem, and then recognizing that a pattern can be used
Software specification
requirements engineering is the process of understanding and defining what services are required from the system and identifying the constraints on the system's operation and development
The outcome of a review may be a decision to cancel a project.
result of technical or managerial failings but, more often, is a consequence of external changes that affect the project.
When these design decisions conflict with your particular requirements,
reusing the component is either impossible or introduces inefficiencies into your system.
The most common expression of the network
s the bar chart or GANTT chart
Maslow (1954) suggests that people are motivated by
satisfying their needs. These needs are arranged in a series of levels,
Use case modeling..
se case modeling is widely used to support requirements elicitation.
he layered architecture pattern is another way of achieving
separation and independence
The maximum amount of time for any task
should be around 8 to 10 weeks. If it takes longer than this, the task should be subdivided for project planning and scheduling.
project manager, you should be aware of the potential problems of people management
should try to develop people management skills.
There are differing views about whether or not software architects should use the UML for architectural description
showed that, when the UML was used, it was mostly applied in a loose and informal way. The authors of that paper argued that this was a bad thing
requierment
simply a high-level, abstract statement of a service that a system should provide or a constraint on a system
The lower levels of this hierarchy represent fundamental needs for food,
sleep, and so on, and the need to feel secure in an environment
The pattern is a description of the problem and the essence of its solution
so that the solution may be reused indifferent settings. The pattern is not a detailed specification
you have limited information to make such an estimate
so you have to make the best possible estimate and then add significant contingency (extra time and effort) in case your initial estimate is optimistic
software engineering not same as program
software engineering, software is not just the programs themselves but also all associated documentation and configuration data that is required to make these programs operate correctly
People management, in my view
something that has to be based on experience, rather than learned from a book
Configuration management tools are used to keep track of change proposals
store versions of system components, build systems from these components, and track the releases of system versions to customers
software characteristics that can be easily measured,
such as size and cyclomatic complexity, do not have a clear and consistent relationship with quality attributes such as understandability and maintainability.
2. Static metrics, which are collected by measurements made of representations of the system
such as the design, program, or documentation. Examples of static metrics are the code size and the average length of identifiers used.
They are affected by subjective factors
such as user experience and education, and they cannot therefore be measured objectively.
2. Version management This involves keeping track of the multiple versions of
system components and ensuring that changes made to components by different developers do not interfere with each other.
End-users and customers need a high-level statement of the requirements
system developers need a more detailed system specification.
In a plan-driven approach
system increments are identified in advance; if an agile approach is adopted, the early increments are identified but the development of later increments depends on progress and customer priorities.
A consequence of the independent development of the same componen
t is that codelines may branch. Rather than a linear sequence of versions that reflect changes to the component over time, there may be several independent sequences,
The waterfall model.
takes the fundamental process activities of specification, development, validation, and evolution and represents them as separate process phases such as requirements specification, software design, implementation, testing, and so on
When a plan-driven software process is used (e.g., for critical systems development),
testing is driven by a set of test plans. An independent team of testers works from these pre-formulated test plans, which have been developed from the system specification and design
A group that has complementary personalities may work better than a group
that is selected solely on technical ability. People who are motivated by the work are likely to be the strongest technically
Activity diagrams are intended to show the activities
that make up a system process and the flow of control from one activity to another.
5. The application domain In some application domains, such as manufacturing and medical information systems, there are several generic products
that may be reused by configuring them to a local situation. If you are working in such a domain, you should always consider these as an option.
Functional Requirements
the activities that the system must perform
Example
the architecture of a web-based application system organized using the MVC pattern.
it is only since 2000 that 'development with reuse' has become
the norm for new business systems
These classes define the objects in the system and their interactions. When the design is realized as an executing program,
the objects are created dynamically from these class definitions
Once a contract to develop a system has been awarded
the outline project plan for the project has to be refined to create a project startup plan
System modeling
the process of developing abstract models of a system, with each model presenting a different view or perspective of that system
Requirements specification....
the process of writing down the user and system requirements in a requirements document
impossible to choose a group with complementary personalities
the project manager has to control the group so that individual goals do not take precedence over organizational and group objectives
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
Ethnography
the scientific description of the customs of individual peoples and cultures.
Sequence models are dynamic models that describe, for each mode of interaction
the sequence of object interactions that take place. When documenting a design, you should produce a sequence model for each significant interaction
1. Change management This involves keeping track of requests for changes to
the software from customers and developers, working out the costs and impact of making these changes, and deciding if and when the changes should be implemented.
Software design and implementation is
the stage in the software engineering process at which an executable software system is developed
Exchanging profit later for cash flow now in order to pay the bills (mostly salaries). Remember that this is itself a risky option, profit or loss being
the very small difference between two very large numbers'.
a CSR validates that the program design is a true expression of the output of the analysis phase,
there is no point in looking at the program design for the source of an error found during the coding phase.
Customized (or bespoke) products
these are systems that are commissioned by a particular customer
common risks that are not related to the type of software being developed
these can occur in any project
The user requirements for a system should describe the functional and nonfunctional requirements
they are understandable by system users who don't have detailed technical knowledge.
If people are not motivated
they will not be interested in the work they are doing
If making the change means that further changes elsewhere in the system are needed
this will obviously increase the cost of change implementation
Customers may use a single release of these systems for many years and may require specific changes
to a particular software system long after its original release date.
A software design is a description of the structure of the software
to be implemented, the data models and structures used by the system, the interfaces between system components and, sometimes, the algorithms used
You should regularly assess each of the identified risks
to decide whether or not that risk is becoming more or less probable
Good project managers should always try t
to encourage group cohesiveness
System modeling has generally come to
to mean representing the system using some kind of graphical notation, which is now almost always based on notations in the Unified Modeling Language (UML).
For each of the risks, you have to think of actions that you might take
to minimize the disruption to the project if the problem identified in the risk occurs.
You may develop different models
to represent the system from different perspectives.
These perspectives have much in common with Krutchen's 4 + 1 view of system architecture
where he suggests that you should document a system's architecture and organization from different perspectives
1. Change avoidance,
where the software process includes activities that can anticipate possible changes before significant rework is required. For example, a prototype system may be developed to show some key features of the system to customers.
Interface design,
where you define the interfaces between system components. This interface specification must be unambiguous
Database design
where you design the system data structures and how these are to be represented in a database.
Architectural design
where you identify the overall structure of the system, the principal components (sometimes called sub-systems or modules), their relationships, and how they are distributed.
1. An external perspective
where you model the context or environment of the system.
4. A behavioral perspective,
where you model the dynamic behavior of the system and how it responds to events.
MDA focuses on the design and implementation stages of software development
whereas MDE is concerned with all aspects of the software engineering process
However, there are costs and problems associated with reuse (Figure 16.2). There is a significant cost associated with understanding
whether or not a component is suitable for reuse in a particular situation, and in testing that component to ensure its dependability
One of the most important implementation decisions that has to be made at an early stage of a software project is
whether or not you should buy or build the application software
The concept that you reuse is represented in an abstract notation (e.g., a system model),
which does not include implementation detail
because data-driven systems are so common in business, UML 2.0 introduced activity diagrams,
which are similar to data-flow diagrams
Pre- and post-conditions
which are statements that are true before and after a process activity has been enacted or a product produced
Products,
which are the outcomes of a process activity. For example, the outcome of the activity of architectural design may be a model of the software architecture.
2. Sequence diagrams
which are used to model interactions between system components, although external agents may also be included.
However, frameworks are usually more general than software product lines,
which focus on a specific family of application system. For example, you can use a web-based framework to build different types of web-based applications
Incremental software development,
which is a fundamental part of agile approaches, is better than a waterfall approach for most business, e-commerce, and personal systems
1. Use case modeling
which is mostly used to model interactions between a system and external actors (users or other systems).
Schedule representation
Project schedules may simply be represented in a table or spreadsheet showing the tasks, effort, expected duration, and task dependencies
6. The platform on which the system will run Some components models, such as .NET, are specific to Microsoft platforms.
Similarly, generic application systems may be platform-specific and you may only be able to reuse these if your system is designed for the same platform.
1. Dynamic metrics, which are collected by measurements made of a program in execution
These metrics can be collected during system testing or after the system has gone into use. An example might be the number of bug reports or the time taken to complete a computation.
They also show the associations and relationships between these entities
These models are the bridge between the system requirements and the implementation of a system
When you try to reuse executable components you are inevitably constrained by detailed design decisions that have been made by the implementers of these components
These range from the particular algorithms that have been used to implement the components to the objects and types in the component interfaces
2. People risks
risks that are associated with the people in the development team.
Project definition sources.
• an inventory of risks with strategies for their avoidance or reduction • project approach • project architecture • high-level project plan • high-level resource plan • project evolution.
By comparing these values to each other and to the standards that apply across an organization
, you may be able to draw conclusions about the quality of software, or assess the effectiveness of software processes, tools, and methods.
a scenario may include
1. A description of what the system and users expects when the scenario starts. 2. A description of the normal flow of events in the scenario. 3. A description of what can go wrong and how this is handled. 4. Information about other activities that might be going on at the same time. 5. A description of the system state when the scenario finishes.
You may develop models of both the existing system and the system to be developed:
1. Models of the existing system are used during requirements engineering. 2. Models of the new system are used during requirements engineering to help explain the proposed requirements to other system stakeholders
Software engineering is important for two reasons:
1. More and more, individuals and society rely on advanced software systems.
there are problems with incremental delivery:
1. Most systems require a set of basic facilities that are used by different parts of the system.
why functional requirement should implement different
1. Non-functional requirements may affect the overall architecture of a system rather than the individual components
he particular architectural style and structure that you choose for a system should depend on the non-functional system requirements:
1. Performance If performance is a critical requirement, the architecture should be designed to localize critical operations within a small number of components,
Various types of specialization of a software product line may be developed
1. Platform specialization 2. Environment specialization 3. Functional specialization 4. Process specialization
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.
If the measure of the internal attribute is to be a useful predictor of the external software characteristic, three conditions must hold.
2. A relationship must exist between the attribute that can be measured and the external quality attribute that is of interest.
two types of representation that are commonly used:
2. Activity networks, which are network diagrams, show the dependencies between the different activities making up a project
The main arguments for and against MDE are
2. Against MDE As I discussed earlier in this chapter, models are a good way of facilitating discussions about a software design. However, it does not always follow that the abstractions that are supported by the model are the right abstractions for implementation
There are two types of technique that can be used to do this:.
2. Algorithmic cost modeling In this approach, a formulaic approach is used to compute the project effort based on estimates of product attributes, such as size, and process characteristics, such as experience of staff involved.
Three additional factors affect the overall duration of the project.
5. Reworking caused by design/software errors. 6. Reworking caused by changes in customer requirements. 7. Delays caused by risks that materialise as issues.
Pipe and filter advantages
Advantages Easy to understand and supports transformation reuse. Workflow style matches the structure of many business processes. Evolution by adding transformations is straightforward. Can be implemented as either a sequential or concurrent system.
Testing phases in a plan-driven software process
After this feedback, the system is modified and released either for further beta testing or for general sale.
This is a baseline for assessing the effectiveness of the too
After using the tool for some time, you repeat this process.
. Application system reuse The whole of an application system may be reused by incorporating it without changing into other systems or by configuring the application for different customers
Alternatively, application families that have a common architecture, but which are tailored for specific customers, may be developed. I cover application system reuse later in this chapter
1. Application system reuse The whole of an application system may be reused by incorporating it without changing into other systems or by configuring the application for different customers.
Alternatively, application families that have a common architecture, but which are tailored for specific customers, may be developed. I cover application system reuse later in this chapter
Software product lines
An application type is generalized around a common architecture so that it can be adapted for different customers.
Interface specification
An important part of any design process is the specification of the interfaces between the components in the design
Object-oriented design using the UML
An object-oriented system is made up of interacting objects that maintain their own local state and provide operations on that state
reuse software stages
Component analysis Requirements modification System design with reuse Development and integration
What is software?
Computer programs and associated documentation. Software products may be developed for a particular customer or may be developed for a general market.
Principles of Agile Methods
Customer involvement Customers should be closely involved throughout the development process. Their role is provide and prioritize new system requirements and to evaluate the iterations of the system.
Financial health
Developers in financial difficulty may lower their price to gain a contract. It is better to make a smaller than normal profit or break even than to go out of business. Cash flow is more important than profit in difficult economic times.
2. Organizational requirements These requirements are broad system requirements derived from policies and procedures in the customer's and developer's organization
Examples include operational process requirements that define how the system will be used, development process requirements that specify the programming language, the development environment or process standards to be used
2. Environment specialization Versions of the application are created to handle particular operating environments and peripheral devices
For example, a system for the emergency services may exist in different versions, depending on the vehicle communications system
3. Technical and managerial communications
Good communications between group members, and between the software engineering team and other project stakeholders, is essential.
What are the attributes of good software?
Good software should deliver the required functionality and performance to the user and should be maintainable, dependable, and usable
3. The target environment, which is the platform on which the system executes. This may be the same type of computer that is used for the development and build systems.
However, for real-time and embedded systems, the target environment is often smaller and simpler than the development environment (e.g., a cell phone). For large systems, the target environment may include databases and other COTS systems that cannot be installed on development machines
Design is about how to solve a problem, so there is always a design process.
However, it isn't always necessary or appropriate to describe the design in detail using the UML or other design description language.
example of risk
Hardware unavailability >Project> Hardware that is essential for the project will not be delivered on schedule
They have to be abstract so that unnecessary detail doesn't hide the relationships between them and the system requirements
However, they also have to include enough detail for programmers to make implementation decisions.
Project Scheduling
Identifying precedence relationships Sequencing activities Determining activity times & costs Estimating material & worker requirements Determining critical activities
example of requirement statement
If a company wishes to let a contract for a large software development project, it must define its needs in a sufficiently abstract way that a solution is not predefined.
1. Structural models, which describe the static structure of the system using object classes and their relationships.
Important relationships that may be documented at this stage are generalization (inheritance) relationships, uses/used-by relationships, and composition relationships.
Setting the system boundaries helps you decide what features are implemented in the system being designed and what features are in other associated systems
In this case, you need to decide how functionality is distributed between the control system for all of the weather stations, and the embedded software in the weather station itself.
2. Storage management To reduce the storage space required by multiple versions of components that differ only slightly, version management systems usually provide storage management facilities
Instead of keeping a complete copy of each version, the system stores a list of differences (deltas) between one version and another. By applying these to a source version (usually the most recent version), a target version can be re-created
A project cost is agreed on the basis of an outline proposal
Negotiations then take place between client and customer to establish the detailed project specification
The best-known open source product is, of course, the Linux operating system which is widely used as a server system and, increasingly, as a desktop environment
Other important open source products are Java, the Apache web server, and the mySQL database management system
Description of layered
Organizes the system into layers with related functionality associated with each layer. A layer provides services to the layer above it so the lowest-level layers represent core services that are likely to be used throughout the system
2. To satisfy esteem needs, you need to show people that they are valued by the organization.
Public recognition of achievements is a simple yet effective way of doing this. O
Design patterns are usually associated with object-oriented design.
Published patterns often rely on object characteristics such as inheritance and polymorphism to provide generality
rapid development
Rapid development and delivery is therefore now often the most critical requirement for software systems
Scheduling: time
Scheduling is essentially the translation of the process model into a network of activities.
class diagram and objects
The UML also allows the role of the objects participating in the association to be specified
I don't find the UML to be useful during the design process itself and prefer informal notations that are quicker to write and which can be easily drawn on a whiteboard. T
The UML is of most value when you are documenting an architecture in detail or using model-driven development,
Requirements elicitation and analysis may involve
a variety of different kinds of people in an organization.
Requirements management
The requirements for large software systems are always changing.
Risk planning,
The risk planning process considers each of the key risks that have been identified, and develops strategies to manage these risks
Relationships between internal and external software...
Usability related to Number of Error Messages ,Length of User Manual
Estimating the work required to deliver the end result is the one difficult part of this equation, especially in the early days of the inception phase
Whether the unit of work is 'Lines Of Code' (LOC) or methods of a class, efficiency is an expression of the number of those units that a member of staff can produce, error-free, in a working day
Repository architecture...
When used You should use this pattern when you have a system in which large volumes of information are generated that has to be stored for a long time. You may also use it in data-driven systems where the inclusion of data in the repository triggers an action or tool
the biggest cost is the effort cost
You have to estimate the total effort (in person-months) that is likely to be required to complete the work of a project
The nature of the relationships is now specified.
You may therefore document the environment of the system using a simple block diagram, showing the entities in the system and their associations.
release date. To document a release, you have to record the specific versions of the source code components that were used to create the executable code
You must keep copies of the source code files, corresponding executables, and all data and configuration files. You should also record the versions of the operating system, libraries, compilers, and other tools used to build the software
The configuration description used to identify
a baseline is also used by the system building tool.
Patterns are a great idea but you need experience of software design to use them effectively
a pattern can be applied. Inexperienced programmers, even if they have read the pattern books, will always find it hard to decide whether they can reuse a pattern or need to develop a specialpurpose solution.
The specific risks that may affect
a project depend on the project and the organizational environment in which the software is being developed
a plan-driven development project
a project plan sets out the resources available to the project, the work breakdown, and a schedule for carrying out the work
A complementary form of reuse is 'concept reuse' where, rather than reuse
a software component, you reuse an idea, a way, or working or an algorithm
Baselines are important because you often have to re-create
a specific version of a complete system. For example, a product line may be instantiated so that there are individual system versions for different customers
Software evolution..
a split between the process of software development and the process of software evolution (software maintenance)
When you are bidding for a contract, you have to work out the price that you will propose to the customer for developing the software
a starting point for calculating this price, you need to draw up an estimate of your costs for completing the project work
a system controlling a valve may move from a state 'Valve open' to
a state 'Valve closed' when an operator command (the stimulus) is received
Other interactions are with a control system that can issue specific weather station control commands
a stick figure is used in the UML to represent other systems as well as human users.
The CCB or product development group considers the impact of the change from
a strategic and organizational rather than a technical point of view.
Changing the implementation of an object
adding services should not affect other system objects.
A model is an abstraction of the system being studied rather than
an alternative representation of that system
The stylized pattern description includes the pattern name, a brief description (with an associated graphical model),
an example of the type of system where the pattern is used (again, perhaps with a graphical model).
In terms of the planning stages that I discussed in the introduction of this chapter,
an initial project schedule is usually created during the project startup phase
The risk management process is
an iterative process that continues throughout the project.
Project planning is
an iterative process that starts when you create an initial project plan during the project startup phase
The software requirements document
an official statement of what the system developers should implement.
4. Release management This involves preparing software for external release
and keeping track of the system versions that have been released for customer use
The change management process is concerned with analyzing the costs
and benefits of proposed changes, approving those changes that are worthwhile, and tracking which components in the system have been changed.
These requests may reflect suggestions
and feedback from customers or analyses of what is offered by competing products.
Organizational needs and requirements change during the lifetime of a system,
bugs have to be repaired, and systems have to adapt to changes in their environment. To ensure that the changes are applied to the system in a controlled way, you need a set of tool-supported, change management processes.
a use case is shown
as an ellipse with the actors involved in the use case represented as stick figures
The UML does not include a specific notation for this database modeling
as it assumes an object-oriented development process and models data using objects and their relationships
the probability and the assessment of the effects of a risk may change
as more information about the risk becomes available and as risk management plans are implemented.
The system requirements change
as the business procuring the system responds to external pressures and management priorities change.
Block diagrams are an appropriate way of describing the system architecture during the design process,
as they are a good way of supporting communications between the people involved in the process
The principles of agile development are
based in a large part on 'lean thinking', an approach to manufacturing
the user and system requirements should
be clear, unambiguous, easy to understand, complete, and consistent.
Structural models may
be static models, which show the structure of the system design or dynamic models, which show the organization of the system when it is executing.
Requirements validation is important
because errors in a requirements document can lead to extensive rework costs when these problems are discovered during development or after the system is in service
Software architecture is importan
because it affects the performance, robustness, distributability, and maintainability of a system
The key benefit of this architecture is that it is easy to support different configurations of subsystems
because the sender of a message does not need to address the message to a particular subsystem.
Evaluating an architectural design is difficul
because the true test of an architecture is how well the system meets its functional and non-functional requirements when it is in use
The notions of separation and independence are fundamental to architectural design
because they allow changes to be localized
The problems of incremental development
become particularly acute for large, complex, long-lifetime systems, where different teams develop different parts of the system.
a 'Preliminary Software Review' (PSR)
between supplier and customer before formally moving on to the analysis phase, based on a preliminary program design which acts as a form of prototype to guide design and coding
When a new version is created, the system simply stores a delta (a list of differences)
between the new version and the older version used to create that new version (
a 'Final Software Acceptance Review' (FSAR
between the testing and operations phases
Maslow's model of motivation is helpful up to a point
but I think that a problem with it is that it takes an exclusively personal viewpoint on motivation.
Software systems and components are potentially reusable entities
but their specific nature sometimes means that it is expensive to modify them for a new situation
Sequence diagrams are used to model the combined behavior of a group of objects
but you may also want to summarize the behavior of an object or a subsystem in response to messages and events
The customer support team may submit change requests associated with bugs that have been discovered and reported
by customers after the software has been released.
The SRS is not complete until the end of the high-level analysis phase
by which time the use cases or user requirements statements have been transformed into concrete system features.
For military and government systems, this group is often
called the change control board (CCB).
Using patterns means that you reuse the ideas but
can adapt the implementation to suit the system that you are developing
Software processes improvement .
can be improved by process standardization where the diversity in software processes across an organization is reduce
'Critical Software Reviews' (CSRs)
can be scheduled with the customer, to further inform the coding process
It is important to be realistic when you are creating a project plan
blems of some description nearly always arise during a project, and these can lead to project delays
Plan-driven development is based on engineering project management techniques a
can be thought of as the 'traditional' way of managing large software development projects
a conceptual view
conceptual views are almost always developed during the design process and are used to support architectural decision making
Configuration management (CM) is
concerned with the policies, processes, and tools for managing changing software systems
Reuse-oriented software engineering.
happens informally when people working on the project know of designs or code that are similar to what is required.
a sequence diagram shows the sequence of interactions
hat take place during a particular use case or use case instance
An important difference between these types of software is
hat, in generic products, the organization that develops the software controls the software specification
they may define constraints on the system implementation
he capabilities of I/O devices or the data representations used in interfaces with other systems.
These requirements reflect
he needs of customers for a system that serves a certain purpose such as controlling a device, placing an order, or finding information
Software Pricing def
he price of a software product to a customer is simply the cost of development plus profit for the developer
The nonfunctional requirements depend on the system architecture
he way in which these components are organized and communicate. In many systems, non-functional requirements are also influenced by individual components
for large systems, software design and implementation is only one of a set of processes (requirements engineering, verification and validation, etc.) i
involved in software engineering.
we use them in small to medium size projects
heavyweight, plan-driven development approach is applied to small and medium-sized business systems
there are costs and problems associated with reuse
here is a significant cost associated with understanding whether or not a component is suitable for reuse in a particular situation, and in testing that component to ensure its dependability
Model-driven engineering has its roots in model-driven architecture
hich was proposed by the Object Management Group (OMG)
1. As a way of facilitating discussion about the system design
high-level architectural view of a system is useful for communication with system stakeholders and project planning because it is not cluttered with detail. Stakeholders can relate to it and understand an abstract view of the system
Requirements classification and organization
his activity takes the unstructured collection of requirements, groups related requirements, and organizes them into coherent clusters
Each subsystem listens for messages on that infrastructure and picks up the messages that are intended for them
his is another commonly used architectural style in addition
Each increment or version of the system
incorporates some of the functionality that is needed by the customer
Event-based modeling was introduced in real-time design
methods such as those proposed by Ward and Mellor
2. The effects of the risk
might be assessed as catastrophic (threaten the survival of the project), serious (would cause major delays), tolerable (delays are within allowed contingency), or insignificant.
Sequence diagrams in the UML are primarily used to
model the interactions between the actors and the objects in a system and the interactions between the objects themselves.
Model-driven architecture
model-focused approach to software design and implementation that uses a sub-set of UML models to describe a system
Software design is a creative activity in which you identify software components and their relationships, based on a customer's requirements
mplementation is the process of realizing the design as a program. Sometimes, there is a separate design stage and this design is modeled and documented
no ideal process
no ideal process and most organizations have developed their own software development processes
Finer subdivision means that a disproportionate amount of time
must be spent on replanning and updating the project plan
System building tools and version management tools
must communicate as the build process involves checking out component versions from the repository managed by the version management system.
The stick figure notation was originally developed to cover human interaction
n but it is also now used to represent other external systems and hardware.
Example
n example of a pipe and filter system used for processing invoices
a manager, you have to break down the work into parts
nd assign these to project team members, anticipate problems that might arise, and prepare tentative solutions to those problems
Increasing demands
new software engineering techniques help us to build larger, more complex systems, the demands change
project planning involves a judicious mixture of
plan-based and agile development.
software processes are categorized
plan-driven or agileprocesses.
agile processes,
planning is incremental and it is easier to change the process to reflect changing customer requirements
Block diagrams
present a high-level picture of the system structure,
The storage management features in a version control system
reduce the disk space required to maintain all system versions
The definition and use of configuration management standards is essential for
quality certification in both the ISO 9000 and the CMM and CMMI standards
A system stakeholder
r is anyone who should have some direct or indirect influence on the system requirements
is possible to explicitly specify a specific component version (X.1.2, say)
r simply to specify the component identifier (X).
It also involves ensuring that changes made by different developers to these versions do not interfere with each other.
r. You can, therefore, think of version management as the process of managing codelines and baselines
A complementary form of reuse is 'concept reuse' where,
rather than reuse a software component, you reuse an idea, a way, or working or an algorithm.
Model-driven engineering and model-driven architecture
re often seen as the same thing
This may be in the form of program libraries or entire applications
re are many domain-specific application systems available that can be tailored and adapted to the needs of a specific company.
he shaded boxes represent earlier versions of a component that are automatically
re-created from the most recent component version
Maintainability If maintainability is a critical requirement, the system architecture should be designed using fine-grain, self-contained components t
readily be changed. Producers of data should be separated from consumers and shared data structures should be avoided
You should document the outcomes of the risk management process in
risk management plan.
The plan should identify
risks to the project and the software under development, and the approach that is taken to risk management
6. Estimation risks
s Risks that derive from the management estimates of the resources required to build the system.
4. Availability If availability is a critical requirement, the architecture should be designed to include redundant components
s so that it is possible to replace and update components without stopping the system.
risk management strategies
s that have been identified for the key risks (i.e., those that are serious or intolerable)
You can think of an architectural pattern as
stylized, abstract description of good practice, which has been tried and tested in different systems and environments
a plan-driven approach is normally used to coordinate
the work across each development site
The four basic process activities
specification, development, validation, and evolution are organized differently in different development processes
It allows for the separation of the application
state from the user interface to application
When version management systems were first developed,
storage management was one of their most important functions
what are the early increment involved
the early increments of the system include the most important or most urgently required functionality
The start of a process is indicated by a filled circle
the end by a filled circle inside another circle
Change management is intended to ensure that
the evolution of the system is a managed process and that priority is given to the most urgent and cost-effective changes
From the description of the Report weather use case, it is obvious that objects representing
the instruments that collect weather data will be required, as will an object representing the summary of the weather data
After an initial feasibility study
the next stage of the requirements engineering process is requirements elicitation and analysis
The alpha testing process continues
until the system developer and the client agree that the delivered system is an acceptable implementation of the requirements.
software validation
verification and validation (V&V) is intended to show that a system both conforms to its specification and that it meets the expectations of the system customer.
The architecture is also changeable and portable. So long as its interface is unchanged, a layer can be replaced by another, equivalent layer
when layer interfaces change or new facilities are added to a layer, only the adjacent layer is affected.
Requirements prioritization and negotiation
when multiple stakeholders are involved, requirements will conflict. This activity is concerned with prioritizing requirements and finding and resolving requirements conflicts through negotiation.
n agile processes, there has to be an overall schedule that identifies
when the major phases of the project will be completed. An iterative approach to scheduling is then used to plan each phase
the waterfall model should only be used
when the requirements are well understood and unlikely to change radically during system development
safety-critical control systems
where a complete analysis of the system is essential, a plan-driven approach is the right one.
The Spiral approach highlights the order in which these different specifications are normally produced
• Business requirements define the scope of the project. • User requirements define the system to be produced in sufficient detail to be able to plan the project. • System requirements define the system in sufficient detail to allow it to be implemented.
Customer business information sources
• Business vision - Corporate goals. • Business rules - Policies and constraints. • Business case - Source of information about corporate values (intangible).
A system release is not just the executable code of the system. The release may also include:..
• an installation program that is used to help install the system on target hardware; • electronic and paper documentation describing the system; • packaging and associated publicity that have been designed for that release
A system release is not just the executable code of the system. The release may also include:
• configuration files defining how the release should be configured for particular installations; • data files, such as files of error messages, that are needed for successful system operation;
The stages in the testing process are:
1. Development testing 2. System testing 3. Acceptance testing
Object-oriented systems are easier to change than
systems developed using functional approaches.
There are three significant approaches to statistical estimation of effort described in the recommended textbooks
1. Constructive Cost Model (COCOMO II) 2. Function Point Analysis (FPA) 3. Object Oriented (OO) approach.
Requirements Evolution
. Requirements reviews The requirements are analyzed systematically by a team of reviewers who check for errors and inconsistencies. 2. Prototyping In this approach to validation, an executable model of the system in question is demonstrated to end-users and customers. They can experiment with this model to see if it meets their real needs. 3. Test-case generation Requirements should be testable
For example, a competitor introducing a new product is a business risk
. The introduction of a competitive product may mean that the assumptions made about sales of existing software products may be unduly optimistic
3. State machine model, which show how individual objects change their state in response to events
. These are represented in the UML using state diagrams. State machine models are dynamic models.
well-known 4+1 view model of software architecture, suggests that there should be four fundamental architectural views,
1. A logical view, 2. A process view 3. A development view 4. A physical view
The four essential elements of design patterns were defined by the 'Gang of Four' in their patterns book:
1. A name that is a meaningful reference to the pattern. 2. A description of the problem area that explains when the pattern may be applied.
System context models and interaction models present complementary views of the relationships between a system and its environment:
1. A system context model is a structural model that demonstrates the other systems in the environment of the system being developed.
It can be difficult to elicit domain knowledge through interviews for two reasons
1. All application specialists use terminology and jargon that are specific to a domain 2. Some domain knowledge is so familiar to stakeholders that they either find it difficult to explain or they think it is so fundamental that it isn't worth mentioning.
the principles underlying agile methods are sometimes difficult to realize:
1. Although the idea of customer involvement in the development process is an attractive one, its success depends on having a customer who is willing and able to spend time with the development team and who can represent all system stakeholders.
The main differences between these approaches are as follows:
1. Application frameworks rely on object-oriented features such as inheritance and polymorphism to implement extensions to the framework.
The software units that are reused may be of radically different sizes. For example:
1. Application system reuse 2. Component reuse 3. Object and function reuse
You can design software architectures at two levels of abstraction
1. Architecture in the small is concerned with the architecture of individual programs. 2. Architecture in the large is concerned with the architecture of complex enterprise systems that include other systems, programs, and program components.
two questions that should be considered when considering agile methods and maintenance:
1. Are systems that are developed using an agile approach maintainable, given the emphasis in the development process of minimizing formal documentation?
three ways in which graphical models are commonly used:
1. As a means of facilitating discussion about an existing or proposed system. 2. As a way of documenting an existing system. 3. As a detailed system description that can be used to generate a system implementation.
two ways in which an architectural model of a program is used:
1. As a way of facilitating discussion about the system design 2. As a way of documenting an architecture that has been designed
The components at each level in the product line system are as follows:
1. At the interaction level, there are components providing an operator display interface and an interface with the communications systems used.
Project planning takes place at three stages in a project life cycle
1. At the proposal stage, when you are bidding for a contract to develop or provide a software system
strategies fall into three categories:
1. Avoidance strategies 2. Minimization strategies 3. Contingency plans
e two types of representation that are commonly used:
1. Bar charts, which are calendar-based, show who is responsible for each activity, the expected elapsed time, and when the activity is scheduled to begin and end.
Successful execution of a software project is dependent on three planning activities:
1. Budget/resource-planning. 2. Scheduling. 3. Monitoring and progress management.
There are two related approaches that may be used to reduce the costs of rework
1. Change avoidance 2. Change tolerance
The configuration management of a software system product involves four closely related activities
1. Change management 2. Version management 3. System building 4. Release management
The key stages in this component measurement process are:
1. Choose measurements to be made The questions that the measurement is intended to answer should be formulated and the measurements required to answer these questions defined.
Software engineering ethics
1. Confidentiality You should normally respect the confidentiality of your employers or clients irrespective of whether or not a formal confidentiality agreement has been signed
You can think of these stimuli as being of two types:
1. Data Some data arrives that has to be processed by the system. 2. Events Some event happens that triggers system processing
Product metrics fall into two classes
1. Dynamic metrics, 2. Static metrics
Bayersdorfer (2007) suggests that companies managing projects that use open source should:
1. Establish a system for maintaining information about open source components that are downloaded and used
To minimize misunderstandings when writing natural language requirements, I recommend that you follow some simple guidelines:
1. Invent a standard format and ensure that all requirement definitions adhere to that format. Standardizing the format makes omissions less likely and requirements easier to check
fundamental questions about the system:
1. Is there a generic application architecture that can act as a template for the system that is being designed? 2. How will the system be distributed across a number of cores or processors? 3. What architectural patterns or styles might be used
classification of non-functional requirements
1. Product requirements 2. Organizational requirements 3. External requirements
To illustrate this problem, consider the following scenario:
1. Release 1 of a system is distributed and put into use. 2. Release 2 requires the installation of new data files, but some customers do not need the facilities of release 2 so remain with release 1. 3. Release 3 requires the data files installed in release 2 and has no new data files of its own
The principal stages of the waterfall model directly reflect the fundamental development activities:
1. Requirements analysis and definition 2. System and software design 3. Implementation and unit testing 4. Integration and system testing 5. Operation and maintenance
d, I introduce some aspects of implementation that are particularly important to software engineering that are often not covered in programming texts. These are:
1. Reuse Most modern software is constructed by reusing existing components or systems. When you are developing software, you should make as much use as possible of existing code.
Estimating: cost
1. Scale of problem 2. Efficiency of staff 3. Unit cost of staff 4. Project-specific equipment costs (for example, servers, licenses) 5. Overheads associated with staff time (travel, accommodation, utility equipment such as phones, laptops).
Eliciting and understanding requirements from system stakeholders is a difficult process for several reasons
1. Stakeholders often don't know what they want from a computer system except in the most general terms; they may find it difficult to articulate what they want the system to do
In the early stages of the design process, I think there are three models that are particularly useful for adding detail to use case and architectural models:
1. Subsystem models, which that show logical groupings of objects into coherent subsystems. These are represented using a form of class diagram with each subsystem shown as a package with enclosed objects
three classes of frameworks:
1. System infrastructure frameworks 2. Middleware integration frameworks 3. Enterprise application frameworks
two ways of coping with change and changing system requirement
1. System prototyping 2. Incremental delivery
Personality type also influences motivation. Bass and Dunteman (1963) classify professionals into three types:
1. Task-oriented people 2. Self-oriented people 3. Interaction-oriented people
To use patterns in your design, you need to recognize that any design problem you are facing may have an associated pattern that can be applied
1. Tell several objects that the state of some other object has changed (Observer pattern). 2. Tidy up the interfaces to a number of related objects that have often been developed incrementally
been identified from the system description and the scenario (use case) description:
1. The WeatherStation object class provides the basic interface of the weather station with its environment
Software reuse is possible at a number of different levels:
1. The abstraction level At this level, you don't reuse software directly but rather use knowledge of successful abstractions in the design of your software
Significant factors that should be taken into account in deciding whether or not a change should be approved are:
1. The consequences of not making the change When assessing a change request, you have to consider what will happen if the change is not implemented
Key factors that you should consider when planning reuse are:
1. The development schedule for the software 2. The expected software lifetime 3. The background, skills, and experience of the development team 4. The criticality of the software and its non-functional requirements 5. The application domain
Building is a complex process, which is potentially error-prone, as there may be three different system platforms involved
1. The development system, which includes development tools such as compilers, source code editors
If the measure of the internal attribute is to be a useful predictor of the external software characteristic, three conditions must hold
1. The internal attribute must be measured accurately. This is not always straightforward and it may require special-purpose tools to make the measurements.
rectangle that represents a class
1. The name of the object class is in the top section. 2. The class attributes are in the middle section . The operations (called methods in Java and other OO programming languages) associated with the object class are in the lower section of the rectangle.
here are three generic factors that affect team working
1. The people in the group 2. The group organization 3. Technical and managerial
ou should assign the risk to one of a number of bands:
1. The probability of the risk 2. The effects of the risk
rapid software development, they share some fundamental characteristics:
1. The processes of specification, design, and implementation are interleaved
To understand why this kind of ambiguity can occur, you have to understand the reasons why users might make change requests:
1. The software is not good enough and does not do what customers want it to do. They therefore request changes to deliver the functionality that they require.
Four factors determine how the network is constructed:
1. The way the project decomposes into tasks (work breakdown structure). 2. The availability of the resources needed to execute the tasks. 3. The estimated time to completion for each task. 4. The interdependencies that dictate prerequisites for starting a task.
Effective interviewers have two characteristics:
1. They are open-minded, avoid pre-conceived ideas about the requirements, and are willing to listen to stakeholde
There are two ways in which measurements of a software system may be used:
1. To assign a value to system quality attributes 2. To identify the system components whose quality is substandard
To develop a system design from concept to detailed, object-oriented design, there are several things that you need to do:
1. Understand and define the context and the external interactions with the system. 2. Design the system architecture. 3. Identify the principal objects in the system. 4. Develop design models. 5. Specify interfaces.
There have been various proposals made about how to identify object classes in object-oriented systems:
1. Use a grammatical analysis of a natural language description of the system to be constructed. Objects and attributes are nouns; operations or services are verbs
I cover two related approaches to interaction modeling
1. Use case modeling 2. Sequence diagrams
Configuration management,,
1. Version management, 2. System integration 3. Problem tracking,
three types of software component that may be used in a reuse-oriented process
1. Web services that are developed according to service standards and which are available for remote invocation. 2. Collections of objects that are developed as a package to be integrated with a component framework such as .NET or J2EE. 3. Stand-alone software systems that are configured for use in a particular environment.
To understand why this kind of ambiguity can occur, you have to understand the reasons why users might make change requests:..
2. Alternatively, the software may be very good and so it is widely and heavily used. Change requests may be generated because there are many software users who creatively think of new things that could be done with the software.
System context models and interaction models present complementary views of the relationships between a system and its environment:,
2. An interaction model is a dynamic model that shows how the system interacts with its environment as it is used.
The components at each level in the product line system are as follows:.
2. At the I/O management level (level 2), there are components that handle operator authentication, generate reports of incidents and vehicles despatched, support map output and route planning,
Agile methods have been very successful for some types of system development:.
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.
the principles underlying agile methods are sometimes difficult to realize
2. Individual team members may not have suitable personalities for the intense involvement that is typical of agile methods, and therefore not interact well with other team members.
Software engineering is important for two reasons:
2. It is usually cheaper, in the long run, to use software engineering methods and techniques for software systems rather than just write the programs as if it was a personal programming projec
The key stages in this component measurement process are:.
2. Select components to be assessed You may not need to assess metric values for all of the components in a software system.
architectural models:
2. Sequence models, which show the sequence of object interactions. These are represented using a UML sequence or a collaboration diagram. Sequence models are dynamic models.
Significant factors that should be taken into account in deciding whether or not a change should be approved are:.
2. The benefits of the change Is the change something that will benefit many users of the system or is it simply a proposal that will primarily be of benefit to the change proposer?
There have been various proposals made about how to identify object classes in object-oriented systems:.
2. Use tangible entities (things) in the application domain such as aircraft, roles such as manager or doctor, events such as requests, interactions such as meetings, locations such as offices, organizational units such as companies
The four essential elements of design patterns were defined by the 'Gang of Four' in their patterns book:.
3. A solution description of the parts of the design solution, their relationships, and their responsibilities. This is not a concrete design description 4. A statement of the consequences—the results and trade-offs—of applying the pattern.
The first step in scoping many projects is a feasibility study and this is very often a technical rather than a commercial decision. Examples include:.
3. A trial to see how many extra sales agents the current network will support. 4. An evaluation of three vendors' COTS software. 5. A mock-up interface to see whether staff would feel comfortable using the proposed new Human Resource system.
5. How can knowledge be shared across the group?
3. How will interactions with external stakeholders and senior company management be handled? 4. How can groups integrate people who are not colocated?
Software engineering ethics..
3. Intellectual property rights You should be aware of local laws governing the use of intellectual property such as patents and copyright.
here are several reasons why change is inevitable:..
3. Large systems usually have a diverse user community, with many users having different requirements and priorities that may be conflicting or contradictory
Project planning takes place at three stages in a project life cycle..
3. Periodically throughout the project, when you modify your plan in light of experience gained and information from monitoring the progress of the work. You learn more about the system being implemented and capabilities of your development team
the principles underlying agile methods are sometimes difficult to realize-
3. Prioritizing changes can be extremely difficult, especially in systems for which there are many stakeholders. Typically, each stakeholder gives different priorities to different changes.
The main differences between these approaches are as follows:
3. Software product lines are often control applications for equipment. For example, there may be a software product line for a family of printers
Significant factors that should be taken into account in deciding whether or not a change should be approved are:..
3. The number of users affected by the change If only a few users are affected, then the change may be assigned a low priority. In fact, making the change may be inadvisable if it could have adverse effects on the majority of system users.
Incremental delivery has a number of advantages:..
3. The process maintains the benefits of incremental development in that it should be relatively easy to incorporate changes into the system.
If the measure of the internal attribute is to be a useful predictor of the external software characteristic, three conditions must hold,
3. This relationship between the internal and external attributes must be understood, validated, and expressed in terms of a formula or model. Model formulation involves identifying the functional form of the model (linear, exponential, etc.)
There have been various proposals made about how to identify object classes in object-oriented systems:..
3. Use a scenario-based analysis where various scenarios of system use are identified and analyzed in turn. As each scenario is analyzed, the team responsible for the analysis must identify the required objects, attributes, and operations
To minimize misunderstandings when writing natural language requirements, I recommend that you follow some simple guidelines..
4. Do not assume that readers understand technical software engineering language. It is easy for words like 'architecture' and 'module' to be misunderstood
3. Be aware of evolution pathways for components. You need to know a bit about the open source project where components
4. Educate people about open source. It's not enough to have procedures in place to ensure compliance with license conditions.
plans normally include the following sections:...
4. Hardware and software resource requirements This specifies the hardware and support software required to carry out the development. If hardware has to be bought, estimates of the prices and the delivery schedule may be included
the principles underlying agile methods are sometimes difficult to realize=
4. Maintaining simplicity requires extra work. Under pressure from delivery schedules, the team members may not have time to carry out desirable system simplifications.
Although each framework includes slightly different functionality, most web application frameworks support the following features:...
4. Session management Classes to create and manage sessions (a number of interactions with the system by a user) are usually part of a WAF.
There are four fundamental activities that are common to all software processes
4. Software evolution, where the software is modified to reflect changing customer and market requirements.
The main differences between these approaches are as follows:
4. Software product lines are made up of a family of related applications, owned by the same organization.
costs associated with reuse:...
4. The costs of integrating reusable software elements with each other (if you are using software from different sources) and with the new code that you have developed
The effectiveness and efficiency of communications is influenced by.
5. The available communication channels There are many different forms of communication—face-to-face, e-mail messages, formal documents, telephone
Significant factors that should be taken into account in deciding whether or not a change should be approved are:....
5. The product release cycle If a new version of the software has just been released to customers, it may make sense to delay the implementation of the change until the next planned release
Although each framework includes slightly different functionality, most web application frameworks support the following features:......
5. User interaction Most web frameworks now provide AJAX support (Holdener, 2008), which allows more interactive web pages to be created.
plans normally include the following sections:....
5. Work breakdown This sets out the breakdown of the project into activities and identifies the milestones and deliverables associated with each activity.
5. Have auditing systems in place. Developers, under tight deadlines, might be tempted to break the terms of a license.
6. Participate in the open source community. If you rely on open source products, you should participate in the community and help support their development
plans normally include the following sections:.....
6. Project schedule This shows the dependencies between activities, the estimated time required to reach each milestone, and the allocation of people to activities
plans normally include the following sections:......
7. Monitoring and reporting mechanisms This defines the management reports that should be produced, when these should be produced, and the project monitoring mechanisms to be used.
fundamental questions about the system:
7. What architectural organization is best for delivering the non-functional requirements of the system? 8. How will the architectural design be evaluated? 9. How should the architecture of the system be documented?
2. The group organization
A group should be organized so that individuals can contribute to the best of their abilities and tasks can be completed as expected.
Software reuse is most effective when it is planned as part of an organization-wide reuse program.
A reuse program involves the creation of reusable assets and the adaptation of development processes to incorporate these assets in new software
Software reuse is most effective when it is planned as part of an organization-wide reuse program
A reuse program involves the creation of reusable assets and the adaptation of development processes to incorporate these assets in new software.
Motivating people
As a project manager, you need to motivate the people that work with you so that they contribute to the best of their abilities.
3. In many companies, software processes are not standardized and are poorly defined and controlled.
As such, there is too much process variability within the same company for measurements to be used in a meaningful way.
Electronic change request forms record information that is shared between all groups involved in change management.
As the change request is processed, information is added to the CRF to record decisions made at each stage of the process.
At any time, it therefore represents a snapshot of the state of the change request.
As well as recording the change required, the CRF records the recommendations regarding the change; the estimated costs of the change; and the dates when the change was requested, approved, implemented, and validated
The context model of a system may be represented using associations
Associations simply show that there are some relationships between the entities involved in the association.
Context models
At an early stage in the specification of a system, you should decide on the system boundaries.
You should monitor risks regularly at all stages in a project
At every management review, you should consider and discuss each of the key risks separately
Software systems always change during development and use.
Bugs are discovered and have to be fixed. System requirements change, and you have to implement these changes in a new version of the system
1. To assign a value to system quality attributes
By measuring the characteristics of system components, such as their cyclomatic complexity, and then aggregating these measurements, you can assess system quality attributes, such as maintainability
Object class identification
By this stage in the design process, you should have some ideas about the essential objects in the system that you are designing
A specification document must comply with the 'four Cs'
Clear: No ambiguities or confusing cross references to other documents. Concise: No unnecessary detail, repetition or confusing cross-references to other documents. Correct: Attributed, with no conjecture, paraphrasing or unsubstantiated opinion. Complete: Verified as part of the V & V process
Software engineering is related to both computer science and systems engineering:
Computer science is concerned with the theories and methods that underlie computers and software systems, whereas software engineering is concerned with the practical problems of producing software
The project plan always evolves during the development process
Development planning is intended to ensure that the project plan remains a useful document for staff to understand what is to be achieved and when it is to be delivered
2. Respect
Different people have different skills and managers should respect these differences. All members of the team should be given an opportunity to make a contribution.( In some cases, of course, you will find that people simply don't fit into a team and they cannot continue, but it is important not to jump to conclusions about this at an early stage in the project.)
Risk analysis,,
During the risk analysis process, you have to consider each identified risk and make a judgment about the probability and seriousness of that risk
process model of the elicitation and analysis process
Each organization will have its own version or instantiation of this general model depending on local factors such as the expertise of the staff, the type of system being developed, the standards use
1. Requirements identification
Each requirement must be uniquely identified so that it can be cross-referenced with other requirements and used in traceability assessments.
client-server disadvantages
Each service is a single point of failure so susceptible to denial of service attacks or server failure. Performance may be unpredictable because it depends on the network as well as the system. May be management problems if servers are owned by different organizations.
the differences between codelines and baselines
Essentially, a codeline is a sequence of versions of source code with later versions in the sequence derived from earlier versions
Event-driven modeling
Event-driven modeling shows how a system responds to external and internal events.
1. Product requirements These requirements specify or constrain the behavior of the software.
Examples include performance requirements on how fast the system must execute and how much memory it requires, reliability requirements
Control metrics are usually associated with software processes.
Examples of control or process metrics are the average effort and the time required to repair reported defects
FURPS - Functionality, Usability, Reliability, Performance, Supportability
FURPS
An obvious advantage of software reuse is that overall development costs should be reduced.
Fewer software components need to be specified, designed, implemented, and validated. However, cost reduction is only one advantage of reuse. In Figure 16.1, I have listed other advantages of reusing software assets.
1. Avoidance strategies
Following these strategies means that the probability that the risk will arise will be reduced. An example of a risk avoidance strategy is the strategy for dealing with defective components
3. Functional specialization Versions of the application are created for specific customers who have different requirements.
For example, a library automation system may be modified depending on whether it is used in a public library, a reference library, or a university library.
2. Component reuse Components of an application, ranging in size from subsystems to single objects, may be reused.
For example, a pattern-matching system developed as part of a text-processing system may be reused in a database management system
2. Component reuse Components of an application, ranging in size from subsystems to single objects, may be reused
For example, a pattern-matching system developed as part of a text-processing system may be reused in a database management system.
Frameworks provide support for generic features that are likely to be used in all applications of a similar type
For example, a user interface framework will provide support for interface event handling and will include a set of widgets that can be used to construct displays.
4. Process specialization The system is adapted to cope with specific business processes
For example, an ordering system may be adapted to cope with a centralized ordering process in one company and a distributed process in another.
It is then left to the developer to specialize these by adding specific functionality for a particular application
For example, in a user interface framework, the developer defines display layouts that are appropriate to the application being implemented
Non-functional requirements often conflict and interact with other functional or non-functional requirements.
For example, the authentication requirement in Figure 4.4 obviously requires a card reader to be installed with each computer attached to the system
Design and implementation are closely linked and you should normally take implementation issues into account when developing a design.
For example, using the UML to document a design may be the right thing to do if you are programming in an object-oriented language such as Java or C#.
1. Platform specialization Versions of the application are developed for different platforms.
For example, versions of the application may exist for Windows, Mac OS, and Linux platforms
the boundary between a system and its environment is relatively clear
For example, where an automated system is replacing an existing manual or computerized system, the environment of the new system is usually the same as the existing system's environment.
You look for common features and then design the inheritance hierarchy for the system
For example, you may identify an Instrument superclass, which defines the common features of all instruments, such as an identifier, and get and test operations
This is an example of a type of CRF that might be used in a large complex systems engineering project.
For smaller projects, I recommend that change requests should be formally recorded and the CRF should focus on describing the change required, with less emphasis on implementation issues
customers for a system often find it difficult to translate their goals into measurable requirements
For some goals, such as maintainability, there are no metrics that can be used.
two kinds of software products
Generic products Customized (or bespoke) products
these risk types overlap تتداخل أنواع المخاطر هذه
If an experienced programmer leaves a project this can be a project risk because, even if they are immediately replaced, the schedule will be affected. (It inevitably takes time for a new project member to understand the work that has been done,) so they cannot be immediately productive. Consequently, the delivery of the system may be delayed
2. Configuration management During the development process, many different versions of each software component are created.
If you don't keep track of these versions in a configuration management system, you are liable to include the wrong versions of these components in your system.
cost of people recuriment
It costs a lot to recruit and retain good people and it is up to software managers to ensure that the organization gets the best possible return on its investment
2. Dynamic models, which describe the dynamic structure of the system and show the interactions between the system objects.
Interactions that may be documented include the sequence of service requests made by objects and the state changes that are triggered by these object interactions.
Project Scheduling
Involves the creation of a specific timetable, usually in the form of charts
Configuration management is useful for individual projects as it is easy for one person to forget what changes have been made
It is essential for team projects where several developers are working at the same time on a software system. Sometimes these developers are all working in the same place but, increasingly, development teams are distributed with members in different locations across the world
There is usually a clear relationship between dynamic metrics and software quality characteristics. I
It is fairly easy to measure the execution time required for particular functions and to assess the time required to start up a system.
low expectation
It is relatively easy to write computer programs without using software engineering methods and techniques
what are architectural design link
It is the critical link between design and requirements engineering, as it identifies the main structural components in a system and the relationships between them
There is little information publicly available about the current use of systematic software measurement in industry.
Many companies do collect information about their software, such as the number of requirements change requests or the number of defects discovered in testing.
3. Object and function reuse Software components that implement a single function, such as a mathematical function, or an object class may be reused.
Many libraries of functions and classes are freely available. You reuse the classes and functions in these libraries by linking them with newly developed application code
Open source software extended this idea by using the Internet to recruit a much larger population of volunteer developers
Many of them are also users of the code. In principle at least, any contributor to an open source project may report and fix bugs and propose new features and functionality
importance of non functional requirement
Non-functional requirements are often more critical than individual functional requirements
Architectural Design
Once the interactions between the software system and the system's environment have been defined, you use this information as a basis for designing the system architecture
At this stage in the design process, you should focus on the objects themselves, without thinking about how these might be implemented
Once you have identified the objects, you then refine the object design
Software product lines,,
One of the most effective approaches to reuse is to create software product lines or application families
Principles of Agile Methods..
People not process The skills of the development team should be recognized and exploited. Team members should be left to develop their own ways of working without prescriptive processes.
Scenarios
People usually find it easier to relate to real-life examples rather than abstract descriptions
Plan-driven development
Plan-driven or plan-based development is an approach to software engineering where the development process is planned in detail
Requirements management planning
Planning is an essential first stage in the requirements management process
benefit of rapid development process
Rapid software development processes are designed to produce useful software quickly
Generalization idea
Rather than learn the detailed characteristics of every entity that we experience, we place these entities in more general classes (animals, cars, houses, etc.)
. Host-target development Production software does not usually execute on the same computer as the software development environment
Rather, you develop it on one computer (the host system) and execute it on a separate computer (the target system). The host and target systems are sometimes of the same type but, often they are completely different
Requirements discovery..
Requirements discovery (sometime called requirements elicitation) is the process of gathering information about the required system and existing systems, and distilling the user and system requirements from this information
2. Stakeholders in a system naturally express requirements in their own terms and with implicit knowledge of their own work
Requirements engineers, without experience in the customer's domain, may not understand these requirements
Requirements specification
Requirements specification is the activity of translating the information gathered during the analysis activity into a document thatdefines a set of requirements
Requirements validation..
Requirements validation is the process of checking that requirements actually define the system that the customer really wants
Alice arranges regular informal meetings where she tells the other group members what is going on
She makes a point of involving people in the product development by asking them to come up with new ideas derived from their own family experiences
What is software engineering?
Software engineering is an engineering discipline that is concerned with all aspects of software production.
Lack of tool support
Some software tools do not support development with reuse. It may be difficult or impossible to integrate these tools with a component library system.
Standards compliance
Some standards, such as user interface standards, can be implemented as a set of reusable components. For example, if menus in a user interface are implemented using reusable components, all applications present the same menu formats to users.
For custom software or software product lines, managing system releases is a complex process
Special releases of the system may have to be produced for each customer and individual customers may be running several different releases of the system at the same time
Configuration Management
System Building,Component Versions,Version Management,System Versions,Release Management, System Releases ,Change Management
System building
System building is the process of creating a complete, executable system by compiling and linking the system components, external libraries, configuration files
2-System testing
System components are integrated to create a complete system. This process is concerned with finding errors that result from unanticipated interactions between components and component interface problems
Software engineering is related to both computer science and systems engineering:
System engineering is concerned with all aspects of the development and evolution of complex systems where software plays a major role
1. Stakeholder communication
The architecture is a high-level presentation of the system that may be used as a focus for discussion by a range of different stakeholders
Reduced process risk
The cost of existing software is already known, whereas the costs of development are always a matter of judgment. This is an important factor for project management because it reduces the margin of error in project cost estimation
As it is most likely that the most recent version of a component will be used, most systems store that version in full
The deltas then define how to re-create earlier system versions.
there has to be a requirements refinement stage where the requirements for the system are modified to reflect the reusable software that is available.
The design and implementation stages of the system may also include explicit activities to look for and evaluate candidate components for reuse.
Description of pipe and filter
The processing of the data in a system is organized so that each processing component (filter) is discrete and carries out one type of data transformation. The data flows (as in a pipe) from one component to another for processing
4. Independent development Different developers may be working on the same component at the same time
The version management system keeps track of components that have been checked out for editing and ensures that changes made to a component by different developers do not interfere
The process models
The waterfall model Incremental development Reuse-oriented software engineering
Group organization
The way that a group is organized affects the decisions that are made by that group
The high-level architectural design for the weather station software
The weather station is composed of independent subsystems that communicate by broadcasting messages on a common infrastructure
As a starting point for risk identification, a checklist of different types of risk may be used
There are at least six types of risk that may be included in a risk checklist:
This may be in the form of program libraries or entire applications.
There are many domain-specific application systems available that can be tailored and adapted to the needs of a specific company
1. It is impossible to quantify the return on investment of introducing an organizational metrics program.
There have been significant improvements in software quality over the past few years without the use of metrics so it is difficult to justify the initial costs of introducing systematic software measurement and assessment
3. Object and function reuse Software components that implement a single function, such as a mathematical function, or an object class may be reused.,
This form of reuse, based around standard libraries, has been common for the past 40 years. Many libraries of functions and classes are freely available. You reuse the classes and functions in these libraries by linking them with newly developed application code
Partially-functional prototypes provide another tool for eliciting feedback from users as the detailed design evolves.
This has become increasingly valuable as developers gain access to re-usable library objects, especially user-interface objects, and acquire skills in using techniques from the field of usability
3. Change history recording All of the changes made to the code of a system or component are recorded and listed. In some systems, these changes may be used to select a particular system version
This involves tagging components with keywords describing the changes made. You then use these tags to select the components to be included in a baseline
Fog index
This is a measure of the average length of words and sentences in documents. The higher the value of a document's Fog index, the more difficult the document is to understand.
Depth of conditional nesting
This is a measure of the depth of nesting of if-statements in a program. Deeply nested if-statements are hard to understand and potentially error-prone.
Length of code
This is a measure of the size of a program. Generally, the larger the size of the code of a component, the more complex and error-prone that component is likely to be.
4. The criticality of the software and its non-functional requirements For a critical system that has to be certified by an external regulator, you may have to create a dependability case for the system
This is difficult if you don't have access to the source code of the software. If your software has stringent performance requirements, it may be impossible to use strategies such as generator-based reuse
You can therefore explain your design by describing the patterns that you have used
This is particularly true for the best-known design patterns that were originally described by the 'Gang of Four' in their patterns book
Requirements discovery
This is the process of interacting with stakeholders of the system to discover their requirements. Domain requirements from stakeholders and documentation are also discovered during this activity
2. A change management process
This is the set of activities that assess the impact and cost of changes. I discuss this process in more detail in the following section.
For valid change requests, the next stage of the process is change assessment and costing.
This is usually the responsibility of the development or maintenance team as they can work out what is involved in implementing the change
4. The system level At this level, you reuse entire application systems. This usually involves some kind of configuration of these systems.
This may be done by adding and modifying code (if you are reusing a software product line) or by using the system's own configuration interface. Most commercial systems are now built in this way where generic COTS (commercial off-the-shelf) systems are adapted and reused
The core system is designed to be configured and adapted to suit the needs of different system customers
This may involve the configuration of some components, implementing additional components, and modifying some of the components to reflect new requirements.
3. Safety If safety is a critical requirement, the architecture should be designed so that safety-related operations are all located in either a single component or in a small number of components
This reduces the costs and problems of safety validation and makes it possible to provide related protection systems that can safely shut down the system in the event of failure.
Depth of inheritance tree (DIT)
This represents the number of discrete levels in the inheritance tree where subclasses inherit attributes and operations (methods) from superclasses. The deeper the inheritance tree, the more complex the design.
a layered architecture with four layers.
User Interface Core Business Logic/Application Functionality System Utilities System Support (OS, Database etc.) User Interface Management Authentication and Authorization
Agile methods
This view came from the software engineering community that was responsible for developing large, longlived software systems such as aerospace and government systems.
2. The object level At this level, you directly reuse objects from a library rather than writing the code yourself
To implement this type of reuse, you have to find appropriate libraries and discover if the objects and methods offer the functionality that you need. For example, if you need to process mail messages in a Java program, you may use objects and methods from a JavaMail library.
Software requirements
Use case diagram A statement of a functional requirement (a specific task undertaken on behalf of a specific class of user)
Use cases
Use cases are a requirements discovery technique that were first introduced in the Objectory method
When used,,of layered
Used when building new facilities on top of existing systems; when the development is spread across several teams with each team responsibility for a layer of functionality; when there is a requirement for multi-level security.
client-server When used
Used when data in a shared database has to be accessed from a range of locations. Because servers can be replicated, may also be used when the load on a system is variable
When used
Used when there are multiple ways to view and interact with data. Also used when the future requirements for interaction and presentation of data are unknown
User requirements vs System requirements
User requirements are the functional and non-functional requirements that describe the business goals for the system. System requirements are the functional and non-functional requirements that have to be met in order to achieve the business goals for the system.
software meaurement
difficult to make direct measurements of many of the software quality attributes
The project scheduling process
identify activities -> identify activity dependencies -> estimate Resources for Activities -> allocate people to activities -> create project charts
You may have to re-create the version delivered to a specific customer
if, for example, that customer reports bugs in their system that have to be repaired
Risk planning
You should make plans to address the risk, either by avoiding it or minimizing its effects on the project
Your aim at this stage should be to create a project plan that can be used to support decision making about project staffing and budgeting
You use the plan as a basis for allocating resources to the project from within the organization and to help decide if you need to hire new staff.
Models are used during the requirements engineering process to help derive the requirements for a system,
during the design process to describe the system to engineers implementing the system and after implementation to document the system's structure and operation.
When a system is to be marketed as a software product
a testing process called 'beta testing' is often used
an architectural pattern should describe
e a system organization that has been successful in previous systems
The requirements engineering process
aims to produce an agreed requirements document that specifies a system satisfying stakeholder requirements. Requirements are usually presented at two levels of detail.
The MVC pattern was originally proposed in the 1980s as an approach to GUI design that
allowed for multiple presentations of an object and separate styles of interaction with each of these presentations
You should record the results of the risk analysis in the project plan
along with a consequence analysis, which sets out the consequences of the risk for the project, product, and business
This is essential for deciding how to provide the required system functionality
and how to structure the system to communicate with its environment
This can be user interaction, which involves user inputs and outputs, interaction between the system being developed
and other systems or interaction between the components of the system
a software architecture can serve firstly as a design plan for the negotiation of system requirements,
and secondly as a means of structuring discussions with clients, developers, and managers. T
Commercial systems developers were not familiar with the military procedures or terminology
and so often invented their own terms.
Each possible interaction is named in an ellipse
and the external entity involved in the interaction is represented by a stick figure.
Military software systems were probably the first systems in which configuration management was used
and the terminology for these systems reflected the processes and procedures already in place for hardware configuration management
Because objects are associated with things, there is often a clear mapping between realworld entities (such as hardware components)
and their controlling objects in the system.
You identify the major components that make up the system and their interactions,
and then may organize the components using an architectural pattern such as a layered or client-server model. However, this is not essential at this stage.
Risk management involves
anticipating risks that might affect the project schedule or the quality of the software being developed, and then taking action to avoid these risks
The architecture of a software product line often reflects a general
application-specific architectural style or pattern. For example, consider a product line system that is designed to handle vehicle despatching for emergency services
In successful companies and economies, this is achieved when people are respected by the organization and
are assigned responsibilities that reflect their skills and experience
extreme programming, requirements
are expressed as scenarios (called user stories), which are implemented directly as a series of tasks
Processes based on formal transformations
are generally only used in the development of safety-critical or security-critical systems
Software design and implementation activities
are invariably interleaved.
Internal software attributes, such as the cyclomatic complexity of a component
are measured by using software tools that analyze the source code of the software
Software systems and components
are potentially reusable entities
Plan-driven processes
are processes where all of the process activities are planned in advance and progress is measured against this plan.
The requirements for a system
are the descriptions of what the system should dothe services that it provides and the constraints on its operation
Design patterns
certain common patterns of building design that were inherently pleasing and effective
control metrics support process management,
control metrics support process management, and predictor metrics help you predict characteristics of the software
1. The people in the group
You need a mix of people in a project group as software development involves diverse activities such as negotiating with clients, programming, testing, and documentation
3. The component level Components are collections of objects and object classes that operate together to provide related functions and services.
You often have to adapt and extend the component by adding some code of your own. An example of component-level reuse is where you build your user interface using a framework
there are software engineering fundamentals that apply to all types of software system..
You should make as effective use as possible of existing resources. This means that, where appropriate, you should reuse software that has already been developed rather than write new software.
There was an assumption that the code would be
controlled and developed by a small core group, rather than users of the code
There are many variants of this process in use but, to be effective, change management processes should always have a means of checking,
costing, and approving changes. This process should come into effect when the software is handed over for release to customers or for deployment within an organization.
3. Finally, to satisfy self-realization needs, you need to give people responsibility for their work, assign them demanding (but not impossible) tasks,
d provide a training programme where people can develop their skills. Training is an important motivating influence as people like to gain new knowledge and learn new skills.
Because of the organizational considerations involved
deciding on a project price should be a group activity involving marketing and sales staff, senior management, and project managers.
3. Traceability policies These policies
define the relationships between each requirement and between the requirements and the system design that should be recorded. The traceability policy should also define how these records should be maintained
Baselines may be specified using a configuration language, which allows you to
define what components are included in a version of a particular system.
The move to reuse-based development has been in response to
demands for lower software production and maintenance costs, faster delivery of systems, and increased software quality
you can use a state machine model that shows how the object instance changes state
depending on the messages that it receives
functional system requirements
describe the system functions, its inputs and outputs, exceptions,
If an incremental approach to development is used,
each increment should be tested as it is developed, with these tests based on the requirements for that increment. In extreme programming, tests are developed along with the requirements before development starts
costs and schedule pressure meant that this approach became increasingly unviable,
especially for commercial and Internet-based systems.
t is difficult, in practice, to separate functional and non-functional requirements in the requirements document
f the non-functional requirements are stated separately from the functional requirements, the relationships between them may be hard to understand.
Cyclomatic complexity
his is a measure of the control complexity of a program. This control complexity may be related to program understandability.
Therefore when a system release is produced, it must be documented to ensure that it can be re-created exactly in the future.
his is particularly important for customized, long-lifetime embedded systems, such as those that control complex machines.
Software engineering and the Web
his led to the development of a vast range of new system products that delivered innovative services, accessed over the Web.
3. Interaction-oriented people
ho are motivated by the presence and actions of co-workers. As software development becomes more user-centered, interactionoriented individuals are becoming more involved in software engineering.
an independent authority, such as the system architect,
hould assess and prioritize changes that affect those system modules that have been produced by different development teams.
Quality attributes such as maintainability, understandability, and usability are external attributes that relate to
how developers and users experience the software
The project plan, which is created at the start of a project, is used to communicate
how the work will be done to the project team and customers, and to help assess progress on the project.
Configuration management policies and processes define
how to record and process proposed system changes, how to decide what system components to change, how to manage different versions of the system and its components, and how to distribute changes to customers
Project definition sources
• definition of scope • user requirements, possibly supported by user profiles and key high-level use case definitions • supplementary, non-functional, requirements • interfaces: users, hardware, software, communications
There are three main parameters that you should use when computing the costs of a software development project:
• effort costs (the costs of paying software engineers and managers); • hardware and software costs, including maintenance; • travel and training costs.
The artefacts that must be signed off to allow the 'Lifecycle objectives' milestone to be met at the end of the inception phase, for example, should be based on:
• project scope definition • cost and schedule definitions • risk identification • project feasibility • plans for the project (development) environment.
we have modified the list to reflect the types of project that you are likely to encounter:
• responding to market demand for a feature, product or service • addressing internal needs or opportunities within the organisation • servicing a customer request for a bespoke system
we have modified the list to reflect the types of project that you are likely to encounter:,,
• technology-driven need to update an existing system • constraints such as legal changes • improving the way a system operates, such as reducing environmental impact • infrastructure development (originally categorised as 'social need', such as providing drinking water).
