What are the 3 characteristics that affect software development?
Malleability
Complexity
Size
What is malleability of a software?
Software is easy to change (programmers are often tempted to tweak their code). This malleability creates a constant pressure for software to be changed rather than replaced. Every change introduces the possibility of new errors.
What is the complexity of a software?
Software is often complex. Complexity can usually be recognised, but it is less easy to define. One item of software can be considered more complex than another if it requires more explanation.
Part of that complexity arises from the potential variety of pathways between the components of a system. The number of errors is likely to depend on the complexity of a system.
What is the size characteristic of a software?
It is likely that there will 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, available and affordable.
How might greater flexibility make a software system more affordable over its whole life?
Users’ needs will change over time. The time taken to implement the changes in requirements in a flexible system is less than for less flexible software.
As 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 because:
some needs are often missed during requirements capture
users’ needs change with time.
For each of the three characteristics of software, explain why errors might arise in a piece of developed software
Malleability. As change is easy to make, often changes are introduced without thorough consideration of the full consequences of each new change introduced.
Complexity. The more complex a piece of software becomes, the more chances there are of a change affecting other parts of the software.
Size. The greater the number of lines of code in a piece of software, the greater the number of likely errors.
What are the characteristics of legacy systems?
Suggest a means of measuring the maintainability of a software system?
We could measure the effort required by a developer to locate and implement a given change to a software system. That effort can be classified 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.
What can we learn from legacy systems about developing a good software system?
A legacy system may have started out with all the characteristics of a good software system, yet those characteristics may have changed over time, resulting in a less flexible and maintainable product. As change is inevitable, the right processes should be in place to make change happen in a more controlled way. This requires the adoption of standards and documentation conventions that help decision making on changes and how to introduce them. Any changes need to be well documented so that software is still understandable and less dependent on the people initially involved with developing and maintaining the software.
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.
What is decomposition of a software?
Decomposition means that we can divide the problem into smaller pieces, so that we can deal with them individually.
What are 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.
What is a problem domain in software development?
Problem domain is the specific area of knowledge, real-world context, or set of issues that the software is intended to address.
What is modularization?
Modularization means decomposing a system into smaller modules.
What is the interface of a module?
The interface of a module is a description of all operations that are visible externally and how they are connected to the other modules. The knowledge of implementations is omitted.
What are context dependencies?
Context dependencies are other modules that are necessary for one module to work.
What is abstraction?
Abstraction in software engineering is the practice of hiding complex implementation details while exposing only the essential features or behavior to the user (or another part of the system).
It’s about focusing on “what” a system does rather than “how” it does it.
What is coupling in software development?
In software engineering, the term coupling is used to refer to the degree of interdependence among the different parts of a system.
What is cohesion in software development?
Cohesion is a way of describing how closely the activities within a single module are related to each other. A cohesive modules performs one task well.
Cohesion is a general concept – for example, a department in an organisation might have a cohesive set of responsibilities (accounts, say), or not (miscellaneous services).
What is circular dependency?
Circular dependency is a form of strong coupling.
Why might you consider splitting up a large project into smaller chunks?
There is a limit to how much one 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