» PDF (free)
» Book
Guide to the Software Engineering Body of Knowledge (SWEBOK)







CASE Computer Assisted Software Engineering



Software development tools are the computer-based tools that are intended to assist the software life cycle processes. Tools allow repetitive, well-defined actions to be automated, reducing the cognitive load on the software engineer who is then free to concentrate on the creative aspects of the process. Tools are often designed to support particular software engineering methods, reducing any administrative load associated with applying the method manually. Like software engineering methods, they are intended to make software engineering more systematic, and they vary in scope from supporting individual tasks to encompassing the complete life cycle.

Software engineering methods impose structure on the software engineering activity with the goal of making the activity systematic and ultimately more likely to be successful. Methods usually provide a notation and vocabulary, procedures for performing identifiable tasks, and guidelines for checking both the process and the product. They vary widely in scope, from a single life cycle phase to the complete life cycle. The emphasis in this KA is on software engineering methods encompassing multiple life cycle phases, since phase-specific methods are covered by other KAs.

While there are detailed manuals on specific tools and numerous research papers on innovative tools, generic technical writings on software engineering tools are relatively scarce. One difficulty is the high rate of change in software tools in general. Specific details alter regularly, making it difficult to provide concrete, up-to-date examples.

The Software Engineering Tools and Methods KA covers the complete life cycle processes, and is therefore related to every KA in the Guide.




Figure 1 Breakdown of topics in the Software Engineering Tools and Methods KA 

1. Software Engineering Tools

The first five topics in the Software Engineering Tools subarea correspond to the first five KAs of the Guide (Software Requirements, Software Design, Software Construction, Software Testing, and Software Maintenance). The next four topics correspond to the remaining KAs (Software Configuration Management, Software Engineering Management, Software Engineering Process, and Software Quality). An additional topic is provided, Miscellaneous, addressing areas such as tool integration techniques which are potentially applicable to all classes of tools.

1.1. Software Requirements Tools [Dor97, Dor02]

Tools for dealing with software requirements have been classified into two categories: modeling and traceability tools.

  • Requirements modeling tools. These tools are used for eliciting, analyzing, specifying, and validating software requirements
  • Requirement traceability tools. [Dor02] These tools are becoming increasingly important as the complexity of software grows. Since they are also relevant in other life cycle processes, they are presented separately from the requirements modeling tools.

1.2. Software Design Tools [Dor02] uuid=efc2659c-9ab3-4e12-9d1e-9e29c1f702b7&groupId=3198959d1e-9e29c1f702b7&groupId=319895&t=1227125905398"

This topic covers tools for creating and checking software designs. There are a variety of such tools, with much of this variety being a consequence of the diversity of software design notations and methods. In spite of this variety, no compelling divisions for this topic have been found.

1.3. Software Construction Tools [Dor02, Rei96]

This topic covers software construction tools. These tools are used to produce and translate program representation (for instance, source code) which is sufficiently detailed and explicit to enable machine execution.

  • Program editors. These tools are used for the creation and modification of programs, and possibly the documents associated with them. They can be general-purpose text or document editors, or they can be specialized for a target language.

  • Compilers and code generators. Traditionally, compilers have been non-interactive translators of  source code, but there has been a trend to integrate compilers and program editors to provide integrated programming environments. This topic also covers preprocessors, linker/loaders, and code generators.

  • Interpreters. These tools provide software execution through emulation. They can support software construction activities by providing a more controllable and observable environment for program execution.

  • Debuggers. These tools are considered a separate category since they support the software construction process, but they are different from program editors and compilers.

1.4. Software Testing Tools [Dor02, Pfl01, Rei96]

  • Test generators. These tools assist in the development of test cases.

  • Test execution frameworks. These tools enable the execution of test cases in a controlled environment where the behavior of the object under test is observed.

  • Test evaluation tools. These tools support the assessment of the results of test execution, helping to determine whether or not the observed behavior conforms to the expected behavior.

  • Test management tools. These tools provide support for all aspects of the software testing process.

  • Performance analysis tools. [Rei96] These tools are used for measuring and analyzing software performance, which is a specialized form of testing where the goal is to assess performance behavior rather than functional behavior (correctness).

