An Oracle White Paper

September 1996 v1

Contents

1. Introduction
2. Component-Based Solutions, Architectures and Techniques
3. Multi-Tier Architectures with Distributed Components
4. Smooth Migration to Object Technology
5. SEdona — Oracle's Component-based Solution
6. Leveraging Industry Standards and Enterprise-wide Platforms
7. Simplifies Distributed Component-based Development
8. Sophisticated Repository-based Collaborative Development
9. Integration With Oracle Database Servers
10. Integration with Oracle Tools
11. Developing Thin Clients for the Intranet and Internet
12. Integration With Other Development Tools and Databases
13. Summary
14. Appendix A: Glossary of Terms

Introduction

The Economics of Application Development

Intensifying market pressures and advances in technology are placing enormous demands on corporations to improve their time-to-market with innovative products, services and solutions. Explosive phenomena like the Worldwide Web have redefined the rules of global competition driving the need for new tools and languages to update existing systems and build new enterprise solutions.

Corporations are realizing that information systems once used solely inside their own operations must be changed to exploit new opportunities for growth. The reality is that nearly any business opportunity could evolve into an enterprise-wide Internet or Intranet solution. The model for software development of these systems must adopt new properties to quickly satisfy these demands.

To address these challenges, developers will be forced to break free of today's monolithic, large scale information systems development efforts. They'll need an iterative approach to stay competitive– build small self-contained reusable components, install them, refine them off-line, then upgrade them. Through successive refinement of assembled components, enterprise applications can adapt quickly to changing requirements and apply existing proven solutions to new tasks.

In order to capitalize on these economics, corporate IT groups must embrace the key traits of component-based iterative development and adopt tools and techniques to support them. The potential benefits of component-based development are numerous: increased developer productivity through component reusability, flexible and adaptable environments, reliable systems, major performance improvements, reductions in maintenance costs, and portability across multiple platforms and operating systems.

This paper describes the types of enterprise solutions developers are starting to build, the architectures and techniques used to design and build these solutions, and introduces Sedona, Oracle's new component-centric application development framework.

Component-Based Solutions, Architectures and Techniques

Component-based Development

Components make it possible to reuse business application functionality to an extent that has never before been possible. Until now, there have been no industry-wide standards allowing developers to mix-and-match objects from multiple vendors. Object-oriented programming (OOP) languages have improved the level of code reuse, and commercial class libraries can provide generic functionality that hides much lower-level API complexity. However, for the most part, OOP languages have not significantly increased the reuse of domain-specific code written for corporate applications. While programming languages can provide encapsulation and inheritance, they do not offer an infrastructure for packaging and distributing components beyond the level of a project or, at best, a department. In addition, a development commitment to specific languages and operating systems further hinders reuse.

Since components make it possible to reuse objects at the level of the enterprise and even the industry, it is important to understand exactly what a component is. Components from different systems share certain characteristics:

• Components are self-contained reusable software pieces. Their functionality is granular enough to be useful in multiple applications.
• Components can interoperate across processes and operating systems. Component infrastructures handle interactions between components in different address spaces anywhere on the network.
• Components are language-neutral. Developers can create components using any language and programming tool, provided their components conform to accepted protocols and standards.
• Components have well-defined interfaces and clear boundaries, allowing individual components to be modified or replaced without disrupting the applications they comprise or participate in.
• Components can be used in more than one application. Although a single component might constitute a small application, or applet, components provide specific services or functions, and developers assemble them together with other components to form complete applications. Because components are separate entities, they can be put together in any number of combinations, even for purposes far-removed from those foreseen by their developers.

Today, the two industry-leading standards for component software are the Component Object Model (COM) and Distributed COM (D/COM) from Microsoft and the Common Object Request Broker Architecture (CORBA) from the Object Management Group (OMG). COM and D/COM are both a component specification and an implementation from Microsoft for Windows NT and Windows 95. OLE and ActiveX are based on COM and D/COM. Since D/COM includes all of the component specifications and implementations of COM as well as added distribution interfaces, protocols and specifications, from here on this paper will refer to D/COM.

CORBA is a specification for which many different vendors have developed CORBA-compliant object request brokers (ORBs). There are significant technical differences between D/COM and CORBA, but the low-level services they provide have similar objectives. Both promote software reuse through component standardization, and both provide an infrastructure for distributed component interactions.

