In case you were not able to attend our 2007 Momentum or Software Developers Conference, we wanted to share with you some system level additions, deprecations and removals coming in Documentum 6 (D6), so you can start to prepare for your D6 deployments now.

DMCL Functionality is Java Based

With D6, the functionality that was in the native C++ DMCL API, has been incorporated into the Java DFC API. You may recall that in 5.3, we announced the deprecation of the DMCL "pass-through" methods (apiSet, apiGet, apiExec, apiGetBytes, apiSetBytes). If you are now accessing the DMCL functionality through DFC as directed, your code should work as it did before and this change will be largely transparent to you. If you are continuing to access the DMCL APIs directly, you can still use the 5.3 DMCL with D6, but you should begin moving to Java and DFC right away, as major versions post D6 may not allow access by the native DMCL.

The benefits of moving the DMCL functionality to Java are as follows:

• Allows for WAR File Deployment for WDK Apps
• Simplifies Clustered and HA deployments
• Allows “non-exploded” WAR file deployment for better performance (for BEA)
• Allows Sandboxed DFC per Application to avoid application conflicts and to allow flexibility of migration/upgrade
• Simplifies troubleshooting by removing transition from Java to C++
• Allows for support of Business Logic and ASPECTS

WDK based applications in D6 will support a standard J2EE deployment strategy, in which dfc.jar and related files will be packaged in a WAR file and optionally sandboxed, so that each DFC instance can have its own DFC configuration. This will allow you to run different versions of WDK based applications (D6 and up) in the same application server, allowing you more deployment and upgrade flexibility. This will also mean that you will not have to run the installer on each machine in your networked or clustered application server environment, meaning it will be easier to deploy WDK based applications in these environments.

In addition, it will be easier to isolate problems as there will be no transition of code from Java to C++. To further add troubleshooting, we have added additional tracing functionality into DFC. Unlike the old DMCL tracing, which is based on a set of trace levels where each higher level results in additional tracing information being added to the log, DFC tracing in D6 will expose a set of configuration properties that can be independently configured. Some properties will result in more detailed information being logged while other properties will serve to limit logging to specific classes, methods, users, etc. Tracing output can be narrowly constrained by configuring multiple properties.

The DFC Java DMCL will have functional parity with the current DMCL. That is, all functionality represented by currently documented DMCL methods will be available through DFC methods. In addition, the D6 DFC Java DMCL implementation will honor BOF and ASPECTs.

What About dmcl.ini?

In prior releases, there were two configuration files: dmcl.ini and dfc.properties. The dmcl.ini file recorded configuration values for client sessions started under the current (5.3 and earlier) DMCL. The dfc.properties file provided configuration information for DFC sessions. In release D6, these files will be unified and dfc.properties file will become the sole configuration file for client sessions. The dmcl.ini values that are still valid, will be migrated to dfc.properties automatically during dfc upgrade.

During the unification process, we have also taken the opportunity to establish some new naming standards for dfc.properties and created utilities for you that will help you map from the old names to the new names.

What About Docbasic and IAPI and IDQL?

Docbasic, IAPI and IDQL will be supported through a Java package whose interfaces and methods emulate DMCL methods by mapping DMCL methods to DFC methods. When emulation is required, the functionality in the package will parse the DMCL and find and execute the appropriate DFC method. The emulation capability will support legacy Docbasic programs executed by dmbasic.exe, IAPI and IDQL, and DFC methods such as IDfSession.apiExec() and IDfSession.apiGet(), and so forth. The emulation package will support the majority of DMCL methods for emulation. The following DMCL methods will not be emulated:

• ping
• match
• find
• index
• scope
• show
• table

When this emulation is used for Docbasic programs that call DMCL methods directly, the application may experience slower performance time due to the cost of initializing the DFC when dmbasic is invoked. This performance degradation will be most noticeable in applications that run many, short dmbasic scripts, as the DFC must be initialized each time dmbasic is invoked. The emulation is part of dfc.jar and does not require any special installation.

In 5.3 we added the ability to convert Docbasic expressions used for check constraints or in conditional value assistance directly to Java code. That capability was implemented using methods (dmc_MigrateDbExprsToJava and dmc_MigrateDbExprsToJavaForType). The resulting Java code was stored in dmc_validation_modules. This implementation was a manual implementation – that is, you had to run the methods to create the Java code equivalents for the expressions. However, for D6, conversion of Docbasic expressions in check constraints or in conditional value assistance to Java code is done at runtime, automatically. The result is cached in memory for the life of the DFC process. Performing conversions at runtime is not expected to degrade performance. Additionally, regenerating the classes for the converted expressions has the benefit of ensuring that the generated classes are always understood by the VM in use. This new functionality means that the dmc_validation_module object type is deprecated. It will not be used in D6. However, the object type and the previously used methods will continue to be supported to support cases of a 5.3 client running against a D6 repository.

New Technologies – Java 1.5 and JMX

D6 DFC is built on Java 1.5. Java 1.5 has many features that we have taken advantage of, including generics, typesafe enums and expanded monitoring and management support, including support for JSR 003 Java Management Extensions (JMX). It will be necessary to recompile your DFC code using Java 1.5. Also, we will only support our D6 WDK based applications on application servers using Java 1.5 VM.

We will be providing a DFC JMX interface for programmatically configuring DFC properties. Documentum Administrator will also be using JMX interfaces for application monitoring and management.

D6 DFC will provide a management bean for tracing configuration. The DFC tracing MBean will provide additional methods for setting those properties which can take multiple values. In addition, some parameters in DFC will now by dynamic, meaning that they will take effect immediately and not require stopping or restarting your application.

New Technologies – Eclipse

We will introduce support for the Eclipse tooling environment in Documentum 6. If you are not already familiar with Eclipse, you can find more information at http://www.eclipse.org.

Deprecated Functionality: BOF1

As of D6, we will be deprecating BOF1 functionality, in favor of our new BOF2 functionality. We will likely remove this functionality in the next major release. We will still include dbor.properties for your BOF1s in this release. We have converted our BOF1 code to BOF2.

Deprecated and Removed Functionality - Routers

In D6, routers, which have been deprecated since 4.0, will not be supported in D6. Any routers you still have should now be replaced by workflows. Hence the following router commands will not be supported:

• start
• force
• reverse
• forward
• reassign
• inserttask
• removetask

Deprecated and Removed Functionality – Content Transfer Applet

In D6, our content transfer applet will not be shipped, instead you must use our UCF.

Getting Ready for D6

To recap, you don’t have to wait for Documentum 6 to ship to begin your D6 preparations. Here are some steps that you can do right now – in order to be ready for the Q3 2007 release of Documentum 6:

1. Begin familiarizing yourself with the new technologies that will be part of D6.

• Learn Java 1.5
• Learn JSR 003 JMX Management API
• Learn Eclipse

2. Ready your code in these areas:

• Convert your Routers to Workflows
• Replace your Content Transfer Applets with our UCF functionality

3. Read the planning documents as they become available.

• The “What’s New in D6” document (coming August 2007) will provide you information on what the new functionality that is part of D6 on a product by product basis.
• “System Migration Guide” will be available when D6 ships. This document will provide you with a roadmap to plan your D6 upgrade.