As more and more of our clients are upgrading to Documentum 6/6.5, we’ve encountered many significant changes between development methods in 5.3 WDK and 6.5 WDK. The good news is they are changes for the better, allowing for more efficient and streamlined development of Webtop customizations. One of the big changes is the ability to modify a Webtop component rather than having to extend it. 

For those of us that have developed Webtop customizations on Documentum 5.3, we are all too familiar with the extend function when customizing a Webtop component. Extending a component is in essence creating a subtype of that component, and allows that subtype to inherit attributes of the out-of-the box (OOTB) component, unless otherwise overwritten by the subtype. However, extending a component can be cumbersome.  In the past, we’ve had to customize components by copying the entire Webtop component xml over to the custom component xml in order to add only one or two new nodes to the xml. For example, in this scenario, we are trying to implement a customization to display a text area for some custom attributes. The following is what the custom component xml would look like using extends: 

Click to view larger version

You can see that most of this xml is just out-of-the-box Webtop. With 6.5, you can use modifies instead of extends and slim down your custom component xml. The following is what the custom component would look like using modifies: 

Click to view larger version

By using the modifies function, you have access to tags such as <insertbefore>, <insertafter>, <replace>, and <remove>, that take in an XPath query to locate the node that needs to be modified. This removes the need to copy over the OOTB Webtop component xml. This, in turn, allows for easier maintenance of customizations when upgrading to new Documentum versions. You no longer have to make the changes that were made to the out-of-the-box component xml when it was upgraded, to your custom component as well. This would only be necessary now if the part changed during the upgrade ended up being the part that was customized. 

Most of the time, modifying a component is preferred over extending, however there are cases where extending a component is actually necessary rather than modifying.  One such scenario is when you are creating new Webtop functionality that is based on, or needs to replicate, OOTB functionality. For example, a recent client asked for a customization that, upon importing a document, would promote the document to the final state of its lifecycle. They wanted to keep the original Import option, but wanted to provide users with an additional Import to Final option. In order to implement this, a new component was created that extended the OOTB import component so that the same import logic would be used regardless of what import option was chosen. However, for Import to Final, a custom processor was created to run after the import logic and promote the document. 

Click to view larger version

There are also other ways of using modifies and extends depending on the functionality you’re looking for. For example, you can add modifications to a component that’s already been modified at a previous level, or you can modify a component inside of an extension. The one thing to remember when using them together is that when customizations are loaded, extensions are always applied after all modifications have been applied to the component. 

Please feel free to contact us if you have any additional questions about WDK development.

TSG is currently in the process of creating a version of the Active Wizard that will work with our own OpenContent web services. Using OpenContent will allow Active Wizard to work with any Content Management System that OpenContent supports.  This means that Active Wizard implementations will be supported on a number of repository types (ex: Documentum, Alfresco, file system).  The Active Wizard will require only a simple configuration change to work with each CMS.  This will also benefit users who are currently using the Active Wizard with Documentum, as it will mean that only OpenContent code will need to be updated and tested when a Documentum upgrade is implemented.

Also, a filesystem implementation of OpenContent is currently in development that will allow the Active Wizard and Active Wizard Lite to be run on open source platforms such as Apache Tomcat, Apache Derby and a simple file system structure to store XML.

Visit www.activewizard.com for more information on the Active Wizard and OpenContent, and check back here for more updates on the status of Active Wizard with OpenContent.

I once heard a business analyst who had the slightest understanding of Documentum say:

Diagnostics is like a heart monitor and tracing is like the Niagra Falls

I have to give him credit because for once, he said something that made partial sense.

If you want to see what’s really going on between your app and Documentum, diagnostics and tracing key.

1.  Diagnostics (Session/Collection Leaks):

Diagnostics == checking for session & collection leaks.

This is configured in two places:

1.  dfc.properties:  (TURNS IT ON)

dfc.diagnostics.resources.enable=true

2.  log4j.properties: (WHAT & WHERE)

NOTE:  this has changed from DFC5.x where the package was different and the logging level was DEBUG

log4j.logger.com.documentum.fc.client.impl.session=ERROR,SESS_LEAK_DETECT
log4j.appender.SESS_LEAK_DETECT=org.apache.log4j.RollingFileAppender
log4j.appender.SESS_LEAK_DETECT.File=/Users/kdomen/Desktop/sessLeakDetector.log
log4j.appender.SESS_LEAK_DETECT.Threshold=ERROR
log4j.appender.SESS_LEAK_DETECT.MaxFileSize=100MB
log4j.appender.SESS_LEAK_DETECT.MaxBackupIndex=5
log4j.appender.SESS_LEAK_DETECT.layout=org.apache.log4j.PatternLayout
log4j.appender.SESS_LEAK_DETECT.layout.ConversionPattern=%d{ABSOLUTE} [%t] %m%n

