Reference: Sommerville, Software Engineering, 10 ed., Chapter 19

 

Software engineering is not an isolated activity but is part of a broader systems engineering process. Software systems are therefore not isolated systems but are essential components of broader systems that have a human, social or organizational purpose.

Systems that include software fall into two categories:

• Technical computer-based systems include hardware and software but not humans or organizational processes. Off the shelf applications, control systems, etc.
• Socio-technical systems include technical systems plus people who use and manage these systems and the organizations that own the systems and set policies for their use. Business systems, command and control systems, etc.

Systems engineering includes procuring, specifying, designing, implementing, validating, deploying and maintaining socio-technical systems. It is concerned with the services provided by the system, constraints on its construction and operation and the ways in which it is used to fulfill its purpose or purposes.

Software is now the dominant element in all enterprise systems. Software engineers have to play a more active part in high-level systems decision making if the system software is to be dependable and developed on time and to budget. As a software engineer, it helps if you have a broader awareness of how software interacts with other hardware and software systems, and the human, social and organizational factors that affect the ways in which software is used.

Systems engineering stages:

• Conceptual design: sets out the purpose of the system, why it is needed and the high-level features that users might expect to see in the system.
• Procurement or acquisition: conceptual design is developed so that decisions about the contract for the system development can be made.
• Development: Hardware and software is engineered and operational processes defined.
• Operation: The system is deployed and used for its intended purpose.

Many professional disciplines are involved in the systems engineering process. There are three reasons for misunderstanding or other differences between engineers with different backgrounds:

• Communication difficulties: Different disciplines use the same terminology to mean different things. This can lead to misunderstandings about what will be implemented.
• Differing assumptions: Each discipline makes assumptions about what can and can't be done by other disciplines.
• Professional boundaries: Each discipline tries to protect their professional boundaries and expertise and this affects their judgments on the system.

Socio-technical systems are large-scale systems that do not just include software and hardware but also people, processes and organizational policies. Socio-technical systems are often 'systems of systems' i.e. are made up of a number of independent systems. The boundaries of socio-technical system are subjective rather than objective: different people see the system in different ways.

Socio-technical systems are used within organizations and are therefore profoundly affected by the organizational environment in which they are used. Failure to take this environment into account when designing the system is likely to lead to user dissatisfaction and system rejection.

There are a number of key elements in an organization that may affect the requirements, design, and operation of a socio-technical system. A new system may lead to changes in some or all of these elements:

• Process changes: Systems may require changes to business processes so training may be required. Significant changes may be resisted by users.
• Job changes: Systems may de-skill users or cause changes to the way they work. The status of individuals may be affected by a new system.
• Organizational policies: The proposed system may not be consistent with current organizational policies.
• Organizational politics: Systems may change the political power structure in an organization. Those that control the system have more power.

A complex system may include software, mechanical, electrical and electronic hardware and be operated by people. System components are dependent on other system components. The properties and behavior of system components are inextricably inter-mingled. This leads to complexity. Complexity is the reason why socio-technical systems have emergent properties, are non-deterministic and have subjective success criteria:

• Emergent properties: Properties of the system of a whole that depend on the system components and their relationships.
• Non-deterministic: They do not always produce the same output when presented with the same input because the systems's behavior is partially dependent on human operators.
• Complex relationships with organizational objectives: The extent to which the system supports organizational objectives does not just depend on the system itself.

Emergent properties are properties of the system as a whole rather than properties that can be derived from the properties of components of a system. Emergent properties are a consequence of the relationships between system components. They can therefore only be assessed and measured once the components have been integrated into a system.

Two types of emergent properties:

• Functional properties: These appear when all the parts of a system work together to achieve some objective. For example, a bicycle has the functional property of being a transportation device once it has been assembled from its components.
• Non-functional emergent properties: Examples are reliability, performance, safety, and security. These relate to the behavior of the system in its operational environment. They are often critical for computer-based systems as failure to achieve some minimal defined level in these properties may make the system unusable.

System reliability is a good example of an emergent property. Because of component inter-dependencies, faults can be propagated through the system. System failures often occur because of unforeseen inter-relationships between components. It is practically impossible to anticipate all possible component relationships. Software reliability measures may give a false picture of the overall system reliability.

System reliability is influenced by:

• Hardware reliability: What is the probability of a hardware component failing and how long does it take to repair that component?
• Software reliability: How likely is it that a software component will produce an incorrect output. Software failure is usually distinct from hardware failure in that software does not wear out.
• Operator reliability: How likely is it that the operator of a system will make an error?

Failures are not independent and they propagate from one level to another.

System reliability depends on the context where the system is used. A system that is reliable in one environment may be less reliable in a different environment because the physical conditions (e.g. the temperature) and the mode of operation is different.

A deterministic system is one where a given sequence of inputs will always produce the same sequence of outputs. Software systems are deterministic; systems that include humans are non-deterministic. A socio-technical system will not always produce the same sequence of outputs from the same input sequence:

• Human elements: People do not always behave in the same way.
• System changes: System behavior is unpredictable because of frequent changes to hardware, software and data.

Complex systems are developed to address 'wicked problems' - problems where there cannot be a complete specification. Different stakeholders see the problem in different ways and each has a partial understanding of the issues affecting the system. Consequently, different stakeholders have their own views about whether or not a system is 'successful'. Success is a judgment and cannot be objectively measured. Success is judged using the effectiveness of the system when deployed rather than judged against the original reasons for procurement.

Conceptual design investigates the feasibility of an idea and develops that idea to create an overall vision of a system. Conceptual design precedes and overlaps with requirements engineering. May involve discussions with users and other stakeholders and the identification of critical requirements. The aim of conceptual design is to create a high-level system description that communicates the system purpose to non-technical decision makers.

Conceptual design activities:

• Concept formulation: Refine an initial statement of needs and work out what type of system is most likely to meet the needs of system stakeholders.
• Problem understanding: Discuss with stakeholders how they do their work, what is and isn't important to them, what they like and don't like about existing systems.
• System proposal development: Set out ideas for possible systems (maybe more than one).
• Feasibility study: Look at comparable systems that have been developed elsewhere (if any) and assess whether or not the proposed system could be implemented using current hardware and software technologies.
• System structure development: Develop an outline architecture for the system, identifying (where appropriate) other systems that may be reused.
• System vision document: Document the results of the conceptual design in a readable, non-technical way. Should include a short summary and more detailed appendices.

System procurement is the process of acquiring a system (or systems) to meet some identified organizational need. Before procurement, decisions are made on: scope of the system, system budgets and timescales, high-level system requirements. Based on this information, decisions are made on whether to procure a system, the type of system and the potential system suppliers. These decisions are driven by:

• The state of other organizational systems and whether or not they need to be replaced
• The need to comply with external regulations
• External competition
• Business re-organization
• Available budget

It is usually necessary to develop a conceptual design document and high-level requirements before procurement. You need a specification to let a contract for system development. The specification may allow you to buy a commercial off-the-shelf (COTS) system. Almost always cheaper than developing a system from scratch. Large complex systems usually consist of a mix of off the shelf and specially designed components. The procurement processes for these different types of component are usually different.

Three types of systems or system components may have to be procured:

• Off-the-shelf applications that may be used without change and which need only minimal configuration for use.
• Configurable application or ERP systems that have to be modified or adapted for use either by modifying the code or by using inbuilt configuration features, such as process definitions and rules.
• Custom systems that have to be designed and implemented specially for use.

Issues with system procurement:

• Organizations often have an approved and recommended set of application software that has been checked by the IT department. It is usually possible to buy or acquire open source software from this set directly without the need for detailed justification. There are no detailed requirements and the users adapt to the features of the chosen application.
• Off-the-shelf components do not usually match requirements exactly. Choosing a system means that you have to find the closest match between the system requirements and the facilities offered by off-the-shelf systems.
• When a system is to be built specially, the specification of requirements is part of the contract for the system being acquired. It is therefore a legal as well as a technical document. The requirements document is critical and procurement processes of this type usually take a considerable amount of time.
• For public sector systems especially, there are detailed rules and regulations that affect the procurement of systems. These force the development of detailed requirements and make agile development difficult.
• For application systems that require change or for custom systems there is usually a contract negotiation period where the customer and supplier negotiate the terms and conditions for the development of the system. During this process, requirements changes may be agreed to reduce the overall costs and avoid some development problems.

