Monitor the process not the machine

Every application logs a varying amount of information about what occurs when users or other systems interact with it. These logs are sent to a database or a file location - it doesn't really matter which because what you end up with is a silo of data that means nothing unless correlated and placed in the context of an overall business process. With most users interacting with anywhere between 5 and 15 applications daily, you'll have a similar number of these silos - all containing different pieces of data, which don't tell the full story.

So why not just have this information stored in the same place and correlated to give you a single process based view? Well, most software products deployed to collect desktop events only look at operating system messages. These types of events are only good at showing you what applications are running and perhaps how people are using the clipboard to transfer data. What it doesn't give you is the context of each application, such as which customer record the user is looking at in the CRM system, what fields they are changing, which field they just copied and pasted etc. Without this information you're logging data that really isn't showing the context of your business process - so why bother at all.

With the launch of OpenSpan Events, a passive monitoring platform with a simple upgrade path to full automation capabilities, you now have the ability to monitor exactly what is happening within every application. You don't even have to alter your existing applications - OpenSpan runs in process and looks at events that are fired down to individual objects such as Text Boxes, Buttons etc. Events can be generated automatically (generic events) or at specific times within an overall process (custom events) - both types sending the contextual information about the event to a central place on your network.

Events are configured centrally via the OpenSpan Studio visual development environment, with the next release adding support for building everything within MS Visual Studio. Projects are deployed to user desktops in a rapid and secure fashion - with remote configuration capabilities and integration to Active Directory, you have complete control over your infrastructure.

Client machines publish events from the desktop using a publisher defined in the OpenSpan Studio. This controls how information is transmitted and where it's stored. The default setup allows you to publish events via message queues (MSMQ, IBM MQ, Tibco, WebMethods, WebLogic), to a file or via SOAP. The publishers are pluggable mechanisms, so it's possible to push events in any format to any existing system you may already have in place - so events can be easily communicated directly to leading BPMS, BAM and BI tools.

Visibility of the collected events is possible from the tool of your choice - the default setup has OpenSpan Events push data to our Events Collection Server where the data is written to a database (MS SQL or Oracle). The database is customised automatically based upon the event data being collected and is configured via the OpenSpan Studio environment. The schema of the database is well documented and can easily be used by any reporting tools on the market to visualise the status of your process.

For more information please visit www.openspan.com or email sales@openspan.com

Understand the process

From time to time people will ask me what's the most important thing to get right before you start down the path of automating a process (or part thereof). I've finally decided that actually the best thing you can arm yourself with is knowledge of the existing process.

Isn't that so obvious? Well it maybe to most people but why is it that time and time again projects are started and in some cases finished, without first of all understanding where the problems are in the initial process. How can you fix something when you don't know where it's broken? The answer is you can't and that's why you find these projects either fail or you end up with massive delays as you're forced to go back and understand the initial problems.

With a platform like OpenSpan, it's possible to rapidly prototype a solution and run it past the business within what could be a matter of hours. This approach helps to show the business users what they'll actually receive once the project goes live and keeps your timelines as short as possible. Francis Carden refers to this as failing faster and I tend to agree with him - it's a nice way to learn what works and what doesn't.

I always tell customers that I want to see the process in action. Show me how you do it today, let me watch the manual task, let me understand the pain. More often that not, with this knowledge we can make tweaks to the process very quickly that will have a massive impact when it becomes automated. This initial work doesn't even have to take up a lot of time - I find that with the small processes we automate, this work can be completed anywhere between 1-4 days (including documentation).

Another obvious point to make that just about everybody fails on, is ensuring you are using like for like systems across your environments. So many projects are delayed by environments being different between development, test and production. These differences are picked up earlier in the development cycle if you've seen how the process is completed the "manual" way and it's documented step by step (including screen shots).

OpenSpan has recently launched the OpenSpan Events product which allows you to monitor generic and custom events from virtually any application. This product can help you understand the current process by monitoring exactly what users do within each application and logging it to a central place. Analysis of this data will give you a good understanding of the problems with the process, for example it's possible to see when a user cuts and pastes the same piece of data across different applications. You could even use OpenSpan Events to check that the systems are the same between your different environments by having it log version numbers as users interact with the applications.

One of the major benefits of using the OpenSpan platform is to decrease the time it takes to integrate your applications and automate your processes. With a typical project lasting around 5 weeks from start to finish, if you're not prepared to start this rapid development approach you'll see project times extended and you'll loose some of the benefits we bring to the table.

Trial

We've just announced a new way to try out the OpenSpan software using a cloud based service from Amazon. You can register here and you'll be given a machine in the cloud that is preconfigured with a the OpenSpan platform and a set of tutorials and finished solutions.

It's a simple, easy way to try our award winning software. Try it for free for 30 days at http://www.openspan.com/Members/TrialIndex.php

