Monday, October 27, 2008

Never send your Application out alone again

Anyone that reads my blog knows I was one of the founders of a company called Preemptive Solutions, Inc. Preemptive was my first startup and has a very been very successful in evolving its DashO and Dotfuscator product lines. Those products are near and dear to my heart as the initial incarnation of DashO was spawned from my Ph.D. dissertation work. People often now associate it as a Java Obfuscator, but to me that was largely an afterthought. Its a static analyzer of an interesting sort for Java. I had originally set out to write a Java bytecode optimizer, but I quickly realized that given Java's nature, you fall pretty flat on how and when you can do static analysis.

Java (and .NET) have very many dynamic components (the more you look, the more you tend to find). My dissertation ( was most interested in a scheme to identify closed systems inside of Java applications. Basically cordoning off open hooks into Java applications and not trying to optimize across them. In essence, it identifies sub-applications within Java and .Net applications and optimizes those one at a time.

This is all well and good, but its basically old news.

Whats new news is Preemptive's new product line. As Preemptive evolved those static analyzers, they got really really good at instrumenting code. In fact it became second nature. Preemptive's new product line takes advantage of this know-how.

They call it "Runtime Intelligence" - I call it fricking cool.

I explain it like this... In past decade application servers popped up to provide an application services cradle for which you to drop your business logic code into. Basically, you write a nice little piece of business logic, put it into an application server, and that server took care of all boilerplate details like database access, fault-tolerance, load-balancing, etc. Its a silly idea to think every website had to write code to handle these generic ideas.

The heyday of application servers isn't what it used to be as many discovered that they added a ton of overhead for applications that weren't using all those shiny services. In fact, new web or server frameworks pop up all the time to literally "part out" application server functionality. You used to ask someone their server infrastructure and they'd say "Weblogic" - now its not uncommon to hear "Spring, Hibernate, Struts2 and GWT".

Runtime Intelligence is sort of the inverse of the idea of an application server. Simply put, Runtime Intelligence allows you to "inject" prebuilt functionality modules into your application. So, does your super application need licensing? Does it need to update itself through patching? How about statistics on how people are using the product?

You got it.

Write your code like you planned to without worrying about "generic" functionality pieces and "inject" them later.

Whats more is that Microsoft has bought into this idea in a big way for .NET. Microsoft today announced a joint press release (See it here) with Preemptive at PDC about this product. If you're familiar with how Microsoft works, you know that joint press releases are pretty rare. Its clear to me that they "get it". This is big.

Preemptive's first round of injectable functionality is pretty slick too. Basically a statistical package for your application. Like web analytics, only for applications. Ever implement a feature and wonder how many people really use it? How about finding out that 33% of your customers never get past the 2nd page on your wizard (maybe its design is too confusing?) How about finding out that 68% of users tend to do 5 features in the same order everytime - and you could easily add a new feature that does that for them. Simply put - releasing an application into the wild unknown and "guessing" how users use it is a thing of the past.

Surely, this kind of application monitoring makes a lot of sense for certain types of applications (of course, its not right for every application just the same way other boilerplate functionality like licensing or patching would or wouldn't be). Either way, this opens up all new possibilities in development planning for applications. I expect plenty of meetings between sales teams and project managers discussing this data.

Some people have compared this to aspect oriented programming, but that's quite inaccurate once you look deeper. I've used both and aspects feel like a sledge hammer (and at least for the packages I've used, an annoying-to-configure one at that). Runtime intelligence is surgical (as far as I know, no one is doing feature stats with aspects). You write the code and inject real business boilerplate functionality anywhere and anyway you want.

As you can tell, I'm really excited about this - and I'm doubly excited that Microsoft is on board with it too. If you're going to PDC this week, definitely check these guys out.

Disclaimer: I have an unhealthy crush on this company. It has gone farther than I had ever imagined and I'm continually impressed of their accomplishments and future.