Today, CORBA and D/COM are the two leading standards for component software, and it is likely that both CORBA and D/COM will become increasingly popular for developers creating reusable distributed software components. There is a need for tools that have the ability to interoperate with these object model standards as well as C++, Java, ActiveX/OLE and Object/Relational Database Management Systems (ORDBMS) to increase the selection of components available to any development project, and protect an investment in component technology from changing market conditions. Rather than having to choose one standard over another, developers must be able to incorporate components built to multiple standards, while at the same time integrating with their chosen relational or object/relational database. Developers must have the capability to not only reuse existing CORBA, D/COM, ActiveX/OLE, C++, Java, or ORDBMS components, but also to publish their own application components to any one of these formats. Corporate IT groups will have more options to choose from when selecting vendors and technology, giving them the flexibility to choose the component technology best suited for their applications. For example:

• COM or D/COM for GUIs on PC clients (D/COM is expanding into the application server space)
• CORBA for UNIX on application servers and departmental database servers
• ORDBMS/database component types for large scale database servers

Component interoperability unifies disparate approaches, platforms, and component standards allowing them to coexist. It is a key requirement for building scaleable applications on large heterogeneous enterprise networks. Another primary requirement is the ability to catalog, organize, browse, query and search for these components in an active object repository. The repository needs to manage component reuse and interoperability with sophisticated features such as version management, distribution control, browsing and querying capabilities, and context management.

Multi-Tier Architectures with Distributed Components

Two-tier client-server application configurations are replacing many centralized monolithic applications at the workgroup and department level. The advantages of the client/server model have led corporations to start deploying these applications throughout the enterprise. As this process continues, developers need to solve a number of new problems, including poor performance, lack of scalability, and high maintenance costs. Most troubling of all is the difficulty of sharing business rules and application logic across the organization. This problem arises from several factors, including the inability of current client-side development tools to create complex application logic in a reusable way, and the failure of server-side implementations to enforce complex business rules and application processing.

Corporations are realizing that both centralizing their business logic and integrating legacy systems with new solutions are critical to their business. Successful analysis, development, validation, testing, and maintenance of business logic is among a corporation's most strategic advantages. Business logic must be maintained independently from front-end tools as well as back-end databases so that it can evolve without having to redeploy client applications as market demands arise.

Well-devised, well-implemented distributed architectures can become a strategic weapon and a key corporate asset. Corporate legacy applications can be divided into logical pieces and reused as components for maintainability and integration with new component-based applications. This allows corporations to take full advantage of their legacy applications as new versions of tools and databases are released.

This situation has led to the introduction of three-tier application models. The third tier is a middle layer of application logic that can interact with a database server on behalf of multiple clients. Recently, new standards for object models and object request brokers such as D/COM and CORBA have made possible a new way of developing and deploying multi-tier distributed applications. With the runtime services and infrastructure that these new technologies provide, distributed components, can reside anywhere on a network, and can interact with each other through standard interfaces and communication protocols. Distributed components can encapsulate data and business logic at any level of granularity, and go beyond two- and three-tier configurations to an n-tier architecture that provides complete flexibility for partitioning applications across the enterprise.

Figure 1: Multi-tier architecture with a middle-tier of distributed components and an object repository for building distributed component-based applications.

Flexible networks of distributed components replace rigid applications, where self-contained components can be assembled by developers into complete applications that can interoperate across network boundaries and operating systems. Individual components can be both “clients” and “servers,” and they can reside anywhere on the network, providing for flexible and easily scaleable systems.

Smooth Migration to Object Technology

Many corporate IT departments are adopting object-oriented (OO) analysis and design methods with the hope of better sharing business requirements between domain experts and developers. At the same time, numerous companies are trying to realize cost savings and faster time-to-market by transitioning from implementing all aspects of their operational systems in-house to a new strategy of integrating and tailoring "off-the-shelf" application components. Unfortunately, few existing tools deliver even a fraction of the potential benefits of object-oriented technology.

