The Evolution of Client/Server CASE

How the New Case Tools Promise to Simplify Data Managment and Automate Development.

Years ago, pundits proclaimed the death of the CASE (Computer-Aided Software Engineering) market. Yet today, it's hard to conceive of a development project that does not use some kind of modeling tool to design, generate, and manage databases. Today's CASE tools are proving to be indispensable in managing complex data, application, and object designs. These tools are also assuming a greater role in the development and construction process. This article reviews CASE and modeling tools for client/server development. It also examines the emerging stratification of the CASE/modeling category into different classes of tools for managing different kinds of models: physical data models, logical data models, and object and process models.

How We Got Here

CASE tools began their forays into client/server environments by generating, and later reverse-engineering, relational DBMS schema. At first, the tools translated entities and attributes into SQL CREATE TABLE statements and other Data Definition Language (DDL) statements stored in disk files. DBAs could then run the scripts on the DBMS server. As the tools matured, they employed native DBMS drivers to connect to a DBMS so they could run the DDL scripts and create DBMS tables and indexes. (The last two years have seen greater reliance on ODBC instead of native drivers.) As an encore following table creation, CASE tools such as ERwin from Logic Works began generating triggers and stored procedures, often from customizable templates. Along the way, several tools were designed to reverse-engineer existing database schemas into their CASE repositories, and some even lay out entity-relationship (ER) diagrams automatically after they catalog the relationships among tables.

But client/server systems do not live by databases alone. About two years ago, integrating CASE tools with application development tools became a hotbed of activity. Sybase's PowerBuilder uses extended attributes to capture interface properties of controls associated with table columns. Because PowerBuilder stores these attributes in relational tables, several CASE vendors enhanced their ER models to capture extended attributes. They could then export those extended attributes to PowerBuilder's extended attribute tables (many also import extended attributes into a data model). This feature lets you specify interface properties during the modeling process. For example, you could specify a radio button control for a column. Several CASE vendors jumped on the PowerBuilder bandwagon. Gupta's SQLWindows also attracted support from several CASE vendors.

Extended attributes are an important aspect of PowerBuilder development. CASE tools are only now beginning to generate PowerBuilder applications. One of the earliest examples is Sybase's own S-Designor, a CASE tool that Sybase acquired from SDP Technologies in 1995. Version 4.2.1 of S-Designor, which shipped in November 1995, generates DataWindows, windows, menus, and application objects. More important, developers are able to specify ancestors from which generated objects should inherit, including ancestors in third-party frameworks. S-Designor ships with templates that link Sybase's PowerBuilder Application Library to S-Designor. Sybase promises that future versions of S-Designor will support Visual Basic and other application development tools.

With their heads out of the PowerBuilder sands, CASE vendors are also eyeing other client/server development tools such as Visual Basic (especially the new Visual Basic 4.0 Enterprise Edition -- see the cover story, "Visual Basic 4.0: Ready for the Enterprise?"), Borland's Delphi, and Forté Software's Forté. Both Logic Works and LBMS support Visual Basic 3.0, and both are now upgrading their tools to support Visual Basic 4.0. Other vendors that have already tied their tools to VB (or have immediate plans to do so) include Popkin Systems & Software, Sterling Software (which recently acquired KnowledgeWare and its ADW CASE toolset, which is now known as Key:Enterprise), Sybase, Select Software Tools, and Rational Software (the latter two vendors sell object-oriented CASE tools). I expect VB to attract the same broad support now enjoyed by PowerBuilder. Meanwhile, Borland developed a link between Delphi and LBMS's Systems Engineer, and Popkin Systems & Software has announced that it will support Delphi in an upcoming version of System Architect. Select Software Tools (Select Enterprise), Protosoft (Paradigm Plus), and Sterling have (or will soon) integrated their CASE tools with Forté.

Despite wider and deeper integration between CASE tools and client/server application development tools, current levels of integration are often little more than thin, snapshot-in-time bridges built between the two islands of design and construction. In theory, a design model is a high-level abstract view of a working implementation, yet today's tools rarely treat the model and the application or database as two views of the same thing. Today they remain two separate things that can exchange and translate relatively small parts of their world views. Typically, you create a design model and then generate or build the application in a one-way process.