Example of Session Leak pointing back to code:

10:55:47,125 [Resource Housekeeper] [DFC_SESSION_NOT_RELEASED] Unreleased session found during garbage collection, Session{id=3, iid=3, serial=1, docbase=bnxdev2, user=KDOMEN}
com.documentum.fc.impl.util.ThrowableStack: Stack when session was obtained
at com.documentum.fc.client.DfClient$ClientImpl.newSession(DfClient.java:331)
at com.nike.bnx.session.SessionManager.createAdminSession(SessionManager.java:176)

2.  Tracing (Low-level DFC/RPC logging)

Tracing == monitoring the low-level API calls made in DFC.

1.  dfc.properties:

dfc.tracing.enable=true
dfc.tracing.include_rpcs=true
dfc.tracing.include_session_id=true
dfc.tracing.log.level=DEBUG
dfc.tracing.dir=/Users/kdomen/dev/tracing

Example:

100.827        0.003 <KDOMEN|s33(33.1)|SM@9968962>   [http-8080-Processor20] .RPC: fetchType(“nike_state”,10746) ==> LiteType@6c7069{name=nike_state, [http-...8080-Processor20] .RPC:

Platforms or Applications?

Solution Frameworks Combine the Best of Both

– By Steve Robins

A few weeks back I attended a discussion by Alan Treffler, CEO of Pegasystems at the Vilnu Shul in Boston.  Treffler described Pega’s decision to focus on frameworks atop their platform rather than applications.  Let’s take a deeper look at software platforms, frameworks, and applications.  

It’s almost a rite of passage for software companies… Sooner or later most software companies have to choose between offering platforms or applications.  The two paths are quite different… platforms require technical differentiation, a large partner ecosystem and broad applicability.  Apps require domain knowledge and specialization.  Innovative early adopter customers favor flexible platforms while risk-averse laggard customers often prefer apps with a short “last mile.”

Platform or app – which one approach is best?  For many companies, the answer is… neither.  These companies get the best of platforms and apps – using solution frameworks built on top of their platforms.  Solution frameworks are designed to speed development, deployment and integration, shortening time to ROI.

Solution Frameworks
Solution frameworks power a class of similar business processes or applications and include reusable, configurable components such as objects and Web services, templates, process templates, dashboards, best practices, interfaces, connectors, reference architectures and more.  Solution frameworks speed deployment and increase business agility.

Source: The Solution Marketing Blog

Just how long is that “last mile”? Many customers desire applications that require little “last mile” development and integration (see chart below).  The reality is that even mature software companies lack the in-depth process and vertical expertise to create as many applications as they’d like.  So solution frameworks can offer a great alternative.  Solution frameworks require less domain knowledge since they can be customized further by services partners with specific domain knowledge.  At the same time, frameworks speed deployment and add value because they “productize” components that would otherwise require custom development.

Click to enlarge

So which approach should you pursue? It all depends on a variety of factors including market maturity (which will vary by software, market, industry, department and/or use case), your company’s business model, your company’s technical capabilities and differentiation, your domain expertise, your company’s revenue trends (are you winning deals for specific use cases and/or in specific industries), your partner ecosystem, your customers’ requirements, and much more.

For a complete comparison between platforms, solutions and applications click to enlarge the chart below.

Click to enlarge

Now let’s take a look at a few companies that offer frameworks.

Pegasystems

Pega is a leading provider of BPM or business process management systems.  Like many others, Treffler’s company had to decide to focus on offering a platform or specific applications.

A few years back, Pega’s customers asked for packaged apps.  The company responded by building a new platform and applications, only to find that the apps required tremendous resources to develop, while limiting customers’ flexibility.  Treffler promptly shut down the app business, refocusing their strategy on a platform complemented by a series of solution frameworks built atop the platform.  The new offering continually adapts to the changing needs of organizations and users, increasing business agility.

By comparison, enterprise applications from the likes of Oracle and SAP may incorporate best practices from thousands of users – but at the cost of forcing users to conform to their rigid processes.  Pega offers a variety of different frameworks for assorted industries and business functions.  It appears that Pega’s industry- and function-oriented frameworks provide sufficient specificity without the rigidity of apps.

EMC Documentum

EMC Documentum provides enterprise content management and archiving.   Two years ago this month, while working at EMC, I created the positioning strategy for Documentum’s solutions and solution frameworks (check out the press release).  Since then, I’ve left EMC Documentum – but their strategy is worth noting.  EMC Documentum recently released their latest solution framework, the xCP Documentum Composition Platform.  According to Documentum, xCP speeds deployment of case management applications such as loan origination, grant administration and more.  Documentum’s xCP appears to be more generalized than Pega’s industry-specific frameworks.

So the choice is yours – which way will you go… platform, app or solution framework?  What do you think?  Share your experience and opinions below!

Further Reading

Platforms, Apps or Solutions?

We had an open-forum discussion on Document Control at the most recent Midwest Documentum User Group meeting. The discussion focused on feedback from various members of the group as well our experience over the years. We received positive feedback that the open discussion format, with multiple people participating, was insightful and are planning on using a similar format to discuss another topic at our next meeting.  Below is a list of topics covered with highlights from the discussion:

1. Document Properties – What are typical configurations  and when do people customize
2. Document Versioning – Rules around major and minor versions, when to delete
3. Document Lifecycle – Flexible lifecycle to handle published and draft versions
4. Security – Typical roles and responsibilities in Document Control
5. Search – Simplifying search – simple search  interface and consumer only viewing
6. Document Viewing – Various ways in which companies have applied “smart” document overlays
7. Change Request Package – CR data capture and relationship to change documents
8. Review – Assignment of reviewers and methods for capturing review information
9. Approval – Discussion on how to simplify approver selection and other common approval practices

The entire presentation is also available from the MWDUG website or feel free to contact me (btee@tsgrp.com) if you want more information on responses and comments received from the MWDUG participants .

Not really meant for production use - unless you pay for it!

I can see the flak coming from all the Alfresco lovers out there after I write this post. Alfresco is a great product. It has changed the enterprise content management landscape and sends shivers down the spines of many executives in the proprietary ECM firms. However, it is not really open source.

There are two versions of the product – Community Edition and Enterprise Edition. Alfresco claims that both are based on the same code. But, the significant difference is that only Enterprise Edition has bug fixes. From what I can see, bugs fixed in the Enterprise edition stay unfixed in Community. Alfresco is intentionally introducing instability in the Community version of the software so that people don’t end up using it in production environments. You can’t get the source code for Enterprise unless you pay for it. I can agree with their argument that unless people pay for Enterprise edition, they won’t get money to keep the company a viable business. Yes, that is what a company is in business for! What I disagree with though is the way the people at Alfresco advertise and market their product claiming it is completely open source. If it were, make the enterprise edition source code available to everyone.

You can have a viable business model where you make money on support agreements from companies that want to use the product for production. Just don’t twist everyones arm by putting the ominous statement on your community edition -> ” Supplied free of charge with no support, no certification, no maintenance, no warranty and no indemnity by Alfresco or its Certified Partners”. This is just not open source. It’s more like a trial version of commercial software.

It’s sad to see that people running Alfresco carried over the business practices of Documentum – over-market and under-deliver.

In the last month, I attended two Documentum User Group meetings.  They were very different experiences, beneficial in different ways.  The NY group was fun and was a chance to talk to lots of different users

I am going to do something slightly different this post, I’m going to focus on the positives. Let’s see how that works.

Razmik Grants a Vision of Documentum’s Future

The New York user group was simply awesome. That is not to say that it was perfect or the best I had ever attended.  What made it so good was the level of interaction of, get this, the USERS of Documentum. The presentations in NY weren’t bad either.

Razmik, the VP and CTO of the CMA Division of EMC (Documentum), gave the keynote.  It was very similar to the keynote delivered by Mark Lewis in Orlando, but the message was more evolved.  The important topic within the presentation was Master Content Management, what I have previously referred to Skynet.

The term isn’t as evil as it sounds, or at least, EMC isn’t to blame for it.  In the world of structured data, there is the concept of Master Data Management. MDM is the management of all data in an organization, even when the information is distributed in multiple systems.

Let’s translate this to content. Managing all content in an organization from one central location.  This can be done through a virtual repository or in a federated manor.  The point is that content is managed in-place from a central, controlling, application.

So how does this work? This is where CMIS comes into play. If you can talk to any repository without having to configure a connector or trying to determine the proper API, then you can act as the Master Content Repository.

This is assuming, of course, that the “in-place” repository has the capabilities to perform what is needed. Take eDiscovery. All these great tools for finding content, but what happens when you find something relevant? You have to place a Hold on it.  Well, not every system can support that, so you have to ingest the content into one that does. If the system can support Holds, you can just place a Hold on the content right then and there. Welcome to Skynet.

There are still some other problems to be worked out, like mapping the metadata between systems, and leveraging that through CMIS. It is a vision, and it is something that you can point at as a direction. Is it the right one? Time will tell.

After all of the presentations, there was an experts panel, that included Razmik. I just want to personally thank Razmik for participating. It was nice to see him try and answer every question without avoidance. He was a good sport and I think we all came away feeling a little better.

A Day in the Life of the DC User Group

The DC group is different. It is a user group that suffers from lower “user” participation.  There are no case studies and the expert panel consists of integrators.  To be fair, for many federal agencies, the Documentum expert is an integrator.  The result is that it feels more like an EMC event than a user group.

Of course, no dynamic presentations were given at the user group.  xCP was presented, but being the biggest push by EMC in recent months, very little new was presented.  I would direct you to Lee Smith’s post on xCP from Momentum Athens for insight as to what the future holds in that department.

On the plus side, I know just about everyone at the DC meeting.  It is usually a time to trade war stories and discuss our latest pains with Documentum. Still, I’d rather meet new people and hear about new solutions that people are implementing.

Remember, the user groups are only as good as the number users that attend and participate. So please support your local user group. I promise you will get something useful out of it.

Past blog posts have touted the flexible, extensible and configurable nature of TSG’s open source migration tool, OpenMigrate.  These claims are currently being put to the test.

TSG is in the final stages of a complex, cross-Atlantic migration utilizing OpenMigrate.  This project requires moving approximately 40,000 documents from a Qumas DocCompliance system in the Midwest to an existing Qumas DocCompliance system in Europe.  Qumas DocCompliance is a content management system which sits on top of Documentum and adds an additional layer of application specific objects.  As a result, an extra 300,000 plus supporting objects need to be migrated as part of the document migration.

Despite the added complexity of the Qumas system, minimal effort has been required to configure OpenMigrate for the migration.  Configurations were simply created for the documents and each of the 15 Qumas objects to be migrated.  The configurations utilize OpenMigrate’s customizable Listener classes, which can be inserted during any step of the migration to manipulate data as required.   Qumas objects rely heavily on attributes which point to other Qumas objects.  Through the use of a translating Listener, these attributes are updated to point to the new objects in the target repository and the application continues to function as required.  Using OpenMigrate’s multi-threading capabilities, test migrations have moved thousands of objects across the ocean in less than a minute, making the migration not only simple but fast as well.

For more information on OpenMigrate, please visit the TSG website.

While helping a client troubleshoot some FAST full text indexing issues with their Documentum 5.3sp6 environment, I came across some tools that proved to be helpful during the troubleshooting process.

I’m sure we’ve all encountered the scenario where a full text search takes a long time to return with results.  As a first step, it’s always helpful to query the FAST index directly, outside of any Documentum interface, such as Webtop. This way you can pinpoint if the slowness is being caused at the index level or at the application level.  Fortunately, FAST provides us with a search tool that we can use for this purpose.

The only thing you need to know in order to access the search tool is the installation base port number that was chosen upon installing Index Server in your Documentum environment.  Once you have that, the search tool can be accessed at the following URL:

http://<Index Server Host>:<Installation Base Port + 2100>

Example:

Installatation Base Port = 14000
URL to search interface = http://<Index Server Host>:16100

For the Query field, specify what value you want to search for and enter it in the following format, depending on whether you’re doing an attribute search or a search on content:

dmftmetadata:’search term’

or

dmftcontents:’search term’

or combine the two

dmftcontents:’search term’ and  dmftmetadata:’search term’

The search will result in an XML file that outlines the total number of documents that match those criteria and provides details on each document, as well as the total time it took to retrieve the results.

Other search keywords that can be used within the Query field can be found in the index-profile-dctm.xml file, stored in the following location:

$FASTSEARCH\index-profiles\index-profile-dctm.xml

The FAST admin tool can also be helpful to get a high level overview of how your indexing environment is operating.  We used it mainly to monitor how fast the number of documents in our collection was increasing, but there are several other functionalities available as well, as shown in the screen shot below:

The FAST admin tool can be accessed at the following URL:

http://<Index Server Host>:<Installation Base Port + 3000>

Example:

Installation Base Port = 14000
URL to admin interface = http://<Index Server Host>:17000

Please feel free to contact us if you have any additional questions about full-text indexing.

A few points to note:

• Use @Override whenever you override a method. Unrecognized typos (meaning no override!) are difficult to debug.
• Stateful aspects must have a name that follows Documentum type naming conventions.
• Do not use constructor logic – use onObjectReinit (after aspects are attached or detached) or init (after initial object loading).


import com.documentum.fc.client.*;
import com.documentum.fc.common.*;
import java.util.*;

Source:http://donr7n.wordpress.com/2008/07/07/an-aspect-implementation-template/

The first thing you need to understand is that the Java object you get from IDfSession.getObject or IDfSession.newObject is not the actual persistent object – it is a proxy object (google Java dynamic proxies for more info). It looks like a regular old persistent object to you, but it isn’t.

Whenever you attach (or detach) an aspect you might end up changing the prototype of the persistent object. This would be the case if an aspect implemented an orthogonal interface. DFC will actually rebuild the class files (yes, the byte code) that relates to the type [+aspects] in question. This is an expensive operation and there are optimizations to minimize the number of times this is done.

Of course, your existing persistent object is already loaded from the old class definition and this can’t change, so you end up with a “stale” persistent object reference.

So, after attaching or detaching an aspect you must refetch the object immediately. The refetched object will implement any new interfaces and will not implement any removed interfaces. Any unsaved changes you made will be preserved. The sequence should be something like this …


if (obj instanceof IDfAspects) {
    (IDfAspects) obj).attachAspect(“foo”, null);
    obj = session.getObject(obj.getObjectId());
    ((IFoo) obj).foo();
}


