Nope. We spend vast sums of money around the nation giving PCs to End users, and then even more vast sums of money training them on how to interact with the applications running on those PCs. Not only is the training and people cost associated with using these applications a large portion of all companies expenditure, but here in 2010, very little has ever been achieved in reducing this spend (at least without negatively impacting productivity or customer service).

Doesn’t that sound mad? Not really! Your TV is digital, right? Maybe connected over a fiber backbone down the street to a satellite receiving digital signals at light speed so you can watch live television, right? But equally, you are also probably using one or more plain jane AA battery powered remote controls where you teach yourself, your spouse and maybe your kids on how to change channels, set the volume, record, skip, play etc., All that awesome technology underneath and you are still forced into these manual steps. Sometimes perhaps even having to get out of your chair to turn the amplifier on manually!

So where am I going with this blog rant? The User Interface (UI) of course.

You see, no matter how much money we invest in technology, we have still not cracked making the UI any easier. Users spend weeks being trained to perform steps that the computer is perfectly capable of doing for them. Deficiencies in UI design across multiple applications prevent this though. Manual processes costs our businesses vast sums of money in what I call AWT (Average Wasted Time). Life sucks for the end user – big time – because the UI leads to so much wasted time, on every single desktop. You can’t blame the user for what the UI forces them to do – badly!

What if (drum rolls please), every application our users use, were written by the same programmer with the same goal; to simply enable those desktop apps to talk to each other so all manual steps could be eliminated. That would be nice… BUT… (sigh’s please)… considering most applications were written by different people, some many years ago even, you don’t see this ever being likely in your lifetime, do you?

But finally you will (trumpets please)… OpenSpan has perfected a technology which can get inside any application (without coding) and bring old and new applications alive so they can participate in being automated, for any of the tasks a user would perform manually in the past. Often said by early prospects “this is too good to be true” – OpenSpan is proud, not only to have close to 120,000 enterprise users using our desktop automation technology, but ALSO, changing the way software on the desktop (UI’s) are written. Game changing. It’s no wonder companies are saving $100’s of millions using OpenSpan. Automating people / processes = massive ROI -

Download it for free to try it here… If you think your user would benefit from one of many automations, just try it, and see if it works for you. Nothing to lose… Download Free OpenSpan IDE here.

I recently worked through a customer issue that revolved around a page that reloaded itself when a form was submitted. This is a pretty common scenario, but it can be a little tricky to handle in OpenSpan, especially if the reloaded page doesn’t actually create any new elements to wait upon. The trick is to wait for the Destroyed event to fire on the web page after you call the method that triggers the reload. This is pretty easy to do in an automation by using the “Wait for this event” feature.

First, drag the Destroyed event from the page onto the automation surface. Right click and select for “Wait for this event”. The event will now transform into an object you can wait for.

_{Selecting the “Wait for this event” command}

_{The right way to trigger the event.}

_{The wrong way to trigger the event.}

_{The complete solution.}

As you can see, waiting for an event is very easy in an automation, but how would you accomplish the same thing in code? You could spin your own eventing mechanism, but this would be a fair amount of work and require a good knowledge of threading. Fortunately there is another way to access the wait for event functionality. Every OpenSpan control supports a GetEvent method which takes a special EventName object. This method actually pre-dates the automation “Wait for this event” functionality. GetEvent takes a parameter of type EventName which is simply a wrapper around the name of the event. GetEvent returns an Event object which exposes a Wait method. Events objects are managed internally by the control so you do not have to worry about disposing the object. The following code snippet illustrates how to use GetEvent.