Current object-oriented programming languages allow developers to create objects that encapsulate code and data as methods and attributes, and to reuse code through inheritance. But they stop short of supporting higher-level OO modeling constructs such as workflow, rules, and events. Traditional CASE tools give analysts the ability to incorporate these kinds of constructs in their models, but their output is typically a diagram, a 4GL, or a generated set of C++ header files. Once analysts hand off their design to application programmers, the integrity of the application model is immediately at risk. Even with good forward and reverse engineering capabilities, the source code is often easier to modify during the final development stages. Inevitably, the source code and models diverge. This is true during the initial development of the application and becomes even more problematic during the maintenance that occurs over the lifetime of the application.

The problem can become chronic as developers begin to assemble applications from components which they themselves did not create. Without tools capable of modeling the functionality of individual components within a larger application model, developers are further tasked with understanding and remembering how the disparate pieces fit together to make a whole. They are realizing that the business model must become one with the application. In addition, they are demanding protection from the complications of working with multiple component standards, and are requiring the ability to use any component's functionality to model, assemble and deploy applications.

For most mainstream IT organizations, replacing existing databases and applications with completely new, stand-alone object-oriented databases and tools is not a viable option. A smooth migration path to object technology for these organizations is mandatory. The object extensions to the relational capabilities must be combined with well integrated runtime services and application development frameworks. This will ensure a successful migration path for organizations who need to carefully manage the adoption of object technology and new application models, without having to write off existing applications and data. Corporations embarking on these new database capabilities and object-oriented methodologies require a complete set of integrated tools and languages to best utilize the new object advancements in the database. In addition, their existing applications and data must continue to work and function while their IT groups are building new component-centric applications.

SEdona — Oracle's Component-based Solution

Oracle recognizes the need for a new component-based development framework and is responding with Sedona. Sedona is designed to be both a producer and a consumer of components using leading industry object standards: D/COM, CORBA, C++, ActiveX/OLE, Java, and Oracle8 object/relational server. Sedona hides the complications of working with multiple component standards and gives developers the ability to use any component's functionality to model, assemble and deploy applications.

Sedona focuses on the entire development life-cycle including business-centric analysis and design with deployment architectures for building multi-tier distributed component applications. With Sedona, designers and developers will work with the business model and the application as if they are one and the same.

Sedona provides the tools and technology for development teams to create, assemble, model, design and deploy distributed components and a component-centric development environment for creating multi-tier distributed enterprise applications. Sedona also delivers integrated tools to take advantage of the powerful new object extensions in the Oracle8 object/relational server, giving IT developers tools for building and using the new database component types in Oracle8.

Leveraging Industry Standards and Enterprise-wide Platforms

At the core of Sedona is the object manager and repository, coordinating interactions between components spanning different native object systems. While fully supporting the native distribution mechanisms available in CORBA, D/COM, ActiveX/OLE, Java, C++ and the Oracle database, Sedona gives developers the flexibility to partition a logical application model onto several different physical application servers. The Sedona application server, the object manager and repository, handle all the marshaling of and negotiations between each component.

Sedona provides access to all the features of CORBA, D/COM, C++, Java, ActiveX/OLE and Oracle8, and adds powerful business-object implementation features to extend them declaratively. Both components created inside Sedona and those imported into it, can be assembled into deployable applications, making sophisticated application development simpler for a wider audience of component "consumers".

Sedona supports the native features of each object system it interacts with through a special Sedona component called an adapter. Oracle will supply a series of useful adapters with Sedona's production release, but since the Sedona system is built entirely using itself (with C++ as the implementation language for maximum compiled performance), building a new adapter can be done by following a straightforward "cookbook" approach. This expands the universe of objects that Sedona can assemble and automatically store in the database. With Sedona, developers can simply take components and assemble them to create distributed enterprise applications.

Simplifies Distributed Component-based Development

Once an “off-the-shelf” component has been assembled into an application, developers need to know more about it than just what attributes and methods it exposes. They need to understand the role the component plays in the application, which of its methods are being called by other objects, what events it executes and which objects respond to those events, and finally, if a new and better component becomes available that provides a similar service, how upgrading will impact the rest of the application. Sedona provides tools for modeling and understanding the relationships between objects as part of the application building process, not as a separate, disconnected stage of development.

Sedona unifies object-oriented modeling and object-oriented rapid application development in a single, highly usable, interactive environment. Iterative development occur on the model or on prototypes based on the model. Since both the model and executable-prototype are simply alternative, editable views of the same active object definition, no one is ever out of sync or questioning whether it's safe to modify generated code. In Sedona, the model is the application.