The above code fragment is suitable when you are a regular client (eg. application code). However, if you are executing in the context of a TBO or aspect method on obj itself when you try to attach or detach the aspect, then you are executing on the “old” object that is about to become stale, and the new object has not been built yet, so getObject just returns the same old disappointing Java object. You then have to use callbacks. Callbacks are invoked just before the original entry point to the outermost TBO or aspect method invocation returns and have a kind of implicit getObject associated with them. You can think of them as delayed client code. Do not do getObject within a callback – the object reference your callback is given is the new, beautiful, predictable Java object. The code sequence would then look something like this …


this.attach/detachAspect(“foo”, myCallback); // myCallback invokes foo()
// You cannot use foo here – the Java object is not ready. Refetch won’t help either.


The callback implementation would look something like this …


void doPostAttach/Detach(IDfPersistentObject obj) {
    ((IFoo) obj).foo(); // ok, obj is fully cooked here
}


Also note that not all objects can have aspects attached. All sysobjects and its subclasses can, but most non-sysobjects don’t support aspects. Any object that does, however, will implement the IDfAspects interface (DFC sees to this automatically). A non-sysobject type would only support aspects if it were created with the DQL syntax …


alter type ... allow aspects

Source:http://donr7n.wordpress.com/2008/07/07/attaching-and-detaching-aspects/