public void DoSearch(){ // Get event Event waitForDestroy = mSample.EventSamplePage.GetEvent(new EventName("Destroyed"));

 // Perform click mSample.Next.PerformClick();

 // Wait for event if (waitForDestroy.WaitForEvent(10000)) {  // Next steps } else {  // Handle error }}

Coming back from Oracle Collaboration 2010 show this week, it struck me what a difference having a product makes to our business. Talking to so many partners at this event, it is clear that the fact the OpenSpan technology is delivered as a product is key. That it can be installed in less than a minute enabling automation and integrations to be built with minimal training (online even), is a massive advantage.

On speaking with them, I found a large number had tried “competitive” products in the past but each time their business units got frustrated they had to build a complex services engagement around each deal that requires a lot of support once (and if) that customer went live. I pull out my laptop and show them a 3 minute demo and they get it – we are a true product! I can show them how to automate or integrate with an SAP activeX control grid in 10 seconds, or a Siebel app with embedded java applets or a custom windows app built over 10 years ago!  It’s so nice. I can even tell them where to go to download a free copy now. Now that’s “putting your money where you mouth is” IMHO :) I don’t know a single competitor that can do that!

I can tell these partners we have tons of live customers (that they can call for references), large and small that installed our “product” around or on top of competing products in the past (where our competitors failed to deliver before us, despite being in that account first).  One such customer brought 2000 seats back about 4 years ago. They have since added approximately 1000 more seats each year, and now at 6000 users. Another customer, sold to over 3 years ago, is now at over 20,000 live seats. Now that’s not just proof we work, but proof we stand the test of time in real accounts and use cases are being found all the time to keep building on the value.

For these partners, I can also tell them our product is also OEM’d or embedded into loads of other products as well. Like at IBM and Aspect. Sure these companies could have chosen to build their own solutions but we are good at what we do and can prove to our partners, we can deliver them what they need to help close deals with their customers. Again, tons of existing customers and partners that prove we can do it.

What a lot of people do not know when I joined OpenSpan, was that I told them, “unless you have a product, I am not interested in being involved”. I had seen too many so called products fail at customer sites by frustrating them on being oversold on ease of use. There is no silver bullet for integration but I think OpenSpan is one of the closest you’ll see. One example, I have seen a customer build a solution, installed into production, with 1 person in under 12 weeks and that solution saves that customer around $2m a month. I know it sounds unbelievable but before OpenSpan, they had no choice but to do everything manually. Another customer, looking at it another way, will save over $300m through automation over a 3 year period. Now that’s an ROI :)

We at OpenSpan are also not standing still. Each time we deliver, not only will our “PRODUCT” be better at saving you more $money, but it’ll get easier and easier to do each time.

As I mentioned in my last post, I’ve been working on a sample where I host OpenSpan adapters inside of a WPF Prism application. Here’s a screenshot that will help give you a sense of it.

When I started fleshing out the sample, I realized that WPF didn’t provide an object that implemented ISynchronizeInvoke that I could pass to the adapter Start method. As a little background, we added an overload to the Start method that takes an instance of ISynchronizeInvoke as a convenience for developers using adapters within windows forms applications. Normally, within the OpenSpan runtime, adapters fire asynchronous events on thread pool threads. Our automation surface abstracts the invocations required to interact with windows forms from visual developers.

When hosting adapters directly in .NET, we quickly realized that it was painful to force developers to invoke onto the windows forms thread anytime they needed to update their UI within an adapter event. Thus, we added an overload to the Start method where developers could pass in an instance of ISynchronizeInvoke. In practice, since all windows forms controls implement ISynchronizeInvoke, developers simply pass in their form or user control. When an adapter is started with an instance of ISynchronizeInvoke, it will automatically invoke all events onto the right thread.

However, the WPF Dispatcher object, which provides equivalent functionality to ISynchronizeInvoke, does not actually implement ISynchronizeInvoke. A quick search revealed that other folks had run into the same issue with WPF and created wrappers. However, looking over the wrappers, they weren’t entirely complete. It seems that nobody had implemented every method or property required. In particular I knew that our adapters depended on the EndInvoke method and the IAsyncResult.AsyncWaitHandle property.

To remedy this, I implemented my own wrapper. In addition to the public DispatchWrapper, I created a couple of nested private classes, DispatchOperationWrapper and DispatcherOperationWaitHandle, to hide the IAsyncResult and WaitHandle implementation details. Unlike some of the samples I found the implementation below doesn’t use any looping or sleeps to wait. Also note that the implementation for IAsyncResult.CompletedSynchronously always return false. This conforms to the IAsyncResult guidance on MSDN.

