Software Engineering: A Methodical Approach (2014)

PART G. Appendices

Appendix 7. Tools for Object-Oriented Methodologies

The previous six chapters discussed the fundamentals of OOM with respect to software design as well as information infrastructure design. This chapter discusses OOM tools. The chapter proceeds under the followings captions:

· Introduction

· Categories of CASE Tools

· Universal Database Management Systems

· Benefits of OO-CASE Tools and UDBMS Suites

· Object-Oriented Programming Languages

· Modeling and Code Generation

· Standards for OOM

· Summary and Concluding Remarks

A7.1 Introduction

Object technology and CASE technology fit naturally together; they are like “a match made in heaven”. The reason for this is twofold:

· Many intricacies of the OO approach (for example information hiding) are implemented by CASE tools at a level beyond user intervention and in a manner that is transparent to the user (developer as well as end users).

· CASE enhances the OO approach and makes it more attractive. In fact, without CASE, the OO approach would have probably remained an alternative widely discussed in academic circles, but seldom used in practice. The techniques would simply be too arduous and time consuming to be worth the effort.

Early emergence of object technology relied on, and heavily emphasized OO programming. The emphasis is now being moved (and rightly so) to OOAD and OO development using integrated CASE (I-CASE) tools involving automatic code generation. Ideally, we require OO-ICASE tools with repositories for storing re-usable classes. These OO-ICASE tools need not be tied to OOPLs (though such linkages are encouraged), but should facilitate all or most aspects of OOSE, with automatic code generation.

Non-OO-CASE tools and 4GLs are many and varied. They remain useful aids in software development. Of course, fourth-generation languages (4GLs) based on non-procedural programming languages are preferred to those that use procedural languages.

A7.2 Categories of CASE Tools

As you are aware, a CASE tool is a sophisticated software product that assists in the development of other software products in a significant way. The CASE tool provides the following functionalities:

· Graphical user interface (GUI) so the user can model the system in a user-friendly environment

· Automatic code generation in at least one programming language (preferably an OOPL)

· Executable diagrams and integration of the GUI with the actual code generator

· Seamless integration/connectivity to various databases

· Facility to produce systems in deployment mode (consisting of executables of system resources without the bulk of the CASE tool itself)

· A repository for defining and storing generic and/or reusable system components

CASE tools may be categorized from two broad perspectives:

· Supporting Technology

· Scope

In terms of supporting technology, there are three classifications:

· Non-OO-CASE Tool

· Pure-OO-CASE Tool

· Hybrid CASE Tool

In respect to scope, there are also three classifications:

· Fragmented CASE — supporting only a portion of the system life cycle

· Integrated CASE (I-CASE) — supporting all aspects of the SDLC

· Information Engineering CASE (IE-CASE) — supporting the whole process of information engineering for the entire enterprise

Figure A7-1 illustrates the categorizations. In examining software development tools for subsequent development, products will fit (some vaguely) in various cells of the matrix. Prudent software evaluation will aid the selection process.

Figure A7-1. Categories of CASE Tools

Recall that in Figure 2-5 of chapter 2, several CASE tools were listed. Figure A7-2 pulls some of these products and places them in the categories they best fit in (bear in mind that there is hardly any product which fits perfectly into a specific cell of the categories grid above).

Figure A7-2. Examples of Popular Products

A7.3 Universal Database Management Systems

In an effort to keep abreast with the advances in OOM, we have seen an increase in the upgrade of traditionally relational database management systems (RDBMS) into object-oriented database management systems (OO-DBMS) suites. Other terms used to describe these products areuniversal database management system (UDBMS) suites, or simply object databases. The rationale for these hybrid products are due to two important perspectives:

· Relational databases dominate the world of databases (and will continue to do so for the foreseeable future). Apart from the fact that the relational database model is very rigorous and has been proven over the years, there are numerous circumstances where a relational database represents the most viable solution.

· The superiority of the OO model (particularly from a user interface perspective) is generally accepted by the industry.

UDBMS suites constitute a reasonable compromise:

· Companies that have dominated the market place with RDBMS can maintain their market share.

· Legacy systems can be integrated into the “world of objects” by simply “wearing” an object-oriented wrapper (user interface).