Sometimes you want to invoke DFS services from within a Java Method Server method implementation.

First you should understand how to implement a method as a BOF module.

What remains is to package your module correctly for DFS service invocation. In order to do this we suggest the following:

1. Create a sandboxed Java library containing the minimum classpath for your chosen DFS client, as described in the DFS SDK doc. This library can be included in all method modules that invoke DFS services.
2. Create a sandboxed Java library containing your generated client classes for each service that you consume. Each library can be included in all method modules that invoke the corresponding DFS service. If you only have one or two methods then these classes could be folded into your implementation jar instead.
3. Create an implementation jar for your method implementation.

Be sure that your method implementation observes the correct thread context class loader handling and you should be good to go. Here’s a little base class that takes care of that for you (note that this class must be in either your implementation jar or a sandboxed java library or it just won’t work).


package com.emc.examples;
import com.documentum.fc.client.DfSingleDocbaseModule;
import java.util.Map;
import java.io.PrintWriter;
public abstract class AbstractMethod extends DfSingleDocbaseModule implements IDfMethod
{
    public final int execute(Map parameters, PrintWriter writer) throws Exception {
        ClassLoader tccl = Thread.currentThread().getContextClassLoader();
        try {
            ClassLoader moduleLoader = AbstractMethod.class.getClassLoader();
            Thread.currentThread().setContextClassLoader(moduleLoader);
            return doMethod(parameters, writer);
        }
        finally {
            Thread.currentThread().setContextClassLoader(tccl);
        }
    }
    public abstract int doMethod(Map parameters, PrintWriter writer) throws Exception;
}

