A Complete Solution for Software Quality
Revealing the cost of software quality.
Software is inherently complex. Controlling the quality of a software product requires a deep understanding of its structure and content. The analysis process supported by the Ada Analyzer provides the insight necessary to make informed decisions about improving software quality.
Software quality affects your ability to deliver on time and within budget. Software professionals and engineers in all disciplines know that taking the time to "do it right" early in the development cycle avoids rework delays as development proceeds. The later in the lifecycle that a problem is found, the broader its impact and the more time required to fix it. Such delays directly impair your ability to meet delivery schedules and increase the final cost of those deliverables.
The reality of CASE.
During the 1980s, many valuable lessons were learned about the application of CASE tools to the development of production-quality software on time and within budget. One of the most costly lessons was that the use of CASE tools alone was not a complete solution for achieving these objectives. Many tools were purchased and then left unused because they lacked the ability to integrate into the day-to-day process of software development. It was finally understood that only the proper combination of process, methods, training, and tools could achieve the necessary level of process integration. Only then could tool software be viewed as an asset that continued to provide a reasonable return on the original investment.
Why investments in quality are difficult to make:
- Conflicting priorities: The highest priority is delivering something that meets the stated requirements. Schedules are often tight, especially early in the process, and engineers are reluctant to take extra time to fix something that "works." Adding flexibility to make the software more adaptable to future requirement changes, for example, makes it more difficult to meet the current schedule. Engineers perceive that time allocation for quality improvement either cannot or should not be made when it delays getting a working deliverable out the door.
- Conflicting work habits: Most engineers do not enjoy developing for quality. It is more difficult to accomplish and not as much fun as simply making something work. "Elegant" solutions appeal to a programmer's sense of self-worth, but they are seldom maintainable by others who were not involved in the original design.
- Conflicting acceptance standards: Software quality is difficult to verify beyond a small set of accepted coding standards. Customers and quality-assurance personnel often are not capable of winning a discussion on quality since they seldom have the depth of understanding that the developer has. Quality thus becomes an unverifiable criterion for an acceptable delivery to the customer.
The Ada Analyzer meets these challenges by offering a combined solution of consulting, training, and tool automation to help you define quality improvement and integrate it into your software development process.
How the Ada Analyzer addresses these investment challenges:
- The Ada Analyzer focuses on actual improvement options: The frustrating aspect of most metrics-based tools is that they identify when software modules have a low relative quality rating but offer no details on the specific factors that contribute to that rating and no strategy for making improvements.
The Ada Analyzer focuses on identifying quality-improvement options rather than making value judgments. The Ada Analyzer analysis process is organized around quality-improvement objectives and how to accomplish them with minimum time investment.
- The Ada Analyzer minimizes the time and effort required to improve quality: The Ada Analyzer defines specific analysis strategies for accomplishing quality-improvement goals. It identifies the information required to evaluate potential improvements and which Ada Analyzer commands collect that information. It then explains how to interpret that information within the context of the objective. All information is placed in summary tables for easy scanning and location of actual problems. Hypertext connections to the analyzed software are included for direct traversal to the actual software for further inspection and/or repair. This dramatically accelerates the inspection and review process over manual search methods and reduces the tedium to a level acceptable to programmers and designers.
- The Ada Analyzer provides a flexible approach to automated standards checking: The Ada Analyzer automates checking for potential programming errors, use of high-risk constructs, and violations of project-development guidelines. This reduces the time required to verify minimum quality standards and allows reverification by the customer. Customizable checking allows users to add new checks, disable checks that do not apply from the predefined library, or modify the precise conditions under which an error or warning is reported. A mechanism for identifying exceptions to any rule is also available.
Why Ada Analyzer is different:
- Little Tree Consulting provides not only the Ada Analyzer tools and documentation but also a combination of consultation and training to integrate a working quality-improvement process into your project's development lifecycle.
- The Ada Analyzer focuses on improving software quality rather than post-facto assessment.
- The analysis methods supported by the Ada Analyzer reflect 14 years of experience with the Ada language, with 5 years specifically focused on quality improvement.
- The Ada Analyzer is unique in the depth of information that it provides due to the rich semantic content of the Rational Ada library mechanisms.
- The Ada Analyzer is fully customizable, with numerous templates to extend and shape the analysis process to meet precise project needs.
How the Ada Analyzer works:
The Ada Analyzer traverses any set of compiled Ada units, locates constructs that match specific selection criteria, and places relevant information about those constructs in a hypertable object (see accompanying diagram). Hypertables contain not only textual information about each construct located but also traversal connections to the actual Ada source from which the information is derived. Users can scan the summary information in the table for items of particular interest and then traverse to the actual software for additional analysis. Sorting options and additional filtering options are available to organize the information into the optimal format for efficient analysis. The accompanying diagram illustrates how the Ada Analyzer facilitates interactive analysis.
The Ada Analyzer does not attempt to rate software with numbers or judge its use as good or bad. Instead, it collects condensed catalogs of program attributes so that users can better understand the content of their software and decide where and when to make improvements. It offers insight into quality-improvement options rather than value judgments. The resulting tables can be included in documentation, printed and distributed to developers or managers for reference, or used interactively to visit software constructs for inspection and repair.
Usage Scenarios
The Ada Analyzer can be used throughout the development lifecycle by a variety of project personnel, each having different analysis objectives.
- Development managers can monitor the growing content of the project software at regular intervals to judge project status, better project milestone completion, and adjust resource allocation. Testing and integration requirements can be estimated based on the size and complexity of project subsystems.
- Senior designers can validate that their program structure remains consistent as development proceeds. Design guidelines to ensure consistent use of Ada constructs and naming can be validated. Use of data typing can be monitored to ensure that types are used as designed and that redundancy does not creep in with local development efforts. Critical structures such as tasking can be located and their rendezvousing relationships analyzed. Candidates for reuse or generic interfaces can be located, which aids iterative-development methods.
- Developers can check their software against project-development guidelines and ensure that their software is compatible with the target compiler and ready for integration release. Redundant or unused constructs that result in any aggressive development effort can be identified and eliminated before software is released internally for review. Aspects of code correctness can be checked and software speed and memory utilization can be improved in the later phases of the development cycle.
- Test and integration personnel can use the Ada Analyzer to get an overview of the contents of software that they in many cases did not develop. Branching analysis and subprogram usage of local and global data can assist in the development of unit- and system-level tests. When problems are isolated to a particular Ada construct or use pattern, all instances of this pattern can be located rapidly within the code.
- Quality-assurance and configuration-management personnel can validate project standards and use output from the tools as a first pass to any code-review process. Various analysis tools can be packaged together to form a QA suite that can be executed before any customer release is made.
The accompanying table lists several analysis activities and cross-references them with the development phase in which they are most likely to occur.
Development Phase
Analysis Activity |
Detailed
Design |
Coding |
Download
& Test |
Release |
Optimization
& Tuning |
| Review of Design Status |
X |
|
| Status Accounting |
X |
X |
X |
X |
X |
| Collection of Project Information |
X |
X |
X |
X |
X |
| Standards Checking |
|
X |
|
X |
|
| Compatibility Checking |
|
X |
|
| Preparation for Code Review |
|
X |
|
X |
|
| Generation of Test Programs |
|
X |
|
| Quality Inspection |
|
X |
|
| Code Optimization |
|
X |
|
X |
Ada Analyzer Quality-Improvement Objectives
The Ada Analyzer is designed to support specific analysis objectives. For each objective listed below, a set of specific approaches to that analysis objective is defined. Each approach includes a recommended list of Ada Analyzer commands to execute along with instructions on how the output can be used to achieve specific improvements.
- Program design and structure: Commands supporting this objective illuminate how a software system is designed and structured. This includes analysis of packaging, data typing and object declaration, subprogram interfaces, and dependencies on all items. This analysis often can suggest restructuring opportunities, identify redundancy and obsolete items, and highlight inconsistencies across the software.
Examples:
- Displaying packaging, with dependencies, and compilation closure
- Comparing type declarations and usage
- Analyzing object declarations and their references
- Locating generics and their instantiations
- Code correctness: Commands supporting this objective locate areas in the code that have a higher likelihood of error, bringing the possibility for error to the attention of the developer or tester.
Examples:
- Use before set of variables
- Use of parameter defaults and when others clauses
- Exception raising, propagation, and handling
- High program complexity
- Divide-by-zero potential
- Code efficiency: Commands supporting this objective locate constructs that generally have a high impact on code size and run-time speed. This coupled with a good understanding of the cross-compilation tools can rapidly identify opportunities for improvement.
Examples:
- Inline candidate analysis
- Use of expensive typing constructs (nested and unconstrained types)
- Operator selection
- Loop nesting (also across subprogram calls)
- Reduction of compilation time: Commands supporting this objective can be used to identify the sections of the software that increase compilation time. Reducing compilation time can have a dramatic impact on the number of testing cycles that can be completed before a release can be made.
Examples:
- Dependency reduction
- Unused constructs
- Program redundancy
- Support for Testing: Commands supporting this objective can be used to aid the construction of test programs. Support includes identification of all possible execution paths, the conditions required at each branch point, and the variables that are set and along each path.
Examples:
- Displaying subprogram call trees
- finding subprogram branch points (execution-path analysis)
- Readability: Commands supporting this objective locate constructs that affect local readability, that are inconsistent, or that, because of their complexity, make programs harder to understand and maintain.
Examples:
- Use of use clauses
- Naming selection (sorted by kind of declaration)
- Consistent renaming
- Portability and reuse: Commands supporting this objective locate constructs that generally are not portable or are implementation-dependent. This extends the host compiler's semantic checking to better match the characteristics of the target compiler. Reuse opportunities also can be identified.
Examples:
- Use of predefined types
- Checking of representation specifications
- Use of duplicate unit names
- Existence of prompts
- Conformance to programming standards: Commands supporting this objective locate items that violate project-specific programming standards. New rules are easily added to these commands through templates.
Examples:
- Software Productivity Consortium's Ada Quality and Style Guidelines
- Little Tree Consulting's guidelines for software quality
- Ada 95 compatibility
products
ada analyzer technical specification | ada analyzer pdf (3.4MB)
ada type interchange generator (ATIG) | ada repair | ada analyzer/ ada repair training
little tree home | about little tree | technical articles | email