The idea is compelling. Build applications by creating an abstract layer above and beyond the physical data to deliver applications quickly, and maximize reuse at the developer, project, and organizations levels. That's the idea behind the growing number of repository-driven development environments hitting the market today. (For more information on repositories, see "Overcoming the Object Onslaught," Internet Systems, April 1997, page 23.) What's more, existing traditional repository-less development environments are moving to repositories this year as well.
Repository-development environments are nothing new. Compuware's Uniface has always promoted the construction of applications around its repository, and PowerBuilder has always provided an extended attribute set for building applications on top of the existing schema. Today we are seeing movement to use the repository as a central storage location for metadata, design information, objects, components, and even Web content. Repositories are becoming more sophisticated and powerful, and, as application architects, we need to understand them.
If your head is spinning, you're not alone. There's no consistent definition of what a repository is. What's more, tool vendors are taking the concept of a repository to new proprietary directions and thus further diluting the concept.
Because there are many different types and concepts of repositories out there, I found it helpful to separate them into a few categories: design repositories, application object repositories, metadata repositories, and a combination of all of the above, known as universal repositories.
Design repositories are from the traditional CASE world. They store design information such as processes and database and attribute information in a central database linked with one or more CASE tools. In some instances, the design repositories may link to application development tools, but in most cases the information exists for design purposes only. Oracle Corp.'s Developer/2000 and Designer/2000 are good examples of tool suites that share repository information across design and application development tools. Visual Basic is moving in these directions as well, using the Microsoft Repository that is able to share design information with the Rational Rose CASE tool. (Rational Software Corp. is partner with Microsoft Corp. on this.) (I will cover the Microsoft Repository in my June DBMS column.)
Application object repositories are linked to application development tools and not necessarily to CASE and databases. They store and distribute objects and methods defined within the tool. Using this type of repository, developers can create new objects or, better yet, reuse objects already defined in the object repository. In some instances, the object repository also stores and distributes components such as those defined by ActiveX or OpenDoc technology.
Metadata repositories are simply another layer on top of the existing schema. For instance, although F_Name is defined in some databases, you can learn from the metadata repository that F_Name is also First Name of a Customer, that it should always show up on the screen using Times Roman 12, and that this is a mandatory field when used in an application. In some cases, the metadata repository resides with the data inside the database. Databases themselves are becoming better at providing metadata services through the database alone. Data warehousing projects also rely on sophisticated metadata layers to let the end user make sense of the data and abstract datatypes.
Universal repositories provide the best of all worlds. They provide developers and application architects with the ability to store and manage design information as well as application objects and metadata from one central unit of storage. This is the ultimate in power -- you can find virtually anything you need in a universal repository. The real value is the ability to share this vast amount of information across the entire organization. This is where we are heading today, but we are not there just yet.
Allegris is really a suite of products, including Allegris Foundation, Allegris Workshop, AOR, Allegris Constructor, and DataDesigner. Allegris Foundation is a C++ class library of cross-platform components found in all of the Allegris products. The Allegris Workshop is where the C++ developers play. The Workshop lets developers create reusable components using Allegris painters and editor and using the Foundation as the base. Once completed, the Workshop developers check the components into the AOR.
The Allegris Constructor, which I cover in more detail later, is a GUI application development environment that lets you assemble components to create an application. (See Figure 1.) A 4GL is available as well, known as MethodScript, which lets you add behavior to an application without learning C++ (although you can use C++ within the tool). There is a debugger as well as a deployment mechanism that generates C++ for submission to a Borland C++ compiler (included). Allegris is also able to work with Microsoft Visual C++ and other C compilers such as Microsoft Visual C. An application-partitioning feature lets developers move objects to other servers in order to spread the load for scaling.
The Allegris DataDesigner is where database administrators design relational databases and object models. DataDesigner supports the Unified Modeling Language (UML), a standard approach to object-oriented design notation. It's also able to import an existing physical database schema into a design and translate a static object model to physical database tables on the fly.
The AOR resides on single or multiuser DBMSs such as SQL Server and Oracle. I ran mine on a local Sybase database that came with Allegris. AOR is able to link to databases through Intersolv's DataDirect database middleware technology. The AOR includes a Direct-to-Objects API, providing the performance of an OODBMS for complex data. Of course, the AOR provides hooks for Intersolv's PVCS to support team development and multiple-level versions and to share repository partitions.
Intersolv gives developers a default AOR. You can also create your own from scratch. Although using the default AOR is easy (it's the way I tested this product), creating an AOR from scratch takes a lot of time and planning.
The developer works in three areas: Application Components, Build Components, and Application Partition. They are organized by tabs.
With the Application Components, you can create or reuse all of the components in an application. There are two basic types of components: visual components and nonvisual components. Visual components, as their name implies, are user-interface components such as windows and control, menus, bitmaps, and online help. Nonvisual components are those components that don't interact with the user. Examples of nonvisual components are business logic components, data access components, and transaction components. Nonvisual components are those components you would move to application servers using the application partitioning mechanism of Constructor.
You can use the Build Components tab to build rule sets that they define with the Build Rule Set Editor. Build rule sets contain the instruction and environment-specific information for compiling and linking your application.
The key differentiator is the Application Partitioning tab, which displays the available application servers where you can run your application components. It's just a matter of dragging and dropping those components onto the available server. In the background, Allegris is able to regenerate the C++ code for the target platforms. This provides you with the ability to scale the application through distribution and place the business logic on a shared tier. It also lets you repartition at any time for any reason. The partitions communicate using Peer Logic Inc.'s message-oriented middleware.
Allegris contains many other subsystems as well, including a Visual and Nonvisual Component Editor, a Class and Object Browser, DataDesigner access, Event Map Editor, a Prototyper and Debugger, an Application Partitioning Editor, the MethodScript language, and a Web Development facility. Let's look at just a few of these.
The Visual Component Editor is a traditional GUI development where you can design and test the application interface. The nonvisual components come to life through the Business Component Editor, Data Access Editor, or the Transaction Editor. The Business Components Editor lets you create classes that contain business application logic. The advantage is that Allegris enables you to split the business logic from the interface and the data. This is the way we should view the distributed system architecture conceptually, but it is often difficult to map it to traditional client/server development tools. The Data Access Editor gives you a means of creating data access components, very much like PowerBuilder's DataWindows, through an easy-to-follow interface. The Transaction Editor gives you a way to create components that are really objects that combine data access and business components into a single logical unit of work called a transaction.
The DataDesigner, as I mentioned already, is a CASE-like subsystem that mixes object and relational models together to form an application. You can create two types of models using the DataDesigner: an object model and a relational model. The object models are more meaningful to application architects or to those who would like to depict a set of objects for an application. The relational model is most useful for database designers. The two models are linked, so that changes to one automatically appear in the other.
The Object Model facility draws class tokens to represent objects in an application. Here is where you can assign the object names, attributes, and methods. The relational model lets you graphically create or modify relational databases. You can create a database from scratch or import a schema from an existing database.
The Event Map Editor sets up the processing logic for your application events. Events are triggered when interacting with the user interface or by nonvisual components. It's just a matter of mapping events to methods inside of objects.
The Application Partition Editor lets you create logical application servers and map them to physical servers. Once they exist, you can drag and drop objects to them for processing. Allegris supports Windows NT OS/2, HP-UX, Digital Unix, IBM AIX, and Solaris.
Allegris Web gives you the means of sending Allegris applications to the Web using ISAPI (Internet Server API) on a Microsoft Internet Information Server Web server and a mechanism that maintains a connection with database server. This is a server-side Web development system, and it's interesting that it does not employ ActiveX at the client.
What I do like about Allegris is the speedy C++ compiler that it employs -- blowing by the old sluggish interpreters -- and the simplicity of its development environment (Constructor). Also, the repository architecture is well thought-out, and the design environment is first-rate. Although I don't think that vendors of the traditional popular two-tier client/server development tools are worried about Allegris, it will be a player in the rising n-tier tool market that is targeting enterprise-level distributed application development.
Take it from me: We are going to see more repository-rich development tools this year. Just when you thought repositories were passé, it appears they could be the only way to get complex distributed development back under control.
