Developer/2000

Developer/2000 lets users build sophisticated systems that scale from workgroup to enterprise.

Developer/2000 is a virtuoso tool. By that I mean not only that it is capable of producing wonderfully rich and powerful database applications in the hands of a talented developer, but also that it requires someone highly skilled in its use to produce such a magnificent result. Given that database application development is still part art and part science, this analogy between the creation of musical masterpieces and software masterpieces is not as far-fetched as it may initially sound. Whereas some development tools can be picked up and used within hours to produce quick-and-dirty applications, Developer/2000 requires planning, study, and practice, but the payoff is in portability, scalability, and tight integration with Oracle Corp.'s databases.

This is a features-oriented review that looks at both Developer/2000 Release 1.4, the currently shipping version, as well as Release 2.0, which is scheduled to ship later this spring. It focuses on a few evaluation criteria that represent the most important issues to developers today.

Object Orientation

I started using the Oracle RDBMS and development tools back in 1986, when SQL*Forms 2.0 had a hierarchy of classes named forms, blocks, and fields. Each block corresponded to a database table and each field to a column in a table (although it was possible to have blocks and fields that weren't attached to database objects). Object methods were defined in what SQL*Forms called "triggers" (not to be confused with stored database triggers that execute in the server), which could be inherited or overridden by objects lower in the hierarchy.

So even back then, more than 10 years ago, Oracle's application development tools contained the rudiments of object orientation. Granted, it was a fixed-class hierarchy and new classes could not be defined by the developer, but it was a start. The Oracle tools have continued to evolve over the years, and the Forms portion of Developer/2000 now offers many more object-oriented programming facilities. (See Figure 1.) Here are a few examples:

Inheritance. Property classes are named lists of properties and methods (triggers). A property class can be applied to any object in an application. These objects will then inherit all of the properties that make sense for that object. If necessary, the values inherited from the property class can be overridden. If overridden at any point, these values can also be defaulted back to the value in the property class if required. Developer/2000 is intelligent in its inheritance of properties and will only inherit those properties and methods that make sense for the current object type. In Developer/2000 Release 2.0, Object Subclassing will be added to the Form Builder to overcome some of the existing limitations of property classes. With the new Object Subclassing, changes made to the structure or properties of the parent will automatically be inherited by the child. You can also override the inheritance and change the properties of the child.

Object reuse. Drag-and-Drop Object Inheritance allows objects and code to be copied or referenced between applications. This capability allows objects and methods to be encapsulated within a source module and reused throughout your development environment. When inheriting objects, you are given the option of copying or referencing the object. When you copy an object, the definition of that object is incorporated into the target module immediately. Any subsequent changes to the source object are not reflected in the target module, and the new object within the target module can be modified without concern. When you reference an object, a pointer to the object in the source module is incorporated into the target module. When you subsequently open or generate the form, Developer/2000 will resolve the reference and incorporate the latest version of the source object.

Encapsulation. Encapsulation allows program changes to be reliably made with a minimum amount of effort. Forms provides this functionality in three ways: Datasource Transparency, PL/SQL Libraries, and Application and Database Packages. Datasource Transparency lets you build template blocks based on database tables and leave the database interaction to Developer/2000 with no coding required. PL/SQL Libraries provide a mechanism to reuse application code and serve to abstract the use of the methods from their actual implementation. An Application or Database Package is an encapsulated collection of related procedures, functions, and other program objects within a single program unit. Once a package has been created and tested, the objects within the package can be modified, with no change required to the objects which rely on them.

Modularity. Complex software systems can become too large and cumbersome to work with. You can solve this problem by organizing and structuring the application in separate modules. The act of partitioning a program into separate components will reduce its complexity. Modularity can be achieved in Developer/2000 at the high level by structuring the application into multiple forms and at the procedural level by organizing the PL/SQL code into libraries and packages.

Polymorphism. Polymorphism means that differing object classes can implement the same function in a manner that is appropriate for the class. Within Developer/2000, polymorphism is implemented using the concept of overloading. Overloading is a method of implementing the same program unit multiple times within a PL/SQL package. Depending on the arguments passed to the package, the appropriate program unit is applied to the arguments. Thus polymorphism and overloading can be used to create generic routines that perform different functions depending on the class they are applied to.

Components

The currently shipping version of Developer/2000 on Windows lets you integrate your applications with other components through OLE 2.0, OLE Automation, VBX (Visual Basic 3.0) controls, and DDE (Dynamic Data Exchange). You can also call .dlls directly from PL/SQL within Developer/2000. Although ActiveX component support is not included in the current version of Developer/2000, ActiveX will be supported in the upcoming Release 2.0, and ActiveX is part of a larger product strategy that Oracle calls Network Computing Architecture (NCA).

Last year Oracle announced the NCA, which supports client application extensibility through de facto standards such as Java, browser plug-ins, and ActiveX objects. This year Oracle shipped Web Developer Suite, which currently enables the development of PL/SQL cartridges for NCA; in the future it will enable the development of other cartridges supported by this architecture. Web Developer Suite supports desktop ActiveX, Netscape ONE, and Java, and it contains licenses for many Oracle development tools: Developer/2000, Designer/2000 (CASE, modeling, analysis and design tool), Web Server 3.0 (Web application development platform), Oracle7 Universal Server or Workgroup Server, Oracle Interoffice, and a Network Computing Cartridge Development Kit.

Distributed and Multitier Applications

In addition to providing support for component technologies such as ActiveX and Java, Oracle's NCA also includes a distributed object environment based on a CORBA/IIOP software infrastructure. At the core of the architecture are de facto standards: CORBA 2.0 and HTTP/HTML. CORBA 2.0 includes IIOP for object interoperability and IDL for language-neutral interfaces. Oracle's NCA proposes to solve the problem of competing standards with the Inter-Cartridge Exchange (ICX). The ICX will provide a COM/CORBA bridging mechanism that will enable ActiveX/COM clients to access other cartridges (CORBA, Java) through IIOP. Through CORBA and language mappings to IDL, Developer/2000 can be used to create cartridges for Web-based SQL forms development.

Multitier applications are another form of distributed network computing Ñ one that is achieved by application partitioning. Two-tier application partitioning is the ability to move code between client and server, preferably in an environment that can execute the same language on both the client and the server. Oracle has long supported the PL/SQL language on both ends of the client/server connection, and this capability forms the basis of the company's application partitioning strategy. Developer/2000 offers "drag-and-drop application partitioning" of PL/SQL program units. In addition to two-tier partitioning, Developer/2000 can also create three-tier applications that centralize business logic on middle-tier application servers.

Web Deployment

The concept of deploying database applications on the Internet/Intranet platform is gaining momentum. In Release 2.0, the Developer/2000 Web cartridge will allow the deployment of interactive applications on the Web by enabling forms, reports, and graphics built in Developer/2000 to run within Web browsers.

Integration with Add-On

Designer/2000 has already been mentioned as an add-on that works with Developer/2000 for CASE, modeling, analysis, and design tasks. Oracle has maintained a tight integration between these two design and development tools over the years. Designer/2000 generates applications that run on multiple platforms with native look-and-feel and that exploit each platform's native features. Applications generated by Designer/2000 can be enhanced in Developer/2000, and a regeneration process ensures that these custom modifications are synchronized and consistent with the Designer/2000 repository. Previously built forms or reports can be reverse-engineered into Designer/2000 for future application enhancements and maintenance.

Oracle has over 6,000 partners providing add-ons that work with Oracle software products. The Web site alliance.oracle.com lists information about add-ons provided by third-party vendors, many of which work with Developer/2000.

Declarative Development

Business rules are declarative rather than procedural ways of describing applications. Because of its integration with Oracle7, Developer/2000 can create applications from database definitions without requiring any procedural code. Applications built using the Developer/2000 point-and-click declarative features automatically establish all database interaction based on server definitions, provide a complete query-by-example interface, add database constraints to the application, and incorporate a toolbar for performing database operations (insert, update, and delete), a menu to invoke operations from, and all message and error handling. In addition, they provide all master/detail form coordination and intelligent transaction locking, with support for distributed heterogeneous databases.

Reports can be developed declaratively in Developer/2000 by defining queries and their relationships in the point-and-click interface of the data modeler, selecting a report format from the pictorial gallery of report styles, and then running the report.

Designer/2000 also plays a role in declarative application development. It provides model-driven development through industry-standard modeling techniques such as entity relationship, function hierarchy, dataflow, and matrix modeling.

Universal Server Support

Oracle Universal Server has been getting a lot of press lately because of increased interest in complex no relational data types. Some of this interest comes from the Web, where images and sounds are regularly used to accompany traditional relational data types such as text and numbers. Other areas of interest come as relational databases made inroads into nontraditional applications such as textbases and Geographical Information Systems (GIS). Oracle Universal Server includes two server options for storing and searching complex data types: the ConText option for large textual data and the Spatial Data option for geographic data.

Developer/2000 Release 2.0 contains declarative support for many data types in forms and reports, including charts, images, ActiveX controls, OLE containers, sound, and VBX controls. In addition, PL/SQL has procedural support for the LONG data type, which means that application-specific complex data types can be manipulated procedurally within Developer/2000. The Universal Server Spatial Data option is a collection of programs and packages written in PL/SQL so the current release of Developer/2000 can make procedural calls to the Spatial Data programs, and the upcoming Release 2.0 will be able to base a block on a stored database procedure making it easier to take advantage of extended data types. Although Release 2.0 won't contain specific support for the Universal Server ConText option, Oracle plans to make the ConText open APIs accessible to Developer/2000 in the near future.

Top-Quality Tool

Developer/2000 is a top-quality, high-end tool for creating relational database applications. Release 2.0 extends the traditional host-based and client/server deployment options to include Internet/Intranet application deployment. It also adds a passel of new object-oriented programming features and support for Oracle's broader Network Computing Architecture. For developers willing to put in the time to learn how to use their development tool to its full potential, Developer/2000 is an excellent choice for building portable, scalable database applications.

--The Form Builder (formerly called SQL*Forms and Oracle Forms) is the part of Developer/2000 that is used to build interactive applications. This example shows a master-detail form under construction. If you look closely at the toolbar on the left side of the window, you can see the OLE and OCX tools near the bottom.