Figure 2: Process model animates business flow without writing code

Sedona's fully object-oriented, graphical tools assist in analyzing and capturing business requirements, as well as evolving the functionality of the objects identified during analysis through to design, testing, and deployment. Sedona provides a runtime execution environment for deploying distributed component applications that can interoperate across major component software standards and integrate with relational or object/relational databases such as the Oracle server. To maximize the benefits of component assembly, Sedona lets developers become true producers of components for use by any products which adhere to industry standards. This makes customized, assembled components accessible to nearly every tool on the market including Developer/2000, Designer/2000, Power Objects, Visual Basic, C++, PowerBuilder, Delphi, and others.

One of the most exciting innovations which the Sedona graphical design tools present is support for visually creating, executing, and debugging the business policies for components. These dynamic "state models" are stored as part of each business component's definition, and provide the foundation for supporting workflow. Sophisticated component workflow processes are implemented directly from the visual representation. Sedona provides a suite of graphical diagrammers, browsers, and editors to manage, assemble, and publish components.

Sophisticated Repository-based Collaborative Development

In a reusable and highly distributed environment it is important to have the ability to manage, organize, catalog, track, browse, query and search for components. Development teams need to have a sophisticated environment to maintain versions of components and manage large development efforts. A repository is essential for managing disparate components and large development teams. In this environment it is also fundamental to have an active repository.

An active repository is capable of uniting all of a corporation's existing metadata, including component implementations which might exist in object registries like those of CORBA or D/COM. An active repository stores not only information about data (metadata), but it also stores and manages the executable components themselves. In addition, an active repository presents reusable components to teams of developers as if they existed in a single, logical universe of components, even if they are physically stored on different machines.

Sedona's Active Repository enables teams of users to organize, share, and evolve the features of components in parallel. This provides the foundation on which tools can synchronize the different phases of a component's lifecycle around a single, active object definition. Any vendor can produce tools that plug into this architecture since it is all public, open, and documented.

Users of the Active Repository must be able to efficiently search the repository for reusable components to help them quickly find something in the system that might already solve a problem at hand. The Sedona Active Repository includes configurable summary information stored with each component which can be used to efficiently search through a single, logical "universe" of components that might actually span several physical locations over "Intranets" and the Internet. The ability to define user-customizable "Summary Information" on objects managed by the repository, means that corporate reuse architects and reuse librarians can annotate objects with keywords and organize objects into meaningful categories. In this way, the system administrator can decide which cataloging and summary information is required with each component and which information is optional. The Active Repository fully exploits the Oracle Universal Server's new "Context Option" for performing fully indexed text searches on the documentation for each component as well.

Figure 3: Active Team Repository.

Sedona's Active Repository offers direct support for check-in, check-out, and branching of components. This enables administrators to track component usage and determine which users made modifications to components and when the changes took place. The Active Repository fosters teamwork collaboration through its support of version control, configuration management, and customizable development process enforcement. It provides a neutral information model for components, manages all changes made to them by developers, and provides a framework for annotating and cataloging reusable business components for future reuse searches. Developers can be more productive by taking advantage of the Active Repository's facilities for querying through metadata for a particular component, attribute value or relationship. This can be combined with "what if" style queries for determining the ramifications of making any changes.

Integration With Oracle Database Servers

For most mainstream IT organizations, replacing existing databases and applications with completely new, stand-alone object-oriented databases and tools is not a viable option. Oracle is uniquely positioned to provide a smooth migration path to object technology for these organizations. The object extensions to the relational capabilities of Oracle8, combined with the runtime services and application development framework of Sedona, provide a smooth migration path for organizations who need to carefully manage the adoption of object technology and new application models, without having to write off existing applications and data.

Oracle8 extends the Oracle relational server with objects, and provides additional support for multimedia data, including text, video, spatial data, image, and time series. Extending the relational foundation offers several advantages:

• Existing applications continue to work.
• New applications can be built on sophisticated data.
• Existing data can be integrated with object technology using object views.
• Oracle8 objects automatically leverage existing Oracle server features including parallelism, concurrency, scalability, and distributed processing.