Another force shaping today's CASE for client/server market is the greater participation by object-oriented (OO) CASE vendors. OO CASE tools embrace object analysis and design methods and notations, as opposed to ER and structured analysis and design diagrams (although some object methods and notations trace their lineage to earlier data and process models). OO CASE tools initially generated DDL for object-oriented DBMSs, but some also began mapping classes to RDBMS tables, reflecting the fact that many OO applications interact with an RDBMS, not an ODBMS. On the application side, the usual targets include C++ and Smalltalk, because these languages carry the flag in most OO camps. However, OO CASE vendors such as Rational and Protosoft have started to support PowerBuilder 4.x and Visual Basic 4.0, because each product steers developers toward greater reliance on classes as an integral part of its application structure. OO CASE vendors finally have a place to hang their hats in the 4GL world.

Several vendors have marketed very low-cost ($500 or less) versions of their CASE tools. These appeal to solo developers, and most support desktop products such as Microsoft Access or Xbase. Unlike their big brothers, who typically support team development, the desktop versions are usually single-user, and some features may also be limited. For example, Sybase's Star-Designor is a subset of S-Designor, but it supports only physical data models, not conceptual models. Logic Works also markets desktop versions of its ERwin product.

On the Horizon

The modeling of decision-support and data warehouse applications is another frontier that few CASE vendors have explored, but I assume this market will open up within a year or two. Ralph Kimball, a DBMS contributing editor and data warehouse consultant, has discussed the inappropriateness of ER models for decision-support applications (see "Is ER Modeling Hazardous to DSS?" Ralph Kimball, DBMS , October 1995). Logic Works is investigating how to support (in a future version of ERwin) the modeling of star schemas, which are often used to represent data warehouse designs. Asymetrix is also weaving together models and queries with its new InfoAssistant product. InfoAssistant is an end-user query tool that can create queries using information from an Asymetrix Info Modeler model.

On the application side, component thinking is slowly replacing systems thinking, especially as OLE becomes more common. CASE vendors must extend their tools to model and generate independent components in addition to integrated systems and applications. Again, I suspect that CASE tools supporting class modeling will have a head start in this arena. One example of this approach is Select Software Tools' Select Enterprise for Visual Basic. This object modeling CASE tool generates in-process and out-of-process OLE servers as part of a Visual Basic 4.0 application.

A housekeeping issue to watch is the future of open repositories. Today, several kinds of tools have their own storage mechanisms, although some tools interact with repositories used by other tools. Maintaining multiple representations of the same system is asking for trouble, so I would not be surprised to see more developers turn to repositories shared by multiple tools. LBMS recently introduced its Object Manager product, which serves as a repository for application objects created by tools such as PowerBuilder and Visual Basic. Object Manager also stores test scripts for SQA's TeamTest. I also expect vendors that sell DBMS servers, application development tools, and CASE tools to encourage developers to use RDBMSs as shared object and model repositories.

Categorizing CASE Tools

• data modeling only
• data and process modeling
• object modeling
• methodology-based tools
• other

Data Modeling Tools

Most data modeling CASE tools employ various flavors of ER diagrams. An exception is Asymetrix's InfoModeler (see "Black Belt Design," DBMS Interview, September 1995), which uses Object Role Modeling. InfoModeler graphically represents a design as objects that play roles, and it can also express a design as a collection of English-like fact statements. Many developers have found this feature useful for verifying designs with non-technical end users.

Although several CASE tools generate schemas for RDBMSs, Cast Software's CAST Workbench is one of the few to integrate data modeling with other database administration tools. CW-Designer, an ER modeling tool, is one of six applications in CAST Workbench. DBAs use the other modules to reverse-engineer, write, test, and manage scripts, and to migrate data into Sybase SQL Server and Microsoft SQL Server databases. Because many client/server projects are still performed by small teams, the same developers often handle a broad array of tasks ranging from database administration to systems design.

Process Modeling Tools

Blending data, process, and object diagrams with a common repository lets developers design systems from different viewpoints using various levels of abstraction. For example, LBMS integrates several products around its repository. Systems Engineer is a modeling tool that also generates database schemas (from the SE/ServerBuilder module) and application components. It also models GUI applications using diagrams that illustrate navigation paths among windows or forms. Process Engineer provides online methodology guides as well as project management features. Also, Object Manager extends LBMS's repository technology to application development tools, testing tools, and other development products, so they can benefit from repository-based documentation, versioning, check-in, and check-out controls.