· Object-oriented technology, which clearly will dominate future software, will not make obsolete, the huge investments that have been made in relational systems. The best we can expect is a peaceful coexistence of both technologies, with each complementing the other.

· Many so-called OO software development tools are only object-oriented to the point of the user interface development. The typical scenario therefore, is to have an OO user interface superimposed on a relational database. Additionally, most of the front-end CASE tools and RAD (rapid application development) tools available facilitate this approach. Examples include (but are not confined to) Java NetBeans, Delphi, C++ Builder, Visual Studio, Team Developer, etc.

The universal database supports both the relational database as well as the OO database. The designer can therefore make critical decisions as to which approach is preferred, given the scenario. Several of the leading software engineering companies have in recent times, introduced such products. Examples include DB2, Oracle, and Informix.

A7.4 Benefits of OO-CASE Tools and UDBMS Suites

Object technology relies heavily and (and typically presumes) the presence on OO-CASE tools to support the principles and techniques. The benefits of object technology (as discussed in appendix 1) are therefore applicable here. Nonetheless, Figure A7-3 underscores the significant benefits of UDBMS suites and Figure A7-4 underscores the benefits of OO-CASE tools.

Figure A7-3. Benefits of Universal Databases

Figure A7-4. Significant Benefits of OO-CASE Tools

A7.5 Object Oriented Programming Languages

An object-oriented programming language (OOPL) is a high level language that supports object-oriented programming. The language must support the fundamental principles of OO programming such as classes, inheritance, polymorphism, encapsulation, etc. (as discussed in appendix 2) in order to qualify as an OOPL. The important features to consider when choosing an OOPL are summarized in Figure A7-5.

Figure A7-5. Desirable Features of OOPLs

There are two categories of OOPLs: pure OOPLs and hybrid languages. Pure OOPLs are languages which from the outset, were designed to be object oriented; they do not support procedural programming at all. Examples of pure OOPLs include SmallTalk, Actor, Eiffel, Java, and Scalable Application Language (SAL).

Hybrid OOPLs are languages that have resulted from the upgrade of traditionally procedural languages. They support both procedural and object oriented programming. Examples include C++ (from C), Objective C (from C), Visual Basic (from Basic), Object Pascal (from Pascal), Object COBOL (from COBOL), and CLOS (from LISP).

A7.6 Modeling and Code Generation

With the use of OO-CASE tools, the software development life cycle (SDLC) is reduced from several disjoint phases to two integrated, interwoven stages — modeling and code generation — as illustrated in Figure A7-6.

Figure A7-6. OO Modeling and Code Generation

OO-CASE tools need not use OOPLs. They can generate code in portable HLLs, e.g. C, COBOL, Pascal, etc. One major problem with this, however is that most traditional HLL compilers do not support dynamic (late) binding. In order for the OO-CASE tool to be successful, the underlying programming language must support late binding. For this reason, OO-CASE tools usually generate code in hybrid languages (such as C++ and Object Pascal) or pure OO languages (such as Java and SAL).

In the future, the industry should be able to produce more OO-CASE tools that generate low or intermediate level code that is machine and/or compiler independent. In this regard, the Java revolution is promising.

A guiding principle of I-CASE is that debugging must not be at the code level, but at the higher modeling level that drives the code generation. Some products meet this criterion better than others. Most products usually provide the designer with the flexibility of deciding whether he/she wants to modify generated code or change the design.

A7.6.1 Instant CASE

Very sophisticated OO-CASE tools not only generate code as soon as classes are defined, and rules specified, but also create instantiation, so the software engineer can see and test the effect of his/her work with actual data. These are referred to as instant CASE tools. The effect is similar to that of a spreadsheet, except that it is much more sophisticated.

Instant CASE is still an ambition (and guiding principle) for many OO-CASE tool developers. However, a number of products have begun to provide this feature. Examples include LiveModel, Oracle, and Delphi. It is anticipated that this trend will continue.

A7.6.2 Repository

The OO-CASE tools should provide for the maintenance of a repository, as an integral part of its environment. Typically, the repository stores and catalogs reusable resources such as generic subsystems, classes, interfaces, methods, and data models. It also stores important information about different systems of the enterprise. In short, any item that is reusable across multiple subsystems or systems is a candidate for the repository.

