OpenSpan: mashing up your legacy applications

Want to mashup your legacy applications? I recently had a chance for some background and a demo of OpenSpan, which is one of the tools that you can consider for bringing those legacy apps into the modern age of composite applications.

A big problem with the existing user environment is that it has multiple disparate applications — Windows, legacy, web, whatever — that operate as non-integrated functional silos. This requires re-keying of data between applications, or copy and paste if the user is particularly sophisticated. I see this all the time with my clients, and this is one of the areas that I’m constantly working with them to find improvements through reducing double keying.

In OpenSpan Studio, the visual design environment, you add a Windows (including terminal emulator or even DOS window) or web application that you want to integrate, then use the interrogation tool to individually interrogate each individual Windows object (e.g., button) or web page object (e.g., text box, hyperlink) to automatically create interfaces to those objects: a very sophisticated form of screen-scraping, if you will. However, you can also capture the events that occur with those objects, such as a button being clicked, and cause that to invoke actions or transfer data to other objects in other applications. Even bookmarks in MS-Word documents show up as entry/access points in the Studio environment.

In a couple of minutes, they built and executed a simple example using the Windows calculator and the Google home page: whenever you hit the M+ button in Calculator, it transferred the contents of the calculator to Google and execute a search on it. This is more than the simple pushing of buttons that you typically find in old-style screen-scraping however; it actually hooks the message queue of the application to allow it to intercept any UI event, which means that other events in other applications can be triggered based on any detected event in the interrogated application: effectively allowing you to extend the functionality of an existing application without changing it.

A more complex example showed interrogating the FedEx website rate to bring results back to Excel, or to bring them back and compare with UPS rates in a custom UI form that was built right in the Studio environment as well. You don’t have to build a UI in their environment: you can use Visual Studio or some other application builder instead, or build .Net controls in another environment and consume them in the OpenSpan Studio (which is a .Net environment).

As you would expect from an integration environment, it can also introspect and integrate any web service based on the WSDL, but it can also encapsulate any solution that you create within OpenSpan and expose it as a service, albeit running on the local desktop: a very cool way to service-enable legacy applications. That means that you can make “web” service wrappers around green-screen or legacy Windows applications, exposing them through a SOAP interface, allowing them to be called from any development/mashup environment.

The integrations and applications defined in Studio are saved to an XML file, which is consumed by the lightweight runtime environment, OpenSpan Integrator; it can launch any applications as required or on startup, and manage the integration between them (which was created in Studio). You can use this to do single sign-on — although not in as secure a fashion as dedicated SSO applications — and can even call services between native desktop applications and virtual environments (e.g., a client service within Citrix). Although the Integrator needs to be running in order to access the integrations via SOAP calls, it can run completely in stealth mode, allowing other applications to call it as if it were a true web service.

You can also integrate databases, which allows you to make database calls based on what’s happening on the screen in order to create analytics that never existed before. As with all other aspects of the integration, these are based only on events that happen in the user interface, but that still has the potential to give you a lot more than what you might have now in your legacy applications.