Recently, CASE tools have shifted the focus of their process modeling techniques along two lines: object-orientation and business process reengineering. In addition to Popkin's System Architect, Intersolv's Excellerator II and Visible Systems' Visible Analyst Workbench (VAW) supplement process diagrams based on structured techniques with new diagram types for modeling classes and objects.

Object Modeling Tools

As today's application development tools become increasingly object-oriented, object modeling CASE tools become more relevant to application developers who do not use C++ or Smalltalk, the traditional focus for object CASE tools. Some popular object CASE tools include Rational Rose by Rational Software, Paradigm Plus by Protosoft, and Select Enterprise by Select Software Tools, which is based on Select OMT Professional. All three now generate application objects for development tools such as PowerBuilder, Gupta SQLWindows, Forté, and Visual Basic.

Methods and Manpower

Beyond online methodology aids, several consulting firms, such as Arthur Andersen and Ernst & Young, provide on-site counselors with the CASE tools they sell. These mentors advise clients not only on the mechanics of making the CASE tool work, but on the fundamental procedures and techniques for developing large systems that involve teams or leagues of developers. Many of the large shops using these services began using CASE tools on mainframe projects, and now utilize them on client/server systems as well. Among the larger shops, Texas Instruments' IEF CASE tool is a popular choice for enterprise-wide development. IEF, supplemented by Texas Instruments' Composer object development environment and Arranger object assembly environment, provides a full life cycle development solution with an implicit methodology.

Building Bridges

Developers build a LEAD model using System Architect or ERwin. The model includes ER diagrams, and if System Architect is used, developers can also create entity state transition diagrams. LEAD's linchpin is the use of two-character prefixes for column names in ER diagrams. These prefixes signify a domain such as date, user ID, state, phone, and so on. LEAD provides almost 20 built-in domain prefixes, and developers can add new ones.

The LEAD Toolkit Console program reads a text file exported by the CASE tool. LEAD generates an application using the LEAD class library, a set of SQLWindows QuickObjects. Each entity in the model becomes a table in the database and a form in the application. (LEAD can also generate one-to-many forms.) Each field on a form is a SQLWindows QuickObject that is based on a LEAD domain.

Client Server Designs is currently working on LEAD version 2, which will generate complete applications for Visual Basic, PowerBuilder, and C++. It will also create OLE controls, so any development environment that supports OLE controls will be able to benefit from LEAD's ability to translate model specifications into application components. Client Server Designs plans to ship version 2 in late 1996.

CenterView Software's (South San Francisco, Calif., 415-873-1295) Choreo is another example of a third-party tool that builds applications from database schemas. Choreo is not a CASE tool, but it performs functions that some CASE tools are now adopting. Choreo reads a DBMS catalog and imports information about tables, columns, primary and foreign keys, indexes, and relationships in a database. If the database is well-designed, Choreo can infer most of the relationships among tables, and it will prompt the developer when it cannot. Choreo stores this information in a "model" file, which is more like a database of its own because no graphical diagram is involved.

A developer runs the Choreo DataLink Manager along with Visual Basic, and drags and drops fields from the Choreo model onto controls on a Visual Basic form. Choreo includes its own grid control, which responds to the drag and drop of a field from the Choreo model. Developers can use other third-party grid controls, but they must write calls to the Choreo API. Once Choreo learns the linkage between a field and a control, it manages all interaction between the Visual Basic application and the database. This approach enables Choreo to coordinate data navigation across one or many windows without additional programming. Choreo includes its native database drivers for Oracle, Sybase and Microsoft SQL Server, and Gupta's SQLBase. An earlier version of Choreo for Gupta's SQLWindows is now marketed by Gupta.

Logic Works is developing a version of ERwin for Visual Basic that will create the Choreo model file from an ERwin model. ERwin will also generate Visual Basic 4.0 forms that use the Choreo controls and database engine.

Designing Complexity

Client/server systems are increasingly complex. Even if you use rapid prototyping to gather user feedback regarding interface design and application function, any non-trivial system needs a well thought-out design. CASE tools enable developers to model database applications and integrate with both back-end DBMS servers and the front-end application development tools. If you're developing a sophisticated client/server system without using a CASE tool, you may be doomed for extinction. (For an extensive list of CASE tools, see Table 1.)

TABLE 1. Product Chart