Sedona provides graphical modeling and programming tools for developing applications with Oracle7 relational data, Oracle8 database component types, or any combination of the two. These include tools for creating and evolving schemas, mapping objects to relational tables and tables to objects, modeling complex master-detail relationships, and managing transactions.

Integration with Oracle Tools

Oracle's development tool offering includes: Develper/2000, Designer/2000, Discover/2000, and Power Objects. Developer/2000 is Oracle's market leading client/server and web development tool. Designer/2000 supports the modelling of complex systems with business process reengineering (BPR), analysis, and design diagrammers. Discoverer/2000 enables people within all levels of the organization to gain immediate access to business information by supporting rapid querying and reporting, multi-dimensional analysis. Power Objects is a visual object-oriented development tool for building workgroup database applications quickly and easily.

Developer/2000 can today connect in a multi-tier client/server configuration to relational databases from Oracle and other database suppliers. Today Developer/2000 developers can drag and drop code between a client and database server. A database can also serve as a middle-tier for client/server applications which are free to get their data from other distributed databases via standard database links. Sedona delivers the benefits of component assembly, interoperability and an active repository to Developer/2000 and the other members of Oracle's development tool set. The Sedona application server will add component assembly and interoperability as well as advanced repository functionality to this middle-tier. With the added capability in Developer/2000, developers will have the extra advantage of working with distributed components and a live active repository as their middle-tiers.

Figure 4: Integrated tools with the Sedona application server. Tools present and access distributed components.

Once a system of distributed components has been iteratively evolved to support the required features, it can be deployed on a particular tested configuration of distributed components to a Sedona application server. From that central location, all of the encapsulated business logic will be accessible by user interfaces designed using Developer/2000, Power Objects, Express Objects, as well as Oracle Interoffice. The Sedona application server provides a common interface to multiple industry standards for distributed component implementations and offers facilities for integrating those with the database. In addition, the Sedona application server gives the same consistent access and interface to the new Oracle8 database object types, expanding the realm of components with which Oracle's tools will be able to integrate.

Customers already leveraging a model-based approach to system analysis, design and generation, using Oracle's Designer/2000 will be able to use existing business and application models as a basis for networked distributed components designed with Sedona. In addition, distributed components deployed as shared services using a Sedona application server and any data-smart visual components produced can be easily integrated into any existing application built with Developer/2000, Designer/2000, Power Objects and other development environments.

Figure 5: Sedona's application server as the middle-tier supplies Oracle tools with distributed components and built-in object repository features.

All of Oracle's application development products will evolve to use the Sedona's Active Repository to share common, active metadata as well as common browsing and search tools. New capabilities afforded by the Active Repository will give future versions of Designer/2000, Developer/2000, Oracle Power Objects, and Discoverer/2000, opportunities to expose rich new teamworking, configuration management, packaging, and distribution facilities as well as offer access to shared business components.

Developing Thin Clients for the Intranet and Internet

Through integration of Oracle's WebServer 2. 0 with the Sedona application server, any Web browser can invoke components from the application server, as well as retrieve instances of distributed components presented using downloaded Java Applets. Sedona will provide developers with full support for building and using components in Java. In addition, Java will be a component standard supported in Sedona's arsenal of integrated component standards.

Runtime features of the Sedona application server will have the ability to package up as a Web Application Module and enable any Web browser to run a Sedona deployed application through the Oracle WebServer 2. x or greater. Sedona provides one development environment for both Windows and Web clients, thereby providing one central place to store business and application logic, minimizing maintenance costs.

Integration With Other Development Tools and Databases

Sedona supplies a set of modular adapters providing immediate access to the market leading component standards. All the necessary interfaces and tools are available for third party developers to create additional adapters for Sedona. Providing a completely open environment which supports development of adapters for other databases, object stores, and component standards.

Consistent APIs are supplied with Sedona to give developers the ability to leverage Sedona's functionality easily from existing development environments such as Visual Basic, PowerBuilder, and Delphi. This makes the Sedona environment more flexible and allows users to select their preferred development tool and leverage existing investments and skills. Sedona's architecture is database neutral as well, allowing developers to exploit the features of other relational, object/relational and pure object databases.