using System;using System.Threading;using System.Windows.Threading;

namespace OpenSpan.Samples{ public class DispatcherWrapper : ISynchronizeInvoke {  private Dispatcher _Dispatcher;

  public DispatcherWrapper(Dispatcher dispatcher)  {   _Dispatcher = dispatcher;  }

  #region ISynchronizeInvoke Members  public IAsyncResult BeginInvoke(Delegate method, object[] args)  {   DispatcherOperation op = _Dispatcher.BeginInvoke(method, args);   return new DispatcherOperationWrapper(op);  }

  public object EndInvoke(IAsyncResult result)  {   DispatcherOperationWrapper wrapper = result as DispatcherOperationWrapper;   if (wrapper != null)   {    wrapper.Operation.Wait();    return wrapper.Operation.Result;   }   throw new ArgumentException("Result does not wrap a DispatchOperation");  }

  public object Invoke(Delegate method, object[] args)  {   return _Dispatcher.Invoke(method, args);  }

  public bool InvokeRequired  {   get { return _Dispatcher.CheckAccess(); }  }

  #endregion

  private class DispatcherOperationWrapper : IAsyncResult  {   private DispatcherOperationWaitHandle _WaitHandle;   private DispatcherOperation _Operation;   private object _State;

   public DispatcherOperationWrapper(DispatcherOperation operation)   {    _Operation = operation;   }

   public DispatcherOperationWrapper(DispatcherOperation operation, object state)    : this(operation)   {    _State = state;   }

   public DispatcherOperation Operation   {    get    {     return _Operation;    }   }

   #region IAsyncResult Members   public object AsyncState   {    get { return _State; }   }

   public WaitHandle AsyncWaitHandle   {    get    {     if (_WaitHandle == null)     {      _WaitHandle = new DispatcherOperationWaitHandle(_Operation);     }     return _WaitHandle;    }   }

   public bool CompletedSynchronously   {    get { return false; }   }

   public bool IsCompleted   {    get { return (_Operation.Status == DispatcherOperationStatus.Completed); }   }   #endregion

   private class DispatcherOperationWaitHandle : WaitHandle   {    private DispatcherOperation _Operation;

    public DispatcherOperationWaitHandle(DispatcherOperation operation)    {     _Operation = operation;    }

    public override bool WaitOne()    {     DispatcherOperationStatus status = _Operation.Wait();     return (status == DispatcherOperationStatus.Completed);    }

    public override bool WaitOne(int milliseconds)    {     return this.WaitOne(new TimeSpan(0, 0, 0, 0, milliseconds));    }

    public override bool WaitOne(int milliseconds, bool exitContext)    {     return WaitOne(milliseconds);    }

    public override bool WaitOne(TimeSpan timeout)    {     DispatcherOperationStatus status = _Operation.Wait(timeout);     return (status == DispatcherOperationStatus.Completed);    }

    public override bool WaitOne(TimeSpan timeout, bool exitContext)    {     return this.WaitOne(timeout);    }   }  } }}

This past week I’ve been working on a sample illustrating how to host OpenSpan within WPF. Specifically, I’ve been working on using our re-parenting control to host external applications within the Prism application block from Microsoft.

For my first attempt at using the re-parenting control, I created a WPF user control with this XAML:

<UserControl x:Class="StockTraderRI.Modules.Research.GoogleFinanceView"    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"    xmlns:os="clr-namespace:OpenSpan.Controls.Reparenting.TabbedReparentContainer;assembly=OpenSpan.Controls"    Height="Auto" Width="Auto">    <DockPanel LastChildFill="True">        <TextBlock Text="{Binding TickerSymbol}" Style="{StaticResource CurrentSymbolTitle}" DockPanel.Dock="Top" />        <WindowsFormsHost Name="_WindowsFormsHost">            <os:TabbedReparentContainer Load="OnReparentContainerLoad" Disposed="OnReparentContainerDisposed" />        </WindowsFormsHost>    </DockPanel></UserControl>