The repository stores object types such as (but not confined to):

· Components

· Interfaces

· Classes

· Event types

· Rules

· Conditions

· Operations

· Data models

· Screen designs

· Report designs

A well-designed OO-CASE tool with repository is usually a useful facility towards information engineering. For this and other reasons, CASE tools with repositories have become the norm in the software engineering industry.

Software systems should be designed with the use of a repository in mind. There is no replacement for good design! Moreover, as emphasized throughout this course, good design is not coincidental; rather, it is a consequence of deliberate effort.

A7.7 Standards for OOM

With the proliferation of tools that support OOM, it has become necessary to standardize these tools so that their usefulness to the consuming public can be maximized. Three prominent standards have emerged – CORBA, COM and .NET. A brief summary of each follows.

A7.7.1 CORBA

Since the start of the 1990s, the Object Management Group (OMG) has been attempting to establish standards for OO software. Since 1996, the OMG’s Common Object Request Broker Architecture (CORBA) has advanced as the de facto industry standard.

The CORBA standards govern how objects communicate in a distributed system. They therefore affect distributed database systems and communication systems. CORBA is well documented and is available via the Worldwide Web (see recommended readings).

A7.7.2 COM

Another important standard is the Component Object Model (COM). Developed by Microsoft, there are two main enhancements of COM: Distributed COM (DCOM) and COM+. Then there are other COM related standards such as Microsoft Transaction Server (MTS) and ActiveX. These standards also support inter-object communication in distributed environments.

It is recommended that contemporary OO-CASE tools and DBMS suites support the CORBA and/or COM standards if they are to remain marketable.

A7.7.3 The .NET Boom

A third wave of technology craze is the .NET craze. This is a set of standards that facilitate easy communication among Microsoft products. These standards were recently developed by Microsoft, and have been off to a good start towards industry acceptance. The .NET products also facilitate easy Web accessibility. Further information can be obtained from the Microsoft .NET Web site (see recommended readings).

A7.8 Summary and Concluding Remarks

Let us summarize what we have covered in this chapter:

· Object technology and CASE technology fit naturally together.

· There are different categories of CASE tools — from object-oriented to procedural; they may be front-end, back-end, or integrated; they may or may not support information engineering.

· A UDBMS supports relational as well as object databases.

· OO-CASE tools and UDBMS suites provide a number of significant benefits to the software engineering industry.

· OOPLs come in two categories, namely pure OOPL and hybrid OOPL.

· Ideally, the OO-CASE tool used should support an OOPL. Additionally, the OO-CASE tool used should preferably be an instant CASE tool with repository support.

· Contemporary OO-CASE tools and DBMS suites must support the CORBA and/or COM standards if they are to remain marketable. The .NET standards are also emerging with increasing industry acceptance.

Care should be taken in choosing the OO tools used for your information engineering or software engineering project, as this could have significant effects on the outcome. By using the appropriate OO-CASE tools, you can reduce your project duration time by 20% – 60% of the time it would have taken without such tools.

A7.9 References and/or Recommended Readings

[Martin, 1993] Martin, James and James Odell. Principles of Object Oriented Analysis and Design. Eaglewood Cliffs, NJ: Pretence Hall, 1993. See chapters 17-19.

[Rumbaugh, 1991] Rumbaugh, James, et. al. Object Oriented Modeling And Design. Eaglewood Cliffs, NJ: Pretence Hall, 1991. See chapters 15-17.

[CORBA, 1997-2009] CORBA. http://www.corba.org (accessed June 2008).

[OMG, 1997-2008] Object Management Group. http://www.omg.org (accessed June 2008).

[Microsoft, 2008a] Microsoft. Microsoft.NET. http://www.microsoft.com/NET (accessed June 2008).

[Microsoft, 2008b] Microsoft. DCOM Architecture. http://msdn.microsoft.com/en-us/library/ms809311.aspx (accessed June 2008).

[Washington University, 2000-2007] Computer Science Department, Washington University. Overview of CORBA. http://www.cs.wustl.edu/~schmidt/corba-overview.html (accessed June 2008).