Developer's Toolkit

Blog archive

A New Approach to Application Integration

I'm sure we've all heard that line before. Redmond magazine Editor Ed Scannell and I got a briefing from a company called OpenScan (www.openspan.com) last week that touted just such a claim. The announcement accompanying the briefing was under embargo until today (yes, sometimes we still get pre-briefings), so I decided to wait until today to even post a description of what the company is doing. When I worked at Compuware's NuMega Lab, one of our most successful products (BoundsChecker) injected debugging code into the memory space of a running process (and yes, that is also what a virus does). This code identified traced code execution and determined the values contained in variables, among other things. The important thing was that it could see many things that weren't being exposed by the application.

OpenSpan also injects code into the memory space of a running process, but to identify objects (a term, I believe, used loosely rather than strictly) and interfaces to those objects. OpenSpan CEO Francis Carden referred to those interfaces as APIs, but that is rather a misnomer. Because processes have different characteristics across platforms, the limitation here is that the process had to be running on a Windows box. You explicitly don't need source code.

Now here is the amazing part. Using an IDE called OpenSpan Studio, you could wire together those objects, without programming, so that they exchanged data. Carden demonstrated this by hooking the ubiquitous Windows calculator to an IE session displaying Google. By typing a number in the calculator, he sent that number as a search request to Google, which returned the results in the browser. Were it an appropriate UI for search results, he could have returned those results to the calculator display.

Way cool. I'll be writing more on this in the future for Redmond magazine (redmondmag.com) and Redmond Developer News (reddevnews.com).

Posted by Peter Varhol on 04/23/2007 at 1:15 PM


comments powered by Disqus

Featured

  • Purple Blue Nebula Graphic

    How to Compute Disorder for Machine Learning Decision Trees Using C#

    Using a decision tree classifier from a machine learning library is often awkward because it usually must be customized and library decision trees have many complex supporting functions, says resident data scientist Dr. James McCaffrey, so when he needs a decision tree classifier, he always creates one from scratch. Here's how.

  • Blazor's Future: gRPC Is Key

    Blazor guru Steve Sanderson detailed what Microsoft is thinking about the future of the revolutionary project that enables .NET-based web development using C# instead of JavaScript, explaining how gRPC is key, along with a new way of testing and a scheme for installable desktop apps.

  • Don't Do It All Yourself: Exploiting gRPC Well Known Types in .NET Core

    If you're creating business services that send dates and decimal data then you may be concerned that gRPC services don't support the relevant data types. Don't Panic! There are solutions. Here's how to use them.

  • Sign

    Microsoft Points Blazor to Native Mobile Apps

    Blazor, the red-hot Microsoft project that lets .NET developers use C# for web development instead of JavaScript, is now being pointed toward the mobile realm, targeting native iOS and Android apps.

  • Circl

    Implementing State in .NET Core gRPC Messages with oneof

    In the real world, you've been dealing with the State pattern every time you designed a set of database tables. The Protocol Buffers specification lets you do the same thing when you define the messages you send and receive from your gRPC Web Service.

.NET Insight

Sign up for our newsletter.

Terms and Privacy Policy consent

I agree to this site's Privacy Policy.

Upcoming Events