Unit 1 Flashcards
In Example 3, we suggested that two systems, for patient monitoring and managing medical records, might be combined into a single system. Suggest an additional function that might be possible with the combined system that would not have been possible with either of the two original systems alone. What can you say about the boundary of the combined system compared with the boundaries of the original systems?
Suppose the monitoring system detected that a patient taking a common drug had a heart problem. If the two systems were combined, it would possible to automatically check whether the heart problem might be due to a known allergy recorded in the patient’s record.
The boundary of the combined system encompasses a wider scope than the combined boundaries of the separate systems because of their relationship.
For each of the three characteristics of software mentioned above (Malleability, Complexity and Size), explain how errors might arise in a piece of developed software.
Malleability: every time a change is made to a piece of software it introduces the possibility of a new error; the easier it is to make changes, the greater the chances of introducing new errors into the software.
Complexity: the more complex a piece of software becomes, the more chances there are of introducing an error.
Size: there are likely to be more errors in a large piece of software than in a small one.
What is the defining quality of a good software system, and what are its main characteristics?
A good software system is one that meets its users’ needs. We can characterise a good software system as useful, usable, reliable, flexible, affordable and available.
How might greater flexibility make a software system more affordable?
Users’ needs will change over time. The time taken to implement the changes in requirements is less than if that software were inflexible. Since labour costs are the most significant component of software costs, flexible software is more affordable.
Give two reasons why a delivered software system might not meet its users’ needs.
Software systems are usually out of date even as they are being developed, since users’ needs:
Are often missed during requirements capture;
Change with time.
Suggest a means of measuring the maintainability of a software system.
We could measure the effort required by a developer to locate and eventually implement a given change to a software system. We could classify that effort in two components: the effort needed to locate and fix errors (bugs); and the effort needed to adapt the software system to meet its users’ needs.
How does a legacy system relate to the attributes of a good software system?
A legacy system is lacking in flexibility. It may have started out with all the characteristics of a good software system, yet those characteristics may have changed over time. The longer a software system is used, the more difficult it will become to maintain, because of the number of changes made since its development. So it gradually loses its maintainability. As a software system ages, the quality of applied changes will be affected by their affordability and the relative importance of the system. Ultimately all the staff who developed and knew about the software system may have moved on, so those new staff allocated to its maintenance may not fully comprehend its features. This can happen to all software systems, including those being developed today.
Thus a legacy system still serves some useful purpose, but there are problems that make it less flexible and maintainable (and so affordable) than it was originally.
Suggest a reason why legacy systems will always be a problem.
The inherent malleability of software makes it easy to change. You have already seen that a legacy system is lacking in flexibility as a result of the number of changes made to it during its operational lifetime. (The analogy with metal-working through malleability is useful. Once a blacksmith forms some component, usually in iron, there is a limit to the number of times that it can be heated, formed and cooled before that component becomes brittle and hence liable to failure.)
This explains why our ability to bolt features and fixes onto a legacy system means that it will eventually become too fragile, and it will become precarious to go any further. The staff issues mentioned compound these problems.
Why might you consider splitting up a large project into smaller chunks?
There is a limit to how much a person can understand at any one time. So there is a limit to the size of a software system that any one person can deal with. By splitting a large project into smaller chunks, it is possible to identify a number of more manageable tasks for those involved.
How does the complexity of a software system affect the maintenance task?
It is essential to be able to make a change to a software system without having to know all about that system. Each change becomes difficult when the flow of control and dependencies within programs are complex. The greater the number and nature of the dependencies, the harder it is to maintain a software system.
What is a module?
A module is any identifiable part of a software system that is considered separately. For example, modules may be subroutines (in a procedural language equivalent to methods), classes (in an object-oriented language), library functions or other constructs that may be treated independently.
Why does it help to have low coupling in a software system?
With low coupling, there are few dependencies between modules. Therefore changes made to one part (one or more modules) of a software system are less likely to propagate throughout the whole system. (A clear record of the dependencies between modules helps you to predict the impact of a proposed change to a software system.)
Give examples of the kinds of information that would be valuable when considering a change to a given module.
There are two kinds of information that contribute to the analysis of a proposed change, and these are as follows:
1) What assumptions have been made in other modules (clients) that call upon the module in question? An understanding of the expected services of a module will help assess the risks associated with a particular change.
2) Which modules are clients of the module in question? This information indicates how far a change may propagate through the software system.
What are the context dependencies of a module? How do they relate to a module’s interface?
The context dependencies for a module are those services that the module needs in order to work correctly. You can express the context dependencies for a module in terms of other interfaces. In effect, you can express the responsibilities of a module in terms of its interface and context dependencies. If the context provides the services that the module needs, then the module can guarantee the provision of the services described in its interface.
What are the benefits of using modules with defined interfaces?
The benefits are as follows:
1) Developers will need to know only about the module’s interface (its syntax and what it achieves –its semantics), not how it provides those services, and consequently developers can be more productive;
2) Developers can understand aspects of the software system more thoroughly, so fewer bugs will be introduced;
3) It should be easier to find bugs, as irrelevant modules are avoided;
4) The possibility of module reuse is increased once it Is known what that module provides and requires.
Why does it help to have high cohesion in the modules of a software system?
With high cohesion, a module carries out a sensible set of operations or activities; ideally, high cohesion implies just one major abstraction per module. The interface abstracts away from what a developer must know in order to use a module. The developer can concentrate on the work required and create software that is useful, usable, reliable and affordable. Indeed, high cohesion tends to make a module more usable.
What characteristics should a module display that will help to ensure that it is easy and cheap to develop and maintain, and that errors are kept to a minimum?
A module should have low coupling and high cohesion, a good abstraction, and a well defined interface that is an encapsulated abstraction of a well understood concept.
Why is it important to achieve a balance between coupling and cohesion?
In constructing a system, we may have a choice between a smaller set of loosely coupled, less cohesive modules, or a larger set of tightly coupled, more cohesive modules. In the former case each module may be difficult to understand; in the latter case the relationships between them may be over-complex. We need to strike an appropriate balance.
What are the characteristics of a component?
A component is a module that is considered to be a sufficiently good abstraction for the problem in hand. A component should be capable of being reused in future projects having the same software architecture, or being easily replaced at a later date within the existing software system. A good component has a well defined interface and is an encapsulated abstraction of a well understood concept.
How does the concept of an architecture contribute to component reuse?
The architecture of a (software) system embodies high-level decisions about the overall structure of the system, and this architecture may apply to more than one system. (An approach called product-line development, covered later in M363, will produce a sequence of systems that have much in common, through a shared architecture, and makes software more affordable if it uses the same components.)
Which form of decomposition might be used in a software architecture?
Complexity is best managed by decomposing a problem into smaller subproblems. The basic form of decomposition used in a software architecture is partitioning to meet a number of separate concerns. For example, we might want to separate the user interface from the core business services.
Why would a good software system need to be both useful and usable?
If a software system is not useful, it will not meet the users’ needs; if it is not usable, the users will be hindered from performing the tasks they need the software for.
If a piece of software contained bugs, how might they affect the usefulness and usability of that software?
If a piece of software contained bugs, it might not meet the users’ needs at all in some respect, or it might meet their needs but in a way that affected usability and made it harder for users to carry out particular tasks.
Give the characteristics of an engineering approach that support the argument that software development is an engineering discipline.
Software development follows an engineering approach provided that those involved:
1) Are concerned with meeting a clear set of requirements that are defined as clearly
as possible;
2) Use a defined process with clear activities, each of which has at least one identifiable end-product;
3) Can apply their skills and experience to the tasks demanded of them;
4) Regard validation and verification to be as essential as building the software itself;
5) Make sensible use of tools and standards.
What is a development process?
A development process is a set of rules that define how a software development project should be carried out. It incorporates a life cycle, and involves a number of methods and procedures.
What is the role of project management with respect to the deliverables of a development project?
Each deliverable uses resources, such as developers’ time, that add to its cost. A good software system must be affordable, and project management is concerned with controlling the cost of developing such systems. So project management involves the identification of the appropriate deliverables for a given set of requirements, and controlling the cost of producing them. Project management also involves ensuring that deliverables are produced on time, and taking steps to cope with any delays.
What is the difference between a customer and a user?
A customer is the person who pays for a software system, whereas a user is someone who will use that system on a day-to-day basis. A customer will also be a user when the proposed software system is intended to support their job.