Overcoming the Object Onslaught

Object and Component Repositories Can Help You Keep Track in the Chaos

April 1997

Sooner or later it happens -- a software project loses track of the programming objects involved and the development effort goes to hell. Although reusable objects and components are a key to better and faster software development, the gains don't come without complications. As a developer, you're often forced to ask: What are all these objects? Where did they come from? Where are they now? What do they do? You have to know that changing something in one object isn't causing chaos, for example, somewhere else in a class hierarchy.

This is not a new problem; tracking project elements became troublesome as soon as people couldn't keep a software project in their head -- say, around the time when computers had tubes instead of transistors. But object-oriented programming (especially Internet and Intranet development) creates a deliberate software fragmentation, the likes of which we've never seen before. It's fair to say that a key challenge now facing software designers and developers is the integration of a vast number of application components into modular and maintainable systems.

Fortunately, if the problem can be defined, solutions are often forthcoming. In this case they come from a branch of database management technology called an object repository. There are other names -- object manager and component repository -- that amount to the same thing: a database system that stores and manages program objects and components. Instead of going to a File: Open dialog and searching high and low through directories for the appropriate file, you locate and access your files (and other objects) within the object repository. This will be easier because the repository also manages information about the objects -- properties, relationships, rules -- in other words, the metadata.

The word "metadata," data about data, has an academic aura; but it's almost guaranteed to become an important buzzword around object-oriented programming and Web software development. In the setting of data warehouse projects, metadata usually describes data items (tables, fields, and dimensions) and application objects such as queries or reports. But in the context of the Net, metadata is the glue information that holds together all of the elements of a project and defines the limits of what can be done with the objects -- or at least it can if properly orchestrated. That's one of the tasks of an object repository and its supporting cast of software.

What Is an Object Repository?

• To physically store objects and components or store the reference to their actual location. The object repository may store the code for objects or keep track of the files that contain the code. The same applies to all types of objects, including images, HTML files, scripts, and documentation. An integral -- and most crucial -- part of this management is the unique naming (identification) of objects.
• To store the metadata about objects and the project as a whole. This may include design documents, CASE information, database schemas, table definitions, object hierarchies and other object relationships, and business rules -- to name a few.
• To track and update objects and metadata. Simply storing information isn't enough. An object repository must provide a data management engine capable of maintaining and delivering to developers both the original goods (objects) and meaningful collections of metadata.
• To integrate the various tools -- languages, visual designers, report generators, and so on -- so that at some level they can interoperate on the objects. For team software development, the object repository may contain or be supplemented by a version-control system.

The repository is a database that becomes useful when accessed by some kind of database engine, more often than not an object database management system. A certain amount of information -- especially metadata -- is stored in traditional alphanumeric formats; however, much of the data -- particularly objects -- is stored as files or file references. It's easy to forget that despite the object-oriented terminology, when we say objects, we're usually talking about something that is, or normally would be, a file. Especially in a repository, much of what it does is store, locate, identify, translate, run, and present file content (OCX, JAVA, HTML, JPEG, WAV, GIF, and so on) as objects.

Like any database system, the database engine isn't enough. There needs to be a user interface, particularly for metadata, that helps the designers, managers, and programmers make use of it. Generically this interface includes:

• A type of object browser to access repository objects and associated data
• A program that reconciles object model differences between the object repository and the development tools being used (principally, this means file-format mapping)
• An administrative interface that generates reports and profiles about the objects and projects
• A user and security management module, often closely tied to a version-control or configuration management system

What's Out There

• Proprietary -- This type of repository functions as part of a larger application development system and can work best, if not exclusively, with elements of that system.
• Dependent -- In this category are object repositories designed to work with another specific product (or small group of products). These are not typically part of a large system and may come from third-party companies.
• Independent -- A relatively new category, these object repositories support software that will work with a variety of products.

The Proprietary Approach

