CASE (computer-aided software engineering)

During the late 1950s and 1960s, software rapidly grew more complex—especially operating system software and large business applications. With the typical program consist-ing of many components being developed by different pro-grammers, it became difficult both to see the “big picture” and to maintain consistent procedures for transferring data from one program module to another. As computer scien-tists worked to develop sounder principles (see structured programming) it also occurred to them that the power of the computer to automate procedures could be used to cre-ate tools for facilitating program design and managing the resulting complexity. CASE, or computer-aided software engineering, is a catchall phrase that covers a variety of such tools involved with all phases of development.

Design Tools

The earliest design tool was the flowchart, often drawn with the aid of a template that could be used to trace the symbols on paper (see flowchart). With its symbols for the flow of execution through branching and looping, the flowchart provides a good tool for visualizing how a pro-gram is intended to work. However large and complex pro-grams often result in a sea of flowcharts that are hard to relate to one another and to the program as a whole. Start-ing in the 1960s, the creation of programs for manipulating flow symbols made it easier both to design flowcharts and to visualize them in varying levels of detail.

Another early tool for program design is pseudocode, a language that is at a higher level of abstraction than the tar-get programming language, but that can be refined by add-ing details until the actual program source code has been specified (see pseudocode). This is analogous to a writer outlining the main topics of an essay and then refining them into subtopics and supporting details. Attempts were made to create a well-defined pseudocode that could be automatically parsed and transformed into compilable lan-guage statements, but they met with only limited success.

During the 1980s and 1990s, the graphics capabilities of desktop computers made it attractive to use a visual rather than linguistic approach to program design. Symbols (sometimes called “widgets”) represent program functions such as reading data from a file or creating various kinds of charts. A program can be designed by connecting the widgets with “pipes” representing data flow and by setting various characteristics or properties.

CASE principles can also be seen in mainstream pro-gramming environments such as Microsoft’s Visual Basic and Visual C++, Borland’s Delphi and Turbo C++, and oth-ers (see also programming environment). The design approach begins with setting up forms and placing objects (controls) that represent both user interface items (such as menus, lists, and text boxes) and internal processing (such as databases and Web browsers). However these environ-ments do not in themselves provide the ability of full CASE tools to manage complex projects with many components.

Analysis Tools

Once a program has been designed and implementation is under way, CASE tools can help the programmers maintain consistency across their various modules. One such tool (now rather venerable) is the data dictionary, which is a database whose records contain information about the defi-nition of data items and a list of program components that use each item (see data dictionary). When the definition of a data item is changed, the data dictionary can provide a list of affected components. Database technology is also applied to software design in the creation of a database of objects within a particular program, which can be used to provide more extensive information during debugging.

Integration and Trends

A typical CASE environment integrates a variety of tools to facilitate the flow of software development. This pro-cess may begin with design using visual flowcharting, “rapid prototyping,” or other design tools. Once the over-all design is settled, the developer proceeds to the detailed specification of objects used by the program and perhaps creates a data dictionary or other databases with informa-tion about program objects. During the coding process, source control or versioning facilities help log and keep track of the changes to code and the succession of new versions (“builds”). While testing the program, an inte-grated debugger (see bugs and debugging) can use infor-mation from the program components database to help pinpoint errors. As the code is finished, other tools can automatically generate documentation and other support-ing materials (see technical writing and documenta-tion of program code).

Just as some early proponents of the English-like COBOL language proclaimed that professional program-mers would no longer be needed for generating busi-ness applications, CASE tools have often been hyped as a panacea for all the ills of the software development cycle. Rather than causing the demise of the programmer, how-ever, CASE tools have played an important role in keeping software development viable.

In recent years, tools for managing or debugging code have been supplemented with tools to aid the design pro-cess itself (see modeling languages). There are also tools to aid in refactoring, or the process of reorganizing and clarifying code to make it easier to maintain.

In a broader sense, CASE can also include tools for man-aging the programming team and its efforts. Even social networking tools (see blogs and blogging and wikis and Wikipedia) can play a part in keeping programmers in touch with issues and concerns relating to many different aspects of a project.