Source: http://donr7n.wordpress.com/category/methodserver/

We recently created a Healthcare application on Documentum Process Suite 6.5. We used the latest versions of Taskspace, Process Builder, Process Integrator, Process Engine, Business Activity Monitor, and the new Composer. Here’s my review of Process Suite D6.5…

As the former Group Product Manager for the Documentum Process Suite, I was pleased to see the improvements in the product. Of course, I was disappointed with some shortfalls on the quality of the BAM (formerly Proactivity) products, which until now, to my opinion, has not met the quality required by its customers and the industry.

My favorite addition to the package was the high-fidelity forms. For those who have used previous versions of the Documentum Forms Builder, I’m sure you have the scars to prove it.  The good news is, in Forms Builder D6.5, a lot of bugs have been finally fixed and works much better with the latest version of Taskspace. With the high-fidelity forms capability, Forms Builder is now a much better product. So if you’re wondering if you should attempt to use Forms Builder D6.5 or migrate your current Webtop to Taskspace with Forms, I strongly suggest you do it. You’ll be pleasantly surprised. What used to take us days & even weeks to develop on WDK with Webtop, only took minutes of configuration on Taskspace.

Just like any other software though, Taskspace D6.5 has its limitations. Some of which, I will attempt to discuss in this blog. So still expect to get some challenges if you do not know the pitfalls of this version.

