Online trading system project specifications
Robustness is responding reasonably to unanticipated inputs or conditions. Systems that respond to unexpected inputs or operating conditions in a reasonable way are robust.
The robustness of a system is largely determined by how programmers respond when they encounter "impossible" conditions in their code. See code listing 1. Verifiability is the measure of effort required to 1 specify the validation criteria for a work product, and 2 verify that the work product meets its validation criteria.
For example, a design is harder to verify than a mathematical routine because the criteria for establishing the correctness of a design is harder to define than the criteria for establishing the correctness of a mathematical routine. A mathematical routine is also easier to test because it can be isolated from its environment and tested with known values.
Verifiability is a little more general than testability. While testing is only practical for code, all work products can be verified using static analysis techniques. Dynamic testing is the operation of a system for the purposes of verifying that is works correctly. Static analysis is the analytical review of work products including code for the purpose of verifying that the work product conforms to its specifications or requirements.
All of the work products of the software life cycle can be verified using either dynamic or static techniques. One way to enhance the verifiability of code is to instrument it with automated test cases. Automated testing is discussed in chapter A system is efficient if it performs its function without wasting resources such as CPU time, memory, disk space, and bandwidth.
Efficiency is mainly a problem when it affects performance. Efficiency is an internal quality, and performance is an outward or external quality. A routine might be inefficient but as long as it doesn't cause unacceptable performance as seen by the end user, it's not a performance problem. Efficiency is often in conflict with other desirable quality goals such as portability and maintainability. Increases in efficiency usually come at the expense of these other characteristics and vice versa.
Advances in technology make finding the right balance a moving target. Faster microprocessors and cheaper memory make certain inefficiencies more tolerable, but demand for smaller less expensive devices increases the priority of efficiency for many applications.
Portability is the measure of effort required to move a software system to a new hardware or software environment. Because an operating system and possibly other middleware sit between an application and the underlying hardware, portability between software environments is often the biggest concern.
Software dependencies that can limit portability include dependencies to the operating system, database, runtime environment or other services such as message queues, authentication directories, etc. The best way to plan for portability is to modularize around potential dependencies. For example, the first layer in the layered architecture style is often an abstract layer for operating system services.
Given such a layer, the changes required to move the program to a new operating system would be limited to a single layer in the design. For more information on the layered architecture style see chapter The portability of a system is often expressed as the percentage of effort required to write the system from scratch in a new environment without the aid of the existing system.
Portability is usually defined relative to a specific target environment [Gilb 88]. Reusability is the measure of effort required to reuse a component or artifact in a context other than the one for which it was originally developed. Reusability is another quality characteristic that applies not just to code, but any artifact created during the software life cycle. An organization with a standard development process usually has a collection of software process assets such as templates and sample documents that can be reused across projects.
Following a standard development process itself can be considered a form of reuse. Most attention, however, is usually placed on code reuse because it offers the biggest opportunity for leveraging assets. Many organizations promote the creation and use of a common repository of reusable assets. The open source community exemplifies the idea on a larger scale. Simply using the class library associated with a programming language is another form of code reuse.
Developing components for reuse usually costs more than developing for single use. However, if the components can be reused and leveraged across multiple systems, the net result will be a reduction in expenses. Opportunities for reuse are described in more detail in chapter Before a component can be maintained, reused or extended it must be understood. Understandability is the measure of effort required to understand the purpose of a component.
What does the component do? How does it do it? What is the relationship between the component and other components? As Boehm's quality model in figure 13 shows, understandability is related to the more primitive quality characteristics: One of the main ways of achieving understandability is with an appropriate use of abstraction as a technique for hiding complexity.
There is a staggering amount of detail in even moderately sized work products, but its possible to organize this detail in a way such that it is revealed in layers. Understandability and readability are interchangeable.
The most common request users have when solicited for requirements is, "make it easy to use". Usability refers to the ease of use or user friendliness of an application. Usability is the measure of effort required to learn and use the application. This includes preparing input and interpreting output. An error message that describes the problem in technical terms might be helpful for the analyst that has to investigate the problem, but it doesn't make the program very usable from the user's perspective.
Usability is maximized by having a user interface UI that is consistent and predictable. Usability is reduced when implementation details are allowed to seep into the UI. This can easily happen when developers participate in UI design. They are deeply familiar with the implementation and without even realizing it, may produce designs that depend on this knowledge. For this reason many projects assign the task of UI design to a non-technical domain expert or product champion.
This is not to say that developers shouldn't be allowed to participate in UI design. Projects that don't include developers in UI design are missing a trick. Developers have the most knowledge of the capabilities and opportunities provided by the implementation technology. When making design decisions they have to be able to look at the problem from the user's perspective and forget what they know about the implementation. Really good developers can context switch between these two perspectives as needed.
Integrity is the extent to which the system is safe from unauthorized access. Integrity is synonymous with security. A system with a high degree of integrity will prevent unauthorized access, data loss, data corruption, service interruption, and virus infections both accidental and intentional.
Integrity is one quality that is absolute and can't be compromised. It would make little sense to have a system quality goal of "some integrity". With just one security problem the system looses all of its integrity. Part of defining integrity requirements for a system is making explicit the authority and level of access available to each type of user.
Interoperability is the measure of the effort required for one system to exchange data and services with another. Interoperability is increased with the use of standard interfaces. Web services promises to increase the interoperability of systems across the Internet.
Non-functional requirements tend to cut across the system they are often called emergent system properties. Non-functional requirements are qualitative. Non-functional doesn't mean non-testable. If non-functional functional requirements can be represented with binary switches, non-functional requirements are represented by variable control knobs rheostats.
Non-functional requirements are also called quality attributes. Non-functional requirements may be important to end-users external or developers internal. Internal non-functional requirements are indirectly important to end-users. One of the goals of software engineering is quality software. It's important to understand the characteristics of quality software because the choices you make during software development will likely affect one or more of these quality factors.
The characteristics of quality software can be divided into two groups: The end user may only be interested in external characteristics but internal characteristics have a strong influence on external characteristics. External characteristics of quality software are: Robustness - reasonable behavior even when given unexpected inputs. Ability of the program to continue performing despite some violations of assumptions in the specifications.
Note, some characteristics are in conflict with each other. For example, a system that maximizes efficiency may not be able to maximize readability. Software quality must be defined relative to the requirements of the end user--explicit as well as implicit requirements. The challenge for the developer is to prioritize and balance the trade-offs in an environment where the quality target may be changing.
Making tradeoffs to maximize aggregate value is one of the characteristics of an engineering discipline. The project balance cost - schedule - technical performance determines the amount of resources that can be balanced among the quality attributes above.
There are two components to technical performance: Constraints are restrictions on design and development choices. Sometimes constraints are considered non-functional requirements. I make the distinction between constraints which can not be changed and non-functional requirements limiting factors that can be balanced and traded for other limiting factors.
For example a constraint might be: In addition to product constraints there may be project constraints. TBD, the following taxonomy is probably more common: It is important to prioritize requirements. This highlights the importance of prioritizing requirements. What generally works best is grouping requirements into three different categories: The number of requirements in each group should be roughly equal. Prioritizing requirements is especially important when doing time box development i.
Risks is the secondary sort criteria. Thus for a two-year project, expect about 25 percent growth in unanticipated requirements. Define the project's vision and scope 2. Identify user classes 3. Identify appropriate representatives from each user class product champion 4. Identify and document the requirements decision-making process 5. Select and plan requirements elicitation techniques 6.
Apply the elicitation techniques to develop and prioritize the main use cases for the system architecturally significant use cases. One approach is to identify all use cases but detail those with the highest priority first. Identify quality attributes, other non-functional requirements and constraints 8. Develop functional requirements from use cases.
Optionally develop prototype to verify requirements with end users. Single requirements document User-manual draft as requirements together with requirements document that lists non-functional requirements Separate use case document, business requirements, user interface requirements Functional specifications may be represented within use cases combining user requirements and functional specifications or they may be represented separate from use cases.
The requirements document shouldn't include design or implementation details unless they are mandated constraints. When a constraint is specified it should be no more restrictive than is necessary. Some analysis or investigation of the constraint may be necessary. For example, if a mandated constraint is that the software should integrate well with Visual Basic.
NET, it's better to state the requirement as "the implementation language should compile to the. It's important to include the rational for each requirement. This helps developers interpret the requirement and make better decisions during design and implementation. The requirements document limits the range of potential designs but doesn't specify any particular design. Requirements should specify externally visible functions or attributes of the system.
Requirements should not be concerned with modular decomposition of the system and interactions between modules. The requirements document should be: Therefore, the requirements document shouldn't state the same requirement in more than one place. Note, it's impossible to remove all redundancies. For example, the introduction may provide an overview that is expanded on in detail later.
Clients and users review the requirements document for correctness and completeness. Traceability helps to insure the requirements document is valid initially and stays valid during the system's life-cycle. Requirements should be traceable to the user's problem they solve or the user need they address. The requirements document should also be written to facilitate traceability from designs back to requirements.
There is backward and forward traceability. Backwards traceability implies that a downstream element can be traced back to an upstream element that begat it. Forward traceability implies the reverse--an upstream element can be traced to down stream elements that are derived from it. Backward traceability is less applicable to the requirements document because in most cases the requirements document is the first documentation created as part of the software life-cycle.
Every requirement must be verifiable. Once implemented there must be a deterministic cost-effective way of verifying the system meets the requirement. For example, "the interface is easy to use" is not a verifiable requirement because the word "easy" is open to interpretation.
Rational and source are important in the future if someone suggests changing a requirement. Requirement management - requirements will change over time. Requirements will change as the system becomes more in focus to developers and end users.
Also, the marketplace and business environment may change during system development. It's important to control requirements change with a good requirements change process.
The requirements document should be baselined and under change management. Keep a history of changes. Proposed requirements must fit within scope of the system as defined by the vision and scope statement.
It may be that suggested requirements outside of the vision and scope are essential to the success of the system. If so, the vision and scope should be changed though the requirements change process established. There must be agreement about how decisions on requirements will be made. Inevitably there will be conflicts between what different customers, stakeholders, and even developers want. The process for making requirements decisions must be clear, documented and agreed upon by everyone.
A participatory but not necessarily consensus decision-making process usually works best. It may be impossible to get everyone to agree on every decision.
Requirement changes are typically managed by a change control board. Requirements change management is a part of configuration management CM. CM is described in lesson Requirements are well-defined and agreed to by appropriate parties 2. Plans are based on requirements. Requirements are modified according to a defined process change control procedures. Requirements management may require the full rigor of a formal change control process.
Changing requirements, misunderstanding requirements, inadequate user involvement, uncertain or changing project scope and objectives,. There are several sources and techniques for gathering requirements. Sources include users, customer, written documentation, business rules, common domain knowledge, etc. Techniques include requirements meetings most common , observation, etc.
The ultimate goal of the requirements phase or phases when gathering requirements over iterations is the organization and documentation of requirements. Organizing requirements is important because it makes it easier to verify their consistency, completeness, etc. It also helps to communicate the requirements to all involved. It takes a lot of effort to organize requirements. During requirements gathering there is a flood of requirements-related information and very little of that information comes with nice neat labels: It's the requirements engineer's job to sort through the information and organize it into categories: Vision, goal, objective, feature, functional-requirement, non-functional requirement, constraint, desired system behavior, solution option, etc.
The requirements process is somewhat different when anticipating reuse. Initial requirements are elicited. Features of existing candidate reuse components are noted. Candidate components may include COTS Commercial off the shelf components, existing components within the organization, and open source.
The customer is presented with options for reuse. This includes cost of implementing certain features given the opportunities for reuse. Some features may be expensive. Reuse may also make other otherwise expensive features easy to provide. Should developers be involved in requirements elicitation? Developers can present users with ideas, alternatives and creative suggestions for requirements and solutions.
Users may not be aware of all the options that are available. They are even less likely to be aware of the costs and risks of each option. However, developer involvement can lead to developer-driven requirements. There is a very thin line between developers offering and pursuing solutions that are beneficial to the user and suggestions by developers motivated by the technical challenge inherent in the solution.
It should be the needs of the user that drive decisions about what is a requirements. Every requirement should be represented by a use case. This prevents developers from implementing requirements that interest them but are not necessarily valuable to the end user.
Developers should be honest about risk and effort estimates for every feature. A product manager can also keep requirements in check. Including developers in requirements sessions also helps them prepare for implementation. During implementation developers make lots of small decisions that in total or even individually can have a large influence on the success of the project.
It's difficult for the requirements document to be a complete and accurate representation of everything discussed during a requirements meeting. Developers that hear user needs first hand are in a better position to make optimal decisions during implementation. Developers attending a requirements meeting should understand and respect the requirements process and not impede the progress of the meeting. When developing requirements take care to capture the true requirements and not automate an inefficient business process.
It's possible that requirements capture may point out opportunities for business reengineering. Requirements must be organized.
During requirements elicitation information doesn't arrive with nice neat labels on it. Business requirements - it should be in compliance with Sarbanes-Oxley. Project requirements - it has to be completed in 2 months. User requirement task need or use case - it should display office code as well as office name. Business rule - for example, only certain people may be allowed to make purchases through a procurement system. Functional requirement - Non-functional requirement quality attribute - no query should take longer than 4 seconds.
It should be easy to use. External interface requirement design requirement - it should publish an RSS feed. Solution idea - Sometimes requirements are presented in the form of solutions. For example, "the user must enter an ID and password" is a solution to the requirement of "the user must be authenticated". It might be OK to let a customer describe a potential solution but make sure you can separate requirement from solution. Be sure what is stated is a requirement and not a solution. If it is one possible solution, restate it as a requirement.
Constraint - the database has to be open source. Requirements are sometimes presented in the form of solutions. In establishing requirements, it is important to specifically establish the functions, attributes, constraints, preferences, and expectations of the product. Usually in the process of gaining information, functions are the first ones to be defined.
Functions describe what the product is going to accomplish. It is also important to determine the attributes of a product. Attributes are characteristics desired by the client, and while 2 products can have similar functions, they can have competely different attributes. After all the attributes have been clarified and attached to functions, we must determine the constraints on each of the atrributes.
Preferences, which is a desirable but optional condition placed on an attribute, can also be defined in addition to its constraints. Finally, we must determine what the client's expectations are. This will largely determine the success of the product. Testing is the final step on the road to establishing correct requirements. There are several testing methods used, as listed below. Establishing good requirements requires people with both technical and communication skills.
Technical skills are required as the embedded system will be highly complex and may require knowledge from different engineering disciplines such as electrical engineering and mechanical engineering. Communication skills are necessary as there is a lot of exchange of information between the customer and the designer.
Without either of these two skills, the requirements will be unclear or inaccurate. It is essential that requirements in safety critical embedded systems are clear, accurate, and complete.
The problem with requirements is that they are often weak about what a system should not do. In a dependable system, it is just as important to specify what a system is not suppose to do as to specfiy what a system is suppose to do.
These systems have an even greater urgency that the requirements are complete because they will only be dependable if we know exactly what a system will do in a certain state and the actions that it should not perform. Requirements with no ambiguities will also make the system more dependable. Extra requirements will usually be required in developing a dependable embedded system.
Requirements and Specification's Role in System Design. Systems exist everywhere in the universe we live in. The universe can be considered a system, and so can an atom. A system is very loosely defined and can be considered as any of the following definitions.
The conceptual system design is the first stage in the systems design life cycle and an example of the systems definition requirements process is shown in Figure 1. Each individual box will be explain below. In establishing system requirements, the first step is to define a need. This need is based on a want or desire.
Usually, an individual or organization identifies a need for an item or function and then a new or modified system is developed to fulfill the requirement. After a need is defined, feasibility studies should be conducted to evaluate various technical approaches that can be taken. The system operational requirements should also be defined. This includes the definition of system operating characteristics, maintenance support concept for the system, and identification of specific design criteria.
In particular, the system operational requirements should include the following elements. Usually, in defining system requirements, the tendency is to cover areas that are related to performance as opposed to areas that are related to support.
However, this means that emphasis is only placed on part of the system and not the whole system. It is essential to take into consideration the entire system when defining system requirements.
The system maintenance concept basically describes the overall support environment that the product is supposed to exist in. After the system operational requirements and system maintenance concept are defined, the preliminary system analysis is performed to determine which approach for system development should be adopted. The following process is usually applied. Finally, the conceptual design review is also performed during the conceptual design stage.
It usually occurs early in the system engineering development life cycle after the operational requirements and the maintenance concept have been defined. It is very important to verify that the requirements are correctly implemented in the design.
This is done with requirements traceability which is usually refered to as "the ability to follow the life of a requirement, in both forwards and backwards direction i. Standards for systems development such as the one from the U. Department of Defense standard A require that requirements traceability be used. Although requirments traceability has been around for more than 2 decades, there has been no consensus as to what kind of information should be used as part of a traceability scheme.
The problem is that the definition of traceability differs when taken from different points of view of the system. Each organization has a different purpose and methodology for requirements tracing. While it is not the purpose of this paper to dwell into a long discussion about requirements traceability, a short example of the methodology used at one organization will be given. The projects typically involved at Abbott Laboratories Diagnostics Division are real-time, embedded, in vitro diagnostic instruments approaching , lines of code.
They have found that traceability aids project managers in verification, cost reduction, accountability and change management. Traceability helps in verifying that software requirements are satisfied in the design process and that they are tested for during the verification process.
Traceability allows the allocation of product requirements early in the development cycle thereby reducing costs of correcting defects due to untraceable components in the integration and system test phase. Providing quantitative traceability analyses also allows for accountability in making sure that project milestones are approved, deliverables are verified, and customers are satisfied.
The documentation from traceability also keeps information organized during changes in staff or management. A specific in vitro diagnostic instrument contained approximately , lines of source code and approximately 1, software requirements that needed to be traced. While the division also has an automated traceability system ATS that allowed them to automate many of the tasks, it was the process and not the tool that led to their success. The main purpose of the traceability program is to identify links and determine that the links are complete and accurate.
The traceability analysis consists of 4 aspects: These steps are used to trace each software requirement through its design elements and test traces. The ATS can be used to design documentation matrices and test matrices that is used to perform the different analyses required.
The ATS is also able to give feedback about the design components that are not yet implemented during the life cycle. In the test phase, the ATS gives input to what requirements are covered by the test cases. There are many requirements and specification standards. They are mostly military standards as opposed to "commercial" standards. In addition, most of the standards are in the systems engineering area, and in particular deals with the software aspects.
There is also a section on requirements analysis methodologies and examples.