As you can see I declaratively added the TabbedReparentContainer within the WindowsFormHost. In the load event handler I created and started the adapter:

private void OnReparentContainerLoad(object sender, EventArgs e){ _Google = new GoogleFinanceAdapter(); _Google.HomePage.Created += OnGoogleHomePageCreated; _Google.Start();}

The setup was very easy so I was feeling pretty confident until I ran the project and received this exception: “Unable to start message form.”

I was puzzled since I knew that the exception occurs when we cannot start the windows form we use internally for inter-process communication. What could be stopping us from starting the windows form? To find out, I downloaded the latest version of Reflector and started debugging. If you haven’t used it, the latest version of Reflector let’s you debug decompiled .NET assemblies within Visual Studio. With Reflector it was pretty easy to see that we were stuck in System.Windows.Forms.NativeWindow:

public virtual void CreateHandle(CreateParams cp){ System.Windows.Forms.IntSecurity.CreateAnyWindow.Demand(); if (((cp.Style & 0x40000000) != 0x40000000) || (cp.Parent == IntPtr.Zero)) {  System.Windows.Forms.IntSecurity.TopLevelWindow.Demand(); } lock (this) {  this.CheckReleased();  WindowClass class2 = WindowClass.Create(cp.ClassName, cp.ClassStyle);  lock (createWindowSyncObject) // <== STUCK  {   // ...  } }}

So there you have it. When .NET is creating a window on one thread, you cannot start another thread and create a window on it at the same time. I’m not really sure why this restriction exists as there isn’t anything inside of the lock that looks particularly unsafe. Nevertheless, because of this, you cannot start adapters synchronously within the Load event, at least in Beta 2.

I’m continuing to work on this sample and will keep posting other interesting things I find over the next few days.

Francis had an interesting post earlier this week: Not using OpenSpan? You could be losing millions. His basic premise is that if you’re not using OpenSpan, you’re losing millions of dollars. The funny thing is that he’s right. This isn’t just hyperbole. Our customers really do save millions of dollars. So why isn’t the world beating a path to our door? Simply put, it’s because the technology community thinks we are the “wrong” way of solving problems.

Are your users having to cut and paste and toggle between too many applications? An OpenSpan developer can develop a solution to that problem in minutes and deploy it in days. But the “right” way of solving that problem is to integrate the applications on the back-end and provide a new user interface. How long is that going to take? I bet it’s longer than a few days.

Are your users having to navigate between too many screens to complete a task? An OpenSpan developer can develop a solution to that problem in minute and deploy it in days. But the “right” way of solving that problem is to rewrite the application and provide a better user interface. How long is that going to take? I bet it’s longer than a few days.

I could keep going, but I think you get the picture. Of course, the real question is what is “right”? If “right” is defined as the most elegant solution that will be most extensible in the future, then OpenSpan is the wrong solution. If “right” is defined as the most cost-effective and rapid solution that will provide value to the business, then OpenSpan is the “right” solution.

Ultimately, the “right” answer it to do both. Solve the business problems in the short term with OpenSpan and in the long term with your strategic architecture. Most IT organizations have backlogs that contain thousands of feature requests. Usability issues, unless they are absolutely horrendous, almost always get pushed below strategic features. And with the resources available and the time alloted, that’s the right decision. Many of those big features will save hundreds of millions of dollars. While those pesky little features are only worth tens of millions of dollars.

But why waste those tens of millions of dollars when you could implement them quickly and cheaply with OpenSpan? Just today, we had a deal killed by a CTO who said, “Don’t worry about that, we’re reimplementing that application anyway. It’s a waste of money.” Really? It’s a waste of money to buy a product where the ROI is typically delivered in less than three months? Whose cost of ownership is a tenth of the savings it delivers? That enables a team of less than five developers to save a company millions?

I try not to criticize the organizations we sell to, but it’s incredible the narrow attitudes that prevail in our industry. Real agile practitioners know that you get the best results by delivering value rapidly. Every day, I tell my team to ask themselves “What’s the value of what I’m doing? Is there anyway I can deliver the same value better or faster?” Although agile is on the rise, it seems clear that the core principles behind agile have yet to filter up to the decision makers within organizations.

Here’s the bottom line: If you’re not using OpenSpan, you’re not delivering the value you should deliver. You’re wasting money and you’re hurting your business.

I couldn’t believe the response we have been seeing to the new download program. The fact that you can now be your own superstar and save your company $100,000’s or $Millions of dollars. Just by downloading our product, building some slick and quick automations in a few hours and see how much you can save – all without leaving your chair or spending a dime up front.  Some real use cases;

Back office Automation – Finance. Process 500% more transactions a day with the same people by automating the end users manual navigations between mainframe, spreadsheets and web (Java) applications. The savings quite literally are over $15m a year. 10 weeks to build/QA/Pilot and go live!

Back Office Automation – Finance. Processing times cut by over 90% for opening new accounts whilst assuring compliancy with ever changing rules. Implemented in weeks.

Call Center Automation – Finance. Call times cut by 28% for managing customer account queries spread over multiple systems. Automated Process Guidance implemented to ensure ease of workflows.

Call Center Automation – Telecoms. Automated almost entire Caller verification process spread over multiple systems. Saved over $30m on first project in first year alone through reduced AHT.

Call Center Automation – Insurance. Reduced time to update multiple systems from 35 minutes to under 10 minutes.

We have hundreds of automation examples like this, hundreds. We have customers who use us where they have just 1 desktop user using it (even zero users in unattended mode) and we have organizations where we are installed, in production on over 20,000 user desktops.

The point is, by downloading the OpenSpan product you don’t’ have to wait months before you see the benefits. OpenSpan is a true product. Download it, build something big or small and if it’s going to save you money, and lots of it, as it likely will, move it into production. Then, keep building and keep saving.

That’s what I mean about being a true product. We can save you a ton of money, and start saving it for you, right now. It costs nothing to try. www.openspan.com/community

You don’t even need to be a hard core developer, just have some basic “programatic” thinking skills and you’ll be automating in minutes with the OpenSpan Studio product! But if you are a hardcore developer, that’s OK too, you can run OpenSpan Plug-in for Visual Studio and write code, or mix and match between the visual workflow designer and your favorite programming language! You can choose.

After over a year of hard work, the next OpenSpan release is upon us. This morning we released the public beta of OpenSpan 4.5. For the first time, OpenSpan Studio will be free for anyone to download and evaluate.

For this release we rewrote our design environment to utilize Visual Studio Extensibility (VSX). OpenSpan Studio will now be available as both a Visual Studio 2008 plug-in and a stand-alone IDE. All OpenSpan developers will benefit from new features enabled by VSX such as source control integration, undo-redo and project references. However, we’re most excited by the new features we can offer .NET developers.

In 4.5, we have changed the output of OpenSpan projects to be .NET assemblies. At design-time, we still utilize XML documents to store the data, but we have added a build step that generates and compiles a class for the project and each project item (adapter, automation, etc.). The generated classes are identical to the classes utilized in OpenSpan automations. Anything you can do in OpenSpan automations you can now do with C#, VB or any .NET language.

So how do we anticipate people using this? Well, currently we have a number of customers who embed our functionality into new or existing windows forms or WPF applications they have created. Our new features will make this integration simple and seamless, enabling more complex integrations than ever before. In particular, with our re-parenting control, you can quickly and easily integrate web pages, terminal screens and Java applications into your composite application or mash-up not only visually, but functionally as well. Anytime you are creating a new .NET application, you should think about the benefits using OpenSpan can bring.

Needless to say this is a big step for us, one that has necessitated not just code changes but organizational changes as well. In order to support the needs of developers, we have introduced a new developer portal with forums and code samples and also a new incident-based support model. I hope you’ll check out the beta and give us feedback on the forums. To get started, check out the OpenSpan Community.