With Taskspace, you can easily configure the search, folder view, file view, attribute display, and content image display components. In addition, Taskspace has a much better transactional perspective versus Webtop. Some of the limitations that you must be aware of is its lack of menu options. The fly-over menu options are very limited and do not really fit well in the overall usability perspective. As for the toolbar menu options…it does not exist. You’re better off customizing the folder and node structure to launch custom components. There is a built-in Adobe Reader, which automatically displays the content images. With the built-in viewer, you’ll be limited to viewing PDF and TIFF images only. All other content formats will be viewed using the application assigned to the document format, which is launched outside Taskspace. You do have the option to buy one of the supported viewers – Brava and Snowbound where you have additional features like annotations and viewing various content formats. For our healthcare application, we created a custom interface to support a shareware viewer for DICOM images.

One of my favorite feature with the high-fidelity form is the ability to use a paper form images as the interface for data entry and review. By using this high-fidelity feature, adaptability to the new application is improved. If you’re converting a paper-based application, you can use high-fidelity forms to have the exact image of your paper forms. This allows you to convert your paper-based system onto a mirrored system in a more efficient electronic application. Another cool feature with high fidelity forms is the ability to print it, use it offline and re-import (or scan) it using a built-in barcode to automatically categorize it. Per my experience, these features greatly reduces the total cost of ownership and accelerates your ROI on your investment.

The Process Builder now allows multiple entry points. For those who have tried Process Builder D6.5, you’ll notice that the Start activity template is still there. Unfortunately, even if you do not need it, it cannot be removed. It is a product bug, which I believe will eventually be fixed in the succeeding SP releases. The new builder also has the ability to group activities. This is a feature that you’ll see in other BPM products with Oracle and IBM. With D6.5, the builder also provides better error handling for integration problems such as connecting via Web Service. The queue management feature now has skill set capabilities. In the previous versions, skill level was available allowing you to set controls based on the user’s skill levels like beginner, intermediate, and professional levels. With skill sets, you have a better feature with matching skills against tasks. Configuring queue management needs a lot of work but the feature is extremely powerful.

Managing rules is still a limitation of the Documentum Process Suite. It supports rules engine products like Ilog (which is now owned by IBM), Corticon, and RulesMachine. There is the basic if-then-else capability and built-in policy configurations for managing queues, content, automated tasks, and people tasks. However, for handling complex rules (such as bank fees, loan rules, and insurance policies) with multiple permutations, you will need one of the rules engines.

As for the BAM products (which were an acquisition from Proactivity),  the new version has fixed a lot of bugs from the 5.3 versions. The 5.3 version was developed with a loosely-coupled design to help get the products integrated at the fastest possible time. Unfortunately, for those who attempted to use the 5.3 and D6 versions, you would (like me) have really deep cuts…some of which are still bleeding. The good news is, BAM D6.5 removed the need for the unreliable Jboss Portal, often failing Documentum publishing job, poorly designed Process Analyzer and report designer, the problematic Observation Point activity template. With the new version, the reports are viewable on Taskspace with an easier configuration tool that actually works. The reports can be easily be configured with the updated report builder and built-in Crystal Report. Unfortunately, the installation and configuration is still difficult, synchronization of transactions still fail and creation of custom business reports are still limited. Perhaps in the SP versions, most of these bugs are eventually fixed. The Process Analyzer, Simulator, and Navigator were not upgraded and do not really work in harmony to provide a complete Process Lifecycle model. Until then, do not expect much from Documentum BAM.

The biggest challenge you need to address though is to determine the type of business reports that makes sense for you. Chances are, most of your reports are often immature in design and are constantly refined using tools like Excel. This begs the question…what is the TOC and ROI of using BAM versus good old fashion Excel? I would love to hear your opinion… Perhaps, Documentum BAM can eventually address that challenge correctly.

As for my wish list, I would like to see Taskspace upgrade to a Web 2.0 interface, which is the direction CenterStage and DAM 6.5 have taken. I would also like to have Documentum workflow web services that can be integrated with other applications.