Borland International Inc., Delphi 2.0, Object Manager
The Delphi Object Repository stores and manages application objects: Forms, Data Modules, Experts, and DLLs. The objects can be organized into custom groups, usually based on functionality, for quicker identification and reuse. All of the Delphi tools, such as the Forms Designer, access the repository (though they're not required to so). As repositories go, this one is relatively bare bones, and it doesn't cover many areas of project metadata such as design, documentation, or distribution. This is typical for most repositories that are part of well-known client/server development systems such as Powersoft's PowerBuilder, Microrim Inc.'s R:BASE, and Centura Software Corp.'s Centura Team Developer. Delphi supports only Windows platforms.

LBMS Inc., SE/Repository
As part of an extensive LBMS software development and business-processing reengineering (BPR) system, the Systems Engineer (SE)/Repository is a classic "under-one-roof" approach. It provides comprehensive object access, storage, graphical representation, reporting, and configuration management capabilities for a software development team. The emphasis is on the collaborative (multiuser) environment and on providing a high level of project data security. Most of the tools involved are proprietary to LBMS, but the companion module named SE/Object Manager lets developers manage PowerBuilder and Visual Basic components in the SE/Repository. SE/Repository supports all Windows platforms and Unix.

Being Dependent

Sybase Inc., ObjectConnect, ActiveX Dynamic Object Repository
A good example of an object repository with a very targeted use is Sybase ObjectConnect, which delivers relational data as objects directly to ActiveX-enabled application development environments such as Optima++, PowerBuilder, Visual C++, Visual Basic, and Delphi. ObjectConnect makes databases appear as object-oriented ActiveX components and stores the components in the Dynamic Object Repository. Once defined in the repository, objects can be accessed and manipulated from applications created in any of the ActiveX-enabled IDEs. In addition to the Dynamic Object Repository, ObjectConnect includes an Object Builder to create the database objects and an Object Runtime that provides access to the repository objects (and data) within a program.

CSM Inc., Access Monitor
Compared with other products in this article, Access Monitor barely makes it into the definition of object repository, yet it is representative of third-party repository support. In this case, Access Monitor uses an object repository to provide version control for Microsoft Access developers. Access objects such as forms, reports, and tables are registered in the repository; the repository tracks their use by multiple developers in multiple projects. Obviously this is a limited role, but it illustrates that even applications created by desktop systems can benefit from object repository technology.

Ontos Inc., OIS Repository (part of Ontos Object Integration Server)
The Ontos repository is used as the link between relational database information and object-oriented programming. The repository stores relational schema representations, object models, and the object/relational mappings. In this way, mappings are reusable by different applications, and changes to the objects and databases can be easily accommodated. At runtime, applications derive mapping information from the repository and directly access information in the databases. This approach has some similarities to Sybase's ObjectConnect. There is a version of OIS for Sybase, and releases are planned for Oracle and DB2.

Going Independent

Microsoft Corp., Object Repository
The Microsoft Object Repository, designed in collaboration with Texas Instruments Inc., is intended to store Component Object Model (COM) metadata about components and application models and make it available to a wide variety of tools. Though it is dependent on Microsoft SQL Server as the database engine, the repository will initially be supported by tools from Microsoft, beginning with Visual Basic 5.0, and eventually under the name Visual Data Tools. Microsoft will be joined by as many as 40 other companies, including Texas Instruments (as a major partner), Rational Software Corp., and Select Software Tools Inc. in support of the repository. The specification standardizes the definition of metadata so that many kinds of tools can share a common object management system and version control. This is a relatively limited vision of a repository; but given the breadth of Microsoft's product line (nearly all of which will eventually participate in the repository) and the company's ability to attract support from hundreds of development tool partner companies, the impact on repository design and commercial acceptance will be important.

Unisys Corp., Universal Repository (UREP)
Despite the size and completeness of this very large and comprehensive repository system, the Unisys Universal Repository is not a strictly proprietary system. It uses the Versant ODBMS as its database engine, and it's designed to incorporate a wide variety of approaches and tools. It includes the Modeler's Workbench, which provides the interface to the repository's modeling capabilities. UREP has its own information model, which makes it possible to share objects and metadata through an object-naming and tool-exchange system. Some of the tools supported are LBMS System Engineer, Texas Instruments' Information Engineering Facility (IEF), PowerBuilder, and Intersolv Inc.'s Excelerator. UREP carefully spells out four levels of tool integration in recognition of the fact that not all tools have objects that lend themselves to matching other data models. UREP also has comprehensive metadata services, including:

• Definitions for object-modeling concepts such as objects, classes, attributes, relationships, and integrity rules
• The ability to define new datatypes and extend the information model
• Management of reusability through inheritance, composition (containership), reference, and n-ary relationships

ClassicSys, InSight Object Repository
The InSight approach to a repository has an important emphasis -- software configuration management (SCM) -- which takes version control to the next level by also including data about deployment and configuration. InSight uses a Visual Links technology that graphically presents the relationships between objects to make them easier to analyze and reuse. As is typical of products in this category, InSight can work with a variety of tools, including Microsoft Visual Basic files and OLE objects (such as Microsoft Word documents) and LBMS Systems Engineer. This is essentially an ActiveX-oriented product.

Wallop Software Inc., Build-IT Object Manager
Build-IT is one of the few repository products, so far, that specializes in serving Web development. (See Figure 1.) The Build-IT Object Manager has a dictionary that registers file types and parameters associated with each component in a Web application. The goal is to let developers select best-of-breed tools and then share what they create as components of a project. Components are associated with development and authoring tools so that these tools can be launched automatically when a component needs to be examined or modified. Build-IT supports the import, creation, and deployment of standard components, including HTML pages, Java applets, ActiveX controls, and .gif images. Components are organized into libraries and stored in file systems on Unix and Windows platforms.

Figure 1 - Wallop Software's Build-IT supports the import, creation, and deployment of standard components, including HTML pages, Java applets, ActiveX controls, and .gif images. Components are organized into libraries and stored in file systems on Unix and Windows platforms. Clicking any component opens the appropriate Authoring tool. (Courtesy of Wallop Software.)

ProForma Corp., ProVision BPR, Object Model Repository
The approach taken by ProForma emphasizes BPR as developed through CASE methodologies and then documented in the object repository. Objects and components derive their definitions from the repository; the strength of the repository in this application is the ability to assemble and coordinate business rules and business objects for very large projects or across several projects. The business objects generated from the analysis can be exported to a number of different tools, including C++, Smalltalk, IBM Corp.'s VisualAge, PowerBuilder, ParcPlace-Digitalk Inc.'s VisualWorks, GemStone Systems Inc.'s GemStone, and Visual Basic.

MetaCase Consulting, MetaEdit+ Object Repository for Integrated Methods
In a similar vein to ProVision, MetaEdit+ is a front-end analysis program that uses an object repository to store CASE documentation and the objects created from the analysis.

This multiproject CASE tool allows design information to be shared and reused among different development projects and several concurrent users. MetaEdit+ provides full project lifecycle support, though without the detail of some other products. It provides the results of the up-front analysis and design as objects that can be used by the same tools for technical design or for generating code.

Complex Yet Essential

Object repositories run a gamut of approaches, from simple storehouses of objects to entire project lifecycle products that cover every aspect of software development from analysis to maintenance. To a certain extent you can pick a product that fits the scope of your needs, if, indeed, one product can fit all projects. That's what makes the all-encompassing repositories such as Unisys UREP and LBMS attractive -- except for an important caveat: The pricing for these enterprise-level products is steep, often running into the tens of thousands of dollars. As a whole, this is not an inexpensive category of software, with most products at $1,000 a seat or more.

The fact that the majority of these products are sold with training and consultation is another clue that installing and mastering comprehensive repositories is a major undertaking and expense. Which leads to the question: When is this kind of object management justified? The truth is, the level at which an object repository could be really beneficial is quite low: a project involving more than five programmers, more than three projects occurring at the same time, or a project containing more than 300 objects or components. There are too many variables to be precise about this, but the point is that most projects could benefit from an object repository, if they could afford it.

Unfortunately, object repository products are usually very complex pieces of software, meaning they are expensive to develop. The job is made even more difficult by the constantly changing object-oriented environment. Companies that build object repository programs are under the gun to keep up with new tools (especially if they venture near the Internet market), and they must deal with some major standards issues that are either already here or coming down the pike. In particular, the CORBA and/or DCOM standards for distributed objects will have a major impact. Several object repository products such as Unisys UREP are already being positioned to serve as specialized partners for object request brokers (ORBs).

At the moment, the more complete object repository systems are targeted for major corporations and big projects. That will change. No doubt, the appearance of Microsoft's repository will help concentrate everybody's thinking, and as Internet software development mushrooms and object-oriented programming continues to become the mainstream application development environment, demand for object repository services -- at all levels -- is bound to skyrocket. If things take their usual course, we should be seeing more approaches, more competition, and less expense. It'll be none too soon.

Components vs. Objects

The words "component" and "object" are thrown around casually in relation to software. Do they describe different things? Not really. One graduates into the other, or to use another trendy word, it's a matter of granularity. In the object-oriented approach, it's generally understood that applications are (or should be) built by combining components, and components are built using objects. Although components are most often associated with Microsoft's ActiveX controls or smaller Java applets, components can be whole applications. For example, a sales automation application might use a phone management component, which is itself a complex application usually composed (in the object-oriented programming sense) of a large number of smaller objects.

Unfortunately, confusion arises from the industry proclivity to call just about anything that shows up on a computer screen an object. ActiveX or Java components are routinely called objects. Web developers like to say that everything is an object, including HTML pages. So do developers of client/server development systems, even when they use relational databases and don't support class inheritance. To top it all off, in object-oriented programming a component is called an object during the execution of a program. Consequently, if you are referring to something that gets plugged into a larger assembly, call it a component. Otherwise, call it an object. That's safe.

Nelson King has been a database application developer for over 15 years and has written eight books on the subject. You can email Nelson at nhking@winternet.com.

Copyright © 1997 Miller Freeman, Inc. ALL RIGHTS RESERVED