1.5. Software Maintenance Tools [Dor02, Pfl01]

This topic encompasses tools which are particularly important in software maintenance where existing software is being modified. Two categories are identified: comprehension tools and reengineering tools.

  • Comprehension tools. [Re196] These tools assist in the human comprehension of programs. Examples include visualization tools such as animators and program slicers.

  • Reengineering tools. In the Software Maintenance KA, reengineering is defined as the examination and alteration of the subject software to reconstitute it in a new form, and includes the subsequent implementation of the new form. Reengineering tools support that activity.

Reverse engineering tools assist the process by working backwards from an existing product to create artifacts such as specification and design descriptions, which then can be transformed to generate a new product from an old one.

1.6. Software Configuration Management Tools [Dor02, Rei96, Som05]

Tools for configuration management have been divided into three categories: tracking, version management, and release tools.

  • Defect, enhancement, issue, and problem-tracking tools. These tools are used in connection with the problem-tracking issues associated with a particular software product.

  • Version management tools. These tools are involved in the management of multiple versions of a product.

  • Release and build tools. These tools are used to manage the tasks of software release and build. The category includes installation tools which have become widely used for configuring the installation of software products.

Additional information is given in the Software Configuration Management KA, topic 1.3 Planning for SCM.

1.7. Software Engineering Management Tools [Dor02]

Software engineering management tools are subdivided into three categories: project planning and tracking, risk management, and measurement.

  • Project planning and tracking tools. These tools are used in software project effort measurement and cost estimation, as well as project scheduling.

  • Risk management tools. These tools are used in identifying, estimating, and monitoring risks.

  • Measurement tools. The measurement tools assist in performing the activities related to the software measurement program.

1.8. Software Engineering Process Tools [Dor02, Som05]

Software engineering process tools are divided into modeling tools, management tools, and software development environments.

  • Process modeling tools. [Pfl01] These tools are used to model and investigate software engineering processes.

  • Process management tools. These tools provide support for software engineering management.

  • Integrated CASE environments. [Rei96, Som05] (ECMA55-93, ECMA69-94, IEEE1209-92, IEEE1348-95, Mul96) Integrated computer-aided software engineering tools or environments covering multiple phases of the software engineering life cycle belong in this subtopic. Such tools perform multiple functions and hence potentially interact with the software life cycle process being executed.

  • Process-centered software engineering environments. [Rei96] (Gar96) These environments explicitly incorporate information on the software life cycle processes and guide and monitor the user according to the defined process.

1.9. Software Quality Tools [Dor02]

Quality tools are divided into two categories: inspection and analysis tools.

  • Review and audit tools. These tools are used to support reviews and audits.

  • Static analysis tools. [Cla96, Pfl01, Rei96] These tools are used to analyze software artifacts, such as syntactic and semantic analyzers, as well as data, control flow, and dependency analyzers. Such tools are intended for checking software artifacts for conformance or for verifying desired properties.

1.10. Miscellaneous Tool Issues [Dor02]

This topic covers issues applicable to all classes of tools. Three categories have been identified: tool integration techniques, meta-tools, and tool evaluation.

  • Tool integration techniques. [Pfl01, Rei96, Som01] (Bro94) Tool integration is important for making individual tools cooperate. This category potentially overlaps with the integrated CASE environments category where integration techniques are applied; however, it was felt that it is sufficiently distinct to merit a category of its own. Typical kinds of tool integration are platform, presentation, process, data, and control.

  • Meta-tools. Meta-tools generate other tools; compiler-compilers are the classic example.

  • Tool evaluation. [Pfl01] (IEEE1209-92, IEEE1348-95, Mos92, Val97) Because of the continuous evolution of software engineering tools, tool evaluation is an essential topic.

2. Software Engineering Methods

The Software Engineering Methods subarea is divided into three topics: heuristic methods dealing with informal approaches, formal methods dealing with mathematically based approaches, and prototyping methods dealing with software engineering approaches based on various forms of prototyping. These three topics are not disjoint; rather they represent distinct concerns. For example, an object-oriented method may incorporate formal techniques and rely on prototyping for verification and validation. Like software engineering tools, methodologies continuously evolve. Consequently, the KA description avoids as far as possible naming particular methodologies.