Source: Erwin Chiong http://bpmchat.com/2008/11/08/does-documentum-bpm-65-offer-anything-new/

Whitney introduced the keynote, reinforcing the theme of ‘Inspired by the past…Primed for the future’, before handing the reins to Mark Lewis.

Mark set the tone by reinforcing that the future is bright for EMC CM&A. He quoted an example of his personal experience of visiting a doctor and having to complete the same details multiple times. He then talked about Business Value, and the need and desire for EMC to drive Business Value. He then introduced the three pillars of the strategy for EMC CM&A:

- Value. Covered by Access and Process.

- Efficiency. Covered by Governance, Access and Process.

- Compliance. Covered by Governance and Access.

He also talked about a move from Application Centric to Information Centric, and a move from Static Placement to Dynamic Movement, see my earlier post on the Future of ECM to see my views on this.

Back to the earlier themes of Governance, Access and Process. Mark introduced these as the three main product groups in CM&A.

Governance

These are the products covering Archiving, EDRM and Search/eDiscovery.

Access

The theme of this group is having it your way and includes the stages of Capture, Communication, Collaboration, Context and Cloud.

Process

This is about building the custom solutions, interestingly Mark talked about Content Enabled Applications, note no Vertical in the title. This is where xCP fits in, Mark described it as the Case Process Platform. He claimed this is the first for the industry, I’m not sure this is true but it could be a major step forward for EMC.

Mark then handed over to John O’Melia who conducted an interview with the CIO of Eurobank, but the main chunk of the session was Mark’s message. Mark’s message was clear and the alignment of the products was clear. He showed a lot of belief in the future and especially in xCP, I left the session needing to find out more about how XCP was going to be executed.

I’m going to try and get through the backlogs of write ups which I have, starting with this session which was hosted by Victor Spivak on the Tuesday morning. Firstly I must criticise the scheduling, or rather room scheduling. Victor’s sessions are notorious for their high attendance so why put this on in one of the smaller rooms, there was no spare space!

Victor talked about the themes which drive the architecture, namely:

- SOA

- Performance/Scalability

Victor did say at the start that some of the session would be a repeat of last year’s, fortunately I did not attend that but I have looked at some of the details which Victor talked about.

On SOA Victor talked about the need to remove the chattiness of DFC and the addition of numerous new services for D6.5. REST will be supported post 6.5, possible 6.6 release in 2010. XML and JSON representations will be made available. EMC will not try and take sides in the SOAP vs REST debate and will support both.

CMIS was discussed and Victor talked about the disappointment of JSR170 and that being the reason behind the lack of Documentum support for it. He talked about the goals of CMIS, all publicly available, and how CMIS can be considered the Esperanto of the ECM world. However he did say that the current release is best served by the Use Case of a repository explorer without too much complex functionality.

He then talked about the Centerstage model and revealed that xCP 2.0 will be based on this, more to come on this in another post. However that is not the only client approach they will follow, note Mediaspace is Flex based. He also raised the interesting idea of using Spaces in Centerstage to support multi-tenancy in the cloud, I’ll have to check some details on this but could be interesting.

On Performance and Scalability, when I stopped being annoyed at the guy who was on his phone!, Victor talked about High Volume Services and the concept of batching citing the example of creating 100 objects in the docbase and the number of api calls this generates. This can be vastly reduced with the concept of batching. Victor also talked about the concept of Lightweight SysObjects.

Next up was the subject of search. Now I had heard from a colleague about Documentum Search Services and Victor talked about it briefly, he did point out the sessions which would cover the details. DSS will use the same Index Agent as the current Search solution but will use xDB. (I had heard from another session that this may complicate the install, I’ll need to check the notes on this one). EMC will not force customers to move away from FAST and will support DSS and FAST running side by side for the forseeable future.

Victor also talked about the 100k user benchmark and the impressive results this showed, he compared this with MOSS 2010 which allegedly will have a limit of 30m objects per repository; for my current project this would not see us through to the Olympics in 2012!

Finally Victor talked a little on Virtual Content Management, which is the use of Federated Records and then briefly talked about Operation Customisation. This is to cover situations where BOF would not apply and the example Victor quoted is when a user wants to import a zip file and then on import for the contents to be extracted to a folder. Another example is a Recycle Bin. Interestingly Victor suggested they would be interested to hear of scenarios which customers/partners would like covered off and they would look at these.

Overall then a good session, a lot of info was already available but then this was a 6.5 architecture. Victor is a good presenter who is clearly passionate about his subject area. As an intro to more detailed sessions this worked well, if only I had the time to get to the other sessions!

