What are the shared characteristics of different approaches to rapid software development?
User interfaces face heavy scrutiny by human factors engineering teams.
Specification, design, and implementation are independent processes.
The system is developed and delivered as a unified code base.
The system is developed and delivered as a series of versions.
"The processes of specification, design, and implementation are inter-leaved."
User interfaces are often developed using an interactive development system that supports rapid UI development.
What are the two fundamental types of software product?
Customised products designed to meet the specific needs of a single customer.
Industrial products that are designed to meet the needs of only industrial businesses.
Standards based products that are designed to meet the needs of ISO registered companies.
Generic products that are designed to meet the needs of many different customers.
Networked products that are designed to meet the needs of collaborative groups.
What are the 4 sectors in each loop in Boehm's spiral model?
Development and validation
Risk assessment and reduction
What are the types of abstract system model that are recommended by the MDA method?
One or more platform-specific models
What are the principal functions of the 4 layers in a generic information system architecture?
"User communications, authentication, and authorization"
Web browser interface
Forms and query manager
Database and transaction management
Information retrieval and modification
What are the advantage of explicitly designing and documenting a software architecture?
It helps with large-scale reuse
It reduces the cost of the system
"It boosts performance, robustness, distributability, and maintainability"
It improves stakeholder communications
It encourages a detailed analysis of the system
It eliminates safety risks
Which answer/s describe/s the pipe and filter architecture?
Clients make service requests to the proper server
The system is organized into layers with related functionality associated with each layer
A system is decomposed into a set of functional transformations that consume inputs and produce outputs
Components do not interact directly, only through the repository
The functionality of the system is organized into services
Data flows from one function to another and is transformed as it passes through the sequence
All shared data is held in a central database that can be accessed by all sub-systems
A layer provides services to the layer above it
List the fundamental questions that should be addressed in architectural design?
What control strategy should be used?
What architectural style or styles are appropriate?
Is there a generic application architecture that can be used?
How will the system be distributed?
How should the system be structured?
What are the most important advantages of a client-server architecture?
It is easy to add a new server or upgrade existing servers without disrupting the system
This is a distributed architecture so that it is possible to provide services on different computers
Can be implemented as either a sequential or concurrent system
Allows replacement of entire layers so long as the interface is maintained.
Changes made by one component can be propagated to all components
Redundant facilities can be provided in each layer to increase the dependability of the system
Components can be independent - they don't need to know about each other
Workflow style matches the structure of many business processes
What are the fundamental architectural views proposed in Krutchen's 4+1 model?
A maintenance view that estimates the ratio of software development versus maintenance
A logical view that shows the key abstractions of the system
A physical view that shows the distribution of software on the system hardware
A connections view that shows how the hardware is going to interact
A development view that shows how the system is decomposed for development
A code view that shows how algorithms should be written
A process view that shows the interacting processes in the system
A language view that determines which software languages are appropriate for the system
What are some fundamental characteristics of a repository architecture?
All shared data is held in a central database that can be accessed by all sub-systems
Data processing is organized so that each component is discrete and only performs one type of data transformation
The data flows from one component to another for processing
"Components do not interact directly, only through the repository"
What do architectural patterns comprise?
Description of strengths and weaknesses
How the pattern should be deployed across multi-core machines
Code listings of database transaction statements
A stylized abstract description of good practice in architectural design that has been tried and tested in different systems and environments
Comparisons with other patterns
Information on when it is and is not appropriate to use that architectural design.
What are some ways in which an architectural model of a system should be used?
To document the architecture of an existing or an intended system
To ambiguate system requirements
To facilitate discussion about the most appropriate architecture for a system
To avoid writing code
What are transaction-processing applications?
Allows controlled access to a large base of information
Translators of natural or artificial language into another representation
They are organized so that transactions cannot interfere with each other and the integrity of the database is maintained
Database-centered applications that process user requests for information and update the information in the database
Usually web based systems that are accessed through a web browser
What are some use-case characteristics?
It shows the actors involved with an interaction.
It shows the interactions between system components as well as actors.
It shows how the system reacts to internal and external events.
It identifies a typical interaction with a system.
What are the principal stages of the requirements engineering process?
Requirements elicitation and analysis
What checks should be applied during requirements validation?
The verifiability of the requirements should be assessed
User competency checks
Noise floor checks
Why is it difficult to elicit requirements?
Stakeholders don't know what they want
The business environment may change during elicitation
Stakeholders use their own language that requirements engineers may not understand.
Stakeholder requirements may conflict
Political factors may influence the system requirements
What should be included in a scenario?
A description of the system state when the scenario finishes
A description of the normal flow of events
A description of what can go wrong and how to handle it
Information about concurrent activities
A description of what's expected when the scenario starts
Which document officially defines the requirements that should be implemented by system developers?
Software Specification Document
Software Requirements Document
Technical Design Document
Software Design Specification
What do Gamma et al. suggest are the essential elements of a design pattern?
A meaningful name
A statement of the consequences of applying the pattern.
Vocabulary for talking about the design
A description of the problem and when the pattern can be applied
A well tried solution to a common problem
A description of accumulated wisdom and experience
Object characteristics such as inheritance and polymorphism
A solution description, which shows the components in the solution and their relationships
Which selections best describe approaches that may be used to identify object classes?
Use scenario-based analysis
Describe the dynamic structure of the system and show the interactions between the system objects
Grammatical analysis identifying nouns and verbs
Describe the static structure of the system using object classes and their relationships
Show logical groupings of objects into coherent subsystems
Identify tangible things in the application domain
What do you understand by the system context and interaction model?
The interaction model shows logical groupings of objects into coherent subsystems
The system context is a static model of the other systems in the environment of the system being designed
The system context uses a grammatical analysis of a natural language description of the system to be constructed
An interaction model is a dynamic model that describes how the system being designed interacts with its environment
What are the standard tools in a software development platform?
A language debugger
GNU Build System
Graphical editing tools for UML models
Project support tools for code control
Testing tools that can automatically run program tests
An integrated compiler and syntax-directed editing systems
What are the principal aims of software configuration management?
Find out what components have been changed and compile and link components to create a system
System integration, where support is provided to help developers define what versions of components are used to create each version of a system
Version management, where support is provided to keep track of the different version of software components
To support system integration so that all developers can access the project code and documents in a controlled way
Problem tracking, where support is provided to allow users to report bugs and other problems
Why is it important to specify the interfaces of components that are being developed by a software engineering team?
Interface design is not concerned with specifying the detail of the interface to an object or to a group of objects
Interfaces have to be specified so that objects and sub-systems can be designed in parallel
Once an interface has been specified, the developers of other parts of the system may assume that the interface will be implemented
You should include details of the data representation in an interface design since attributes are not defined in an interface specification
Which concepts describe the idea of open-source development.
The source code of a software system is made publicly available and volunteers participate in the further development of the system
When high-quality open source options are available, you can save time and money by using these systems
Great for developing software to a specific set of organizational requirements
Any contributor to an open source development may fix bugs and add new features to a system
The Linux operating system
Making a software system open source guarantees community involvement
What are the 5 key activities in an object-oriented design process?
Understand and define the context and use of the system.
Identify the principal objects in the system
Provide a standard way of accessing the elements in a collection
Specify object interfaces
Develop design models
Design the system architecture
Tidy up the interfaces to a number of related objects
What are the three types of user testing?
Alpha testing, where users work with the development team to test the software as it is being developed
Acceptance testing, where customers test a system to check that it is ready for deployment
Acceptance testing, where users work with the development team to test the software as it is being developed
Beta testing where the software is released to selected users for testing before the formal system release
Alpha testing, where the software is released to selected users for testing before the formal system release
Beta testing, where customers test a system to check that it is ready for deployment
What guidelines does Whittaker suggest for defect testing?
Design inputs that might cause buffers to overflow
Force invalid outputs to be generated
Choose inputs that force all error messages to be generated
Force computation results to be too large or too small.
Repeat the same input numerous times
Use the wrong parameter types in function calls
Use metric units where US standard units are required
Randomly start and stop the program multiple times
Interface errors fall into three classes. What are they?
Interface misuse: A calling component calls some other component and makes an error in the use of its interface such as the wrong number of parameters.
Interface misunderstanding: A calling component makes assumptions about the called component. An unsorted array might be sent when a sorted array is required.
Timing errors: Two components may be operating at different speeds. However, old data is better than no data.
Interface misuse: A calling component calls some other component and makes an error in the use of its interface such as sending unordered arrays.
Timing errors: Two components may be operating at different speeds. Consumers may access out of date information.
Interface misunderstanding: A calling component makes assumptions about the called component such as which native data types are in the parameter list.
Briefly describe the principal stages of testing for a commercial software system.
Release testing: the system is tested to check that it meets its requirements. This is usually held by the original software developers.
Release testing: the system is tested to check that it meets its requirements. This is usually held by a separate team.
Component testing: where individual program units are tested. Component testing should focus on testing the functionality of objects and methods.
Development testing: the system is tested to discover bugs and defects. System designers are not likely to be involved.
Component testing: where component interfaces are tested. Several individuals create composite components.
User testing: the system is tested in the user's environment. Unit testing is a type of user testing.
User testing: the system is tested in the user's environment. Acceptance testing is a type of user testing.
Development testing: the system is tested to discover bugs and defects. System designers are likely to be involved.
Software systems require a certain level of confidence. What is this 'level' based on?
Software Inspections and Reviews
What is emergent behavior?
Behaviors exhibited by emergents
Elements of system functionality that become obvious when you put the components together.
Untested functionality that users' discover after release
Behaviors synonomous with emergency broadcasts
What are the advantages of inspections over testing?
Inspections can consider broader quality attributes as well as program defects.
Testing can only show the presence of errors, not their absence
Incomplete versions of a system can be tested
Inspections can discover many errors.
In testing, one error may mask another.
What are the different types of component interfaces?
Shared memory interfaces
Software design interfaces
Message passing interfaces
Public and private interfaces
What tests should be included in object class testing?
Tests that set and access all object attributes
Tests for all operations in isolation
Tests that simulate all events that cause a state change
Tests that force the object into all possible states
What process metrics might be used to assess maintainability?
Number of outstanding change requests
Average time required for impact analysis
Number of requests for corrective maintenance
Average time taken to implement a change request
Why is it usually more expensive to add functionality after a system is in operation?
Senior staff engineers are usually placed on maintenance teams.
The maintenance contract is usually separate from the development contract. So why should a development team write maintainable software?
Development is seen as a less-skilled process. Therefore maintenance engineers are paid more.
Older systems used more stringent software engineering principles and were optimized for efficiency rather than understandability.
As changes are made to programs, the structure tends to degrade which makes them harder to understand.
Teams are usually broken up after a system is complete.
Maintenance staff are usually less experienced with the application domain.
The maintenance phase is so much longer than the original development phase.
What occurs during the evolution phase of a software product?
The software may still be used but no further changes are implemented.
Its structure tends to degrade and changes become more and more expensive.
Only changes that are relatively small and essential.
Significant changes to the software architecture and functionality may be made.
Only small tactical changes are made to it.
A transition point where significant changes and implementing new requirements becomes less and less cost effective.