How quickly can you integrate to Salesforce.com?

OpenSpan has built a component that will allow you to integrate to Salesforce in under 5 minutes without writing a single line of code! That's a big difference compared to the "normal" integration path people take - starting your IDE, creating an empty project, configuring which libraries are required takes at least 5 minutes, then you've got to integrate the API in to your existing applications.

At OpenSpan we've created a component that wraps the web services API provided by Salesforce.com. This means that you can now integrate your existing applications in to the market leading cloud based CRM system, with only a few clicks.

The main data object is configured with the User ID and Password (which is encrypted) of your Salesforce.com API login - these can be statically assigned or dynamically added at runtime.

After assigning your credentials it's simply a matter of picking the data table you wish to interact with from the drop down list. You have access to all the standard data tables as well as any custom ones that you may have configured in your Salesforce setup. Now your ready to query the data held in the table - this is done using the Salesforce.com query language which is very similar to SQL.

The data object has a number helper methods to add a record, update a record, delete a record or simply select one. By dragging one of these methods on to an automation you will have access to your Salesforce.com data. The returned data object can also be pushed directly in to a data table for easy of integration in to a Windows form application control such as a DataGrid.

As well as this, there are is another component called GetRecords which can used to build a query visually, without having to understand the Salesforce.com query language. This component is built dynamically based upon the data table and the schema held within Salesforce.com, so not only does it work with the standard schema it also matches your schema!

In summary, OpenSpan provides a simple to use drag and drop interface that allows you to integrate virtually any application without writing any code. The platform is extensible and allows components to be added to the toolbox simply by using the IComponent interface to wrap any API, as explained in this post using Salesforce.com as an example. For more information and to try OpenSpan and our Salesforce components, you can register for a trial instance on our website here

Where should I put my desktop?

It may sound like an odd question but in reality you don't need to have your desktop on the machine that's physically in front of you anymore. The cloud based desktop has arrived or has it?

As the idea of the "cloud" expands, having your desktop hosted in a data centre comes closer to reality. In fact there is already a few service offerings available today, that will allow me to host any number of machines at the flick of a switch, for next to nothing. EC2 is the name of such a service that is part of the Amazon Web Services umbrella.

It allows you to switch on and off machines, using images you've created, so that they have all your required applications installed and ready to go. You have access to persistent storage, that's backed up and distributed across multiple sites and you no longer need to worry about your machine becoming unstable because every time you boot it up it launches from the base image.

If you need to make changes to the base image, for example you need to install a new product or update an existing application, you can overwrite the base image or better still just create a new image. This way if the platform becomes unstable, you simple stop the instance and start using the old image and you've rolled back any changes - perfect!

But best of all this machine can change it's hardware profile depending on the task at hand. If you're doing some video editing and need lots of memory/CPU then you can boot the image on a higher spec machine. For day to day use, you may just use the smaller hardware profile and the beauty of it is you only pay for what you use.

At the end of the day, I switch the virtual machine off and I stop paying for it. It's very similar to a using a hire car when they limit your milage. You don't pay while the car is stopped, likewise you don't pay for hosting a machine that's not running (except for a small disk usage charge but this is really tiny).

The uses for this are endless - to the extent that you could consider using this as a method of hosting multiple clients development environments. Build the base image, launch the number of instances required (one for each developer) and you're done - an instant place to being work.

Go and check out Amazon for more information as well as IBM, Microsoft and Salesfore.com - they all offer similar services.

Connecting Windows Applications to the iPhone

How do you connect a closed Windows application to a killer device such as the iPhone? Most would normally expect to have to alter the existing application adding APIs or even worse be forced down an upgrade path which costs 10 times more than you have available and takes 18 months to rollout.

With the launch of the OpenSpan Virtual Broker, you can now add Web Service wrappers to virtually any application and host them in a virtual (or physical if you like) environment. These services can then be accessed from anywhere, such as your portal environment (for customer self service) or directly from your other internal applications, even those hosted on a mobile device like the iPhone.

It's a simple drag and drop process to build a set of automations that integration my application(s) and then with the click of a button I can expose this functionality as a Web Service for any client to integrate.

Here at OpenSpan, we've just built a simple iPhone applications which calls a hosted service that allows a user to look-up contact information contained within a Windows fat client CRM system. If we'd wanted to create an API it would have involved getting the CRM vendor to upgrade our application, costing massive amounts and no doubt taking an age to be delivered.

This set of automations were built inside 1 day with the iPhone application taking a similar amount of time to put together - compared with a traditional approach - which one would you pick in today's market?

The iPhone application will be available soon in the App Store - I'll send out a link once it's live. In the meantime, if you want to be able to extend the life of those mission critical Windows applications, give OpenSpan a call.