In the content management world, users often require an “all-in-one” interface to help them assemble batches of related documents, tag them with metadata , then import them into the underlying Content Management System.  Traditional web-based interfaces, such as Webtop or Web Publisher from Documentum, Explorer or Share from Alfresco, don’t offer this functionality out-of-the-box.

Could TSG’s OpenMigrate open source migration framework fit this need?

OpenMigrate is typically used in a batch mode, especially in high-volume situations.  And while the browser-based Administrator does allow for interactive configuration and execution of migrations, the actual tagging of documents with metadata is outside of its realm.

To bridge this divide, TSG is pleased to announce the availability of the new OpenMigrate Bulk Load Interface for download.

The OpenMigrate Bulk Load Interface provides a highly configurable user interface which enables the user to easily manage documents and import them into a variety of targets.  The interface is built on top of the Spring framework making it extremely easily maintainable, customizable, and configurable.

To learn more about this versatile new entry in the OpenMigrate toolset, please visit www.tsgrp.com.

Its Saturday night and everything is just about packed for the trip to Athens for EMC Momentum 2009. It will be a long today tomorrow to get there, leave the house at 8:45 and arrive in the hotel around 19:00, so hopefully the sessions will be worth it.

I’m going to attempt to write as many posts and tweets as possible in the next week, some posts will need to wait until the week after and some things will just get missed as I have a lot of things lined up in the next few days outside the actual sessions.

I’ll try and get notes up quickly in the day or so afterwards and then post something more reflective later on. I won’t be posting things which are told to me in confidence but will just comment on the public aspects of the conference.

Keep coming back for updates during the week and do not forget to visit me at twitter.com/leecsmith.

Last month, I ran into an error.  You know the type, vague, irritating, and an r_object_id that I didn’t recognize. (Okay, I never “recognize” an id given the complexity, but usually I can figure things out from the first two digits.)  The error basically said that the r_object_id “53…” did not exist.

Anyway, a quick look didn’t reveal anything. I determined that it wasn’t derived by dm_sysobject by doing a quick query on the table. I decided to throw the question out to Twitter and see what happened.

Okay fearless #Documentum hackers, what object type begins its r_object_id with a ‘53′?

I got two replies, one from Lee Dallas (@ldallasBMOC) and another from David Matheson (@davidfmatheson).

@piewords #Documentum 53 is dm_literal_expr – if you are asking-you need to run data dictionary publish,clear caches restart app svrs

@piewords #Documentum @ldallasBMOC beat me to it, I would add you can check IDfId for the full list of what’s what in any version of DFC.

So Lee gave me the fix, which had already been executed, but he told me why the restart of the client application worked. (The Data Dictionary runs regularly in our environment, so it had already run). David taught me how to answer the question in the future.  I also found another way to make the determination as well.  I’m going to share them both now.

The DFC Javadocs

This is where David sent me.  The Javadocs are simple enough to navigate.  Open up the Javadocs and select IDfId from the left-hand panel.  You will see a list of constants.  Click on any of them, DM_ACL is first, and it will take you to the definition.  It doesn’t give you the value here, but if you click that link for Constant Field Values, you will be taken to a table of values.

We aren’t done as there is one final step that David overlooked.  The constants are all base 10 decimals.  The two character object type tag is hexadecimal (base 16).  So if I convert my 53 from hexadecimal (using this nice little converter), I get 83.  When I search the table, I find dm_literal_expr, the very answer that Lee sent me.

If you ever need to reverse the process and work from the table (decimal) to the object type tag, you can use the reverse conversion (available from the same source) to get your hexadecimal value.

The Object Reference Manual

So a day or two later, I was looking something else up in the documentation.  I then noticed that the answer was staring me in my face.  I was looking in the Object Reference Manual that is part of the core Content Server documentation and there it was, Object type Tag: XX.

So rather than navigating the DFC Javadocs for the answer, I can open that manual and search on Object type tag: 53 and get my answer.  It is faster and now I have two options.

Extra Side Notes

A few random lessons/observations came about from this effort, so I wanted to share them.

1. It is impossible to learn everything in Documentum, so don’t even try. Just learn where everything is written down. I learned two new places while solving this problem.
2. I found all sorts of Documentum documentation online while looking for other items.  Not sure if it allowed to be up there, but it has been posted by James Azarja on Scribd.  The Object Reference Manual for 6.5 is up there as of this writing.
3. Twitter is pretty useful for getting some quick answers. It can be faster than the forums on EDN, though EDN is the perfect place for more detailed Q&A.
4. The error in question arose when a Composer project was installed.  Only one thing was updated in the project, but everything was version, even with no changes.  This may turn into a separate post on best practices around Composer (aside from using Application Builder instead).