2.1. Heuristic methods [Was96]

This topic contains four categories: structured, data-oriented, object-oriented, and domain-specific. The domain-specific category includes specialized methods for developing systems which involve real-time, safety, or security aspects.

  • Structured methods. [Dor02, Pfl01, Pre04, Som05] The system is built from a functional viewpoint, starting with a high-level view and progressively refining this into a more detailed design.

  • Data-oriented methods. [Dor02, Pre04] Here, the starting points are the data structures that a program manipulates rather than the function it performs.

  • Object-oriented methods. [Dor02, Pfl01, Pre04, Som05] The system is viewed as a collection of objects rather than functions.

2.2. Formal Methods [Dor02, Pre04, Som05]

This subsection deals with mathematically based software engineering methods, and is subdivided according to the various aspects of formal methods.

  • Specification languages and notations. [Cla96, Pfl01, Pre01] This topic concerns the specification notation or language used. Specification languages can be classified as model-oriented, property-oriented, or behavior-oriented.

  • Refinement. [Pre04] This topic deals with how the method refines (or transforms) the specification into a form which is closer to the desired final form of an executable program.

  • Verification/proving properties. [Cla96, Pfl01, Som05] This topic covers the verification properties that are specific to the formal approach, including both theorem proving and model checking.

2.3. Prototyping Methods [Pre04, Som05, Was96]

This subsection covers methods involving software prototyping and is subdivided into prototyping styles, targets, and evaluation techniques.

  • Prototyping styles. [Dor02, Pfl01, Pre04] (Pom96) The prototyping styles topic identifies the various approaches: throwaway, evolutionary, and executable specification.

  • Prototyping target. [Dor97] (Pom96) Examples of the targets of a prototyping method may be requirements, architectural design, or the user interface.

  • Prototyping evaluation techniques. This topic covers the ways in which the results of a prototype exercise are used.


  • [Cla96] E.M. Clarke et al., “Formal Methods: State of the Art and Future Directions,” ACM Computer Surveys, vol. 28, iss. 4, 1996, pp. 626-643.

  • [Dor97] M. Christensen, M. Dorfman and R.H. Thayer, eds., Software Engineering, IEEE Computer Society Press, 1997.

  • [Dor02] M. Christensen, M. Dorfman and R.H. Thayer, eds., Software Engineering, Vol. 1 & Vol. 2, IEEE Computer Society Press, 2002.

  • [Pfl01] S.L. Pfleeger, Software Engineering: Theory and Practice, second ed., Prentice Hall, 2001.

  • [Pre04] R.S. Pressman, Software Engineering: A Practitioner's Approach, sixth ed., McGraw-Hill, 2004.

  • [Rei96] S.P. Reiss, Software Tools and Environments in The Computer Science and Engineering Handbook, CRC Press, 1996.

  • [Som05] I. Sommerville, Software Engineering, seventh ed., Addison-Wesley, 2005.

  • [Was96] A.I. Wasserman, “Toward a Discipline of Software Engineering,” IEEE Software, vol. 13, iss. 6, November 1996, pp. 23-31.


  • (Ber93) E.V. Berard, Essays on Object-Oriented Software Engineering, Prentice Hall, 1993.

  • (Bis92) W. Bischofberger and G. Pomberger, Prototyping-Oriented Software Development: Concepts and Tools, Springer-Verlag, 1992.

  • (Bro94) A.W. Brown et al., Principles of CASE Tool Integration, Oxford University Press, 1994.

  • (Car95) D.J. Carney and A.W. Brown, “On the Necessary Conditions for the Composition of Integrated Software Engineering Environments,” presented at Advances in Computers, 1995.

  • (Col94) D. Coleman et al., Object-Oriented Development: The Fusion Method, Prentice Hall, 1994.

  • (Cra95) D. Craigen, S. Gerhart, and T. Ralston, “Formal Methods Reality Check: Industrial Usage,” IEEE Transactions on Software Engineering, vol. 21, iss. 2, February 1995, pp. 90-98.

  • (Fin00) A. Finkelstein, ed., The Future of Software Engineering, ACM, 2000.

  • (Gar96) P.K. Garg and M. Jazayeri, Process-Centered Software Engineering Environments, IEEE Computer Society Press, 1996.

  • (Har00) W. Harrison, H. Ossher, and P. Tarr, “Software Engineering Tools and Environments: A Roadmap,” 2000.

  • (Jar98) S. Jarzabek and R. Huang, “The Case for User-Centered CASE Tools,” Communications of the ACM, vol. 41, iss. 8, August 1998, pp. 93-99.

  • (Kit95) B. Kitchenham, L. Pickard, and S.L. Pfleeger, “Case Studies for Method and Tool Evaluation,” IEEE Software, vol. 12, iss. 4, July 1995, pp. 52-62.

  • (Lam00) A. v. Lamsweerde, “Formal Specification: A Roadmap,” The Future of Software Engineering, A. Finkelstein, ed., ACM, 2000, pp. 149-159.

  • (Mey97) B. Meyer, Object-Oriented Software Construction, second ed., Prentice Hall, 1997.

  • (Moo98) J.W. Moore, Software Engineering Standards, A User's Roadmap, IEEE Computer Society Press, 1998.

  • (Mos92) V. Mosley, “How to Assess Tools Efficiently and Quantitatively,” IEEE Software, vol. 9, iss. 3, May 1992, pp. 29-32.

  • (Mül96) H.A. Muller, R.J. Norman, and J. Slonim, eds., “Computer Aided Software Engineering,” special issue of Automated Software Engineering, vol. 3, iss. 3/4, Kluwer, 1996.

  • (Mül00) H. Müller et al., “Reverse Engineering: A Roadmap,” The Future of Software Engineering, A. Finkelstein, ed., ACM, 2000, pp. 49-60.

  • (Pom96) G. Pomberger and G. Blaschek, Object-Orientation and Prototyping in Software Engineering: Prentice Hall, 1996.

  • (Pos96) R.M. Poston, Automating Specification-based Software Testing, IEEE Press, 1996.

  • (Ric92) C. Rich and R.C. Waters, “Knowledge Intensive Software Engineering Tools,” IEEE Transactions on Knowledge and Data Engineering, vol. 4, iss. 5, October 1992, pp. 424-430.

  • (Son92) X. Song and L.J. Osterweil, “Towards Objective, Systematic Design-Method Comparisons,” IEEE Software, vol. 9, iss. 3, May 1992, pp. 43-53.

  • (Tuc96) A.B. Tucker, The Computer Science and Engineering Handbook, CRC Press, 1996.

  • (Val97) L.A. Valaer and R.C.B. II, “Choosing a User Interface Development Tool,” IEEE Software, vol. 14, iss. 4, 1997, pp. 29-39.

  • (Vin90) W.G. Vincenti, What Engineers Know and How They Know It — Analytical Studies from Aeronautical History, John Hopkins University Press, 1990.

  • (Wie98) R. Wieringa, “A Survey of Structured and Object-Oriented Software Specification Methods and Techniques,” ACM Computing Surveys, vol. 30, iss. 4, 1998, pp. 459-527.


  • (ECMA55-93) ECMA, TR/55 Reference Model for Frameworks of Software Engineering Environments, third ed., 1993.

  • (ECMA69-94) ECMA, TR/69 Reference Model for Project Support Environments, 1994.

  • (IEEE1175.1-02) IEEE Std 1175.1-2002, IEEE Guide for CASE Tool Interconnections—Classification and Description, IEEE Press, 2002.

  • (IEEE1209-92) IEEE Std 1209-1992, Recommended Practice for the Evaluation and Selection of CASE Tools, (ISO/IEC 14102, 1995), IEEE Press, 1992.

  • (IEEE1348-95) IEEE Std 1348-1995, Recommended Practice for the Adoption of CASE Tools, (ISO/IEC 14471), IEEE Press, 1995.

  • (IEEE12207.0-96) IEEE/EIA 12207.0-1996//ISO/IEC12207:1995, Industry Implementation of Int. Std. ISO/IEC 12207:95, Standard for Information Technology—Software Life Cycle Processes, IEEE Press, 1996.