The Sedona Active Repository contains an extensive set of services and interfaces to facilitate metadata management and teamworking. In addition, the Active Repository's architecture is fully open so that third party vendors can leverage their expertise to validate the repository design and provide additional functionality to the Sedona Active Repository.

Additionally, Sedona supports the implementation of additional tools such as diagrammers, editors, CASE tools, compilers and debuggers. Having third party vendors implement versions of their tools within the Sedona environment is a powerful combination, and allows existing third party solutions to address different aspects of the software life cycle.

Summary

Corporations are facing many challenges when deciding to update existing systems and build new solutions. Sedona addresses each of these challenges through a rich, interactive, team environment for analysis, design, assembly, testing, and deployment of distributed components using a choice of industry standards, and offers the only framework and tools for designing and building distributed applications out of complex distributed components that are automatically integrated with the database. Distributed components assembled and deployed with Sedona are directly accessible from applications built using Oracle Developer/2000, Oracle Power Objects, as well as other tools, ensuring that Sedona adds value to any existing application development tool in use today.

Appendix A: Glossary of Terms

ActiveX ActiveX controls, formerly known as OLE controls or OCX controls, are components (or objects) inserted into a Web page or other application to reuse packaged functionality. For example, the ActiveX controls that are included with Microsoft® Internet Explorer version 3.0 allow developers to enhance Web pages with sophisticated formatting features and animation. A key advantage of ActiveX controls is that they can also be used in applications written in many programming languages, including all of the Microsoft programming and database languages.

Adapter A service of the Sedona application server that provides a bi-directional path from a persistent store (such as an Oracle7 or Oracle8 server) to an component in the Sedona environment. Application developers can work with an adapted components as if it were a native Sedona component. Currently supported data sources are Oracle7, Oracle8, CORBA, Distributed COM, OLE and/or ActiveX, and C++. Oracle will supply all the APIs for creating additional adapters.

Application Umbrella term for all of the entities that together perform a specific information management function. A Sedona application includes a local or remote object manager instance and a Sedona runtime client, as well as database servers, CORBA ORBs, networking software, and other application entities.

Component Components are self-contained reusable software pieces that can interoperate across processes and operating systems. Components are language-neutral. Developers can create components using any language and programming tools, provided their components expose the interfaces required for interoperability. Components have well-defined interfaces and clear boundaries between each other, and individual components can be modified or replaced without disrupting the applications in which they participate. Components are objects that can be used in more than one application. Although a single component might constitute a small application, or applet, in general, components are objects that provide specific services or functions, and developers assemble them together with other components to form complete applications. Because components are separate entities, they can be put together in any number of combinations, some of which may not even have been foreseen by their developers.

Database Component Type Oracle8 object type or abstract data type.

Distributed Common Object Model (D/COM) Specifies interfaces between component objects within a single application or between applications and separates the interface from the implementation. Bases for Microsoft's distributed computing environment.

Common Object Request Broker Architecture (CORBA) A system definition specification that allows applications and components to communicate with one another regardless of their location and developer.

Metadata Information about the substantive or “real world” data that is the end user's real concern; for example, descriptions of the location and the format of the end user's data.

Object An instance of a class. Objects have a lifecycle: they are created, exist in memory or persistent storage for some period of time, and are then released. During an object's lifetime, it can be saved persistently in the repository, reused and loaded into memory as needed. An object has “state”. The state of an object is defined by the current values of its attributes.

Object Modeling Specification that describes objects and formalizes their rules of engagement.

Object Manager (OM) (Sedona application server) Provides runtime services, access to multiple object stores, object interoperability, and access to the repository. To access the services of the OM, clients must establish an OM connection. The connection to the OM can be local or remote. In a local connection, the OM instance runs on the same machine as the client process connecting to it. In a remote connection, the OM instance runs on a remote machine or collection of machines and the connection is made through the network. The local configuration involves a connection to a single-user OM, and is transparent to developers using Sedona. The remote configuration involves connecting to the multi-threaded, multi-user OM installation and applications connect through a published API.

Object Linking and Embedding (OLE) A set of common services that allow components to collaborate intelligently. See ActiveX.

Repository A facility that supports application development by gathering into one logical space all the components. A repository can be private or shared. It supports team working, which includes version control, libraries, projects and other collaborative product development efforts. The repository is a central facility in Sedona.