System development usually follows a plan-driven approach because of the need for parallel development of different parts of the system. Little scope for iteration between phases because hardware changes are very expensive. Software may have to compensate for hardware problems. Inevitably involves engineers from different disciplines who must work together. Much scope for misunderstanding here. Different disciplines use a different vocabulary and much negotiation is required. Engineers may have personal agendas to fulfil.

The system development process:

• Requirements engineering: The process of refining, analyzing and documenting the high-level and business requirements identified in the conceptual design.
• Architectural design: Establishing the overall architecture of the system, identifying components and their relationships.
• Requirements partitioning: Deciding which subsystems (identified in the system architecture) are responsible for implementing the system requirements.
• Subsystem engineering: Developing the software components of the system, configuring off-the-shelf hardware and software, defining the operational processes for the system and re-designing business processes.
• System integration: Putting together system elements to create a new system.
• System testing: The whole system is tested to discover problems.
• System deployment: the process of making the system available to its users, transferring data from existing systems and establishing communications with other systems in the environment.

Requirements engineering and system design are inextricably linked. Constraints posed by the system's environment and other systems limit design choices so the actual design to be used may be a requirement. Initial design may be necessary to structure the requirements. As you do design, you learn more about the requirements.

Subsystem engineering may involve some application systems procurement. Typically parallel projects developing the hardware, software and communications. Lack of communication across implementation teams can cause problems. There may be a bureaucratic and slow mechanism for proposing system changes, which means that the development schedule may be extended because of the need for rework.

System integration is the process of putting hardware, software and people together to make a system. Should ideally be tackled incrementally so that sub-systems are integrated one at a time. The system is tested as it is integrated. Interface problems between sub-systems are usually found at this stage. May be problems with uncoordinated deliveries of system components.

System delivery and deployment takes place after completion, when the system has to be installed in the customer's environment. A number of issues can occur:

• Environmental assumptions may be incorrect;
• May be human resistance to the introduction of a new system;
• System may have to coexist with alternative systems for some time;
• May be physical installation problems (e.g. cabling problems);
• Data cleanup may be required;
• Operator training has to be identified.

Operational processes are the processes involved in using the system for its defined purpose. For new systems, these processes may have to be designed and tested and operators trained in the use of the system. Operational processes should be flexible to allow operators to cope with problems and periods of fluctuating workload.

Problems with operation automation:

• It is likely to increase the technical complexity of the system because it has to be designed to cope with all anticipated failure modes. This increases the costs and time required to build the system.
• Automated systems are inflexible. People are adaptable and can cope with problems and unexpected situations. This means that you do not have to anticipate everything that could possibly go wrong when you are specifying and designing the system.

Large systems have a long lifetime. They must evolve to meet changing requirements. Existing systems which must be maintained are sometimes called legacy systems. Evolution is inherently costly for a number of reasons:

• Changes must be analyzed from a technical and business perspective;
• Sub-systems interact so unanticipated problems can arise;
• There is rarely a rationale for original design decisions;
• System structure is corrupted as changes are made to it.

Factors that affect system lifetimes:

• Investment cost: The costs of a systems engineering project may be tens or even hundreds of millions of dollars. These costs can only be justified if the system can deliver value to an organization for many years.
• Loss of expertise: As businesses change and restructure to focus on their core activities, they often lose engineering expertise. This may mean that they lack the ability to specify the requirements for a new system.
• Replacement cost: The cost of replacing a large system is very high. Replacing an existing system can only be justified if this leads to significant cost savings over the existing system.
• Return on investment: If a fixed budget is available for systems engineering, spending this on new systems in some other area of the business may lead to a higher return on investment than replacing an existing system.
• Risks of change: Systems are an inherent part of business operations and the risks of replacing existing systems with new systems cannot be justified. The danger with a new system is that things can go wrong in the hardware, software and operational processes. The potential costs of these problems for the business may be so high that they cannot take the risk of system replacement.
• System dependencies: Other systems may depend on a system and making changes to these other systems to accommodate a replacement system may be impractical.

Proposed changes have to be analyzed very carefully from a business and a technical perspective. Subsystems are never completely independent so changes to a subsystem may have side-effects that adversely affect other subsystems. Reasons for original design decisions are often unrecorded. Those responsible for the system evolution have to work out why these decisions were made. As systems age, their structure becomes corrupted by change so the costs of making further changes increases.