Cheap CEIP

February 8th, 2010 by Joe Kuemerle

Spring is (hopefully) just around the corner here in the northern hemisphere, with warming weather a young man’s fancy turns to that age old question…"what exactly are my users doing with my application?"

We’re familiar with big software vendors including Customer Experience Improvement Program (CEIP) features in their applications allowing them to gather anonymous usage data showing which features people are actually using. Analyzing that data allows them to focus their development efforts on what their users are actually doing, as well as obtaining hard measurements of how features are actually adopted in the wild. As someone whose paycheck depends on meeting the users’ requirements I really like to know how much of my time is being spent developing stuff that people actually want and use. Unfortunately, I don’t have the huge number of person-years and dollars to spend on something that is not directly related to my core application functionality to get a CEIP into my products.

CEIP Dialogs

Instrumenting an application to send its usage data back to the free Runtime Intelligence portal hosted by PreEmptive is covered in some previous blog posts (here and here ), but today I am covering a slightly different scenario. While there are great analytics capabilities in the hosted portal, my current needs are only basic usage tracking and that I must store the data at my own facility. As is normally the case in proof-of-concept situations, I have no budget, no time, and am highly visible to non-technical decision makers.

The first problem, no budget, is easily solved by using freely available tools. First, I am going to use Dotfuscator Community Edition 5.0, included in my copy of Visual Studio 2010, to perform injection of the application analytics functionality into my binaries. Since I need to store the usage data at my location I can’t use the hosted free endpoint and reporting portal, but I can use the new open source (Ms-RL license) Runtime Intelligence Endpoint Starter Kit (RI Starter Kit) to build my own application usage listener service, data repository, and basic reports.

Instrumentation via extended attributes in Dotfuscator UI

The fact that I have no time to implement this is also solved by my selection of tools. Since this is a proof-of-concept, I don’t need to create any extra code to obtain the users opt-in consent for tracking application usage. This means I can leverage Dotfuscator’s post compilation code injection model, similar to IL Weaving in Aspect Orientated Programming, to inject usage tracking directly into my test application binary without changing any source code or recompiling. In a matter of minutes I navigate through my applications structure and define the injection points from within the Dotfuscator user interface. To create a database using either SQL Express 2005 or higher or MySQL 5 or higher only takes a few minutes. Finally, setting up the WCF service project only requires updating the connection string in the web.config. Using the outstanding documentation included in the RI Starter Kit as my guide in less than an 30 minutes I have a proof of concept for tracking how often my application is run and which features the users are actually using.

Application analytics feature use report

Finally, I have to show something useful to the non-technical users. I know that application analytics data is being sent to my endpoint and stored in the database. I can easily run a few queries to get a feel for how the application is being used but not everyone is as comfortable with SQL as I am. As I review the source code included in the RI Starter Kit I see that there is also a SQL Server Reporting Services solution that contains two prewritten reports that show application and feature usage over time. A quick update of the data source, a deploy to the SSRS server, and now the business users have an easy way of seeing what our users like best about our products. To add application analytics data to executive dashboards, there’s also a SharePoint Web Part included so you can easily put an application usage graph directly into any SharePoint site (WSS 3.0 / MOSS 2007 or higher).

Application analytics SharePoint dashboard

All in all, I have spent around an hour and no money adding basic application usage tracking and analysis to an existing product and exposed that data to both technical and non-technical users. With only a small amount of code, I easily add an opt-in dialog to my product so my users can choose to send their usage data for analysis.  Now I have the start of my very own Customer Experience Improvement Program.

PreEmptive is always looking for feedback on our products, please take this new solution for a spin and leave us comments, feature requests and ideas on the project’s Codeplex page.

Dotfuscator 4.6.1200 Released

February 4th, 2010 by Joe Kuemerle

We just shipped the latest update to Dotfuscator, the 4.6.1200 version.  This is mostly a bugfix release but includes a small enhancement that supports using project properties in the ClickOnce package signing certificate path, allowing for better portability of project files between build environments.

There are a number of updates to fix small issues in packaging support, improve handling of mixed mode assemblies and address some issues with Visual Studio integration.

For a summary of the changes in Dotfuscator 4.6.1200 check out the change log here or subscribe to the change log in your RSS reader here .

This update is available to all customers who are current with their maintenance.  Download it here , give it a try, and let us know what you think.

Dev Connections 2009 Keynote Demo

November 12th, 2009 by Gabriel Torok

I was fortunate enough to be selected to demonstrate Runtime Intelligence in Dave Mendlen’s keynote at Dev Connections a few days ago. Everything was very well orchestrated and it was a fantastic experience. There were a couple thousand people in attendance and plenty of energy. When it was my turn I started by making two predictions:

That the audience would see an “easy way to use Visual Studio to allow your application to tell you how it being used in the field” – or a breakthrough that takes feedback driven development to an entirely new level.

And that a year from now these techniques will be familiar and some of them would be accustom to using this information to drive application development decisions.

I talked about how Dotfuscator continues to evolve and now includes Runtime Intelligence, the ability to instrument applications to gather real world runtime data.
And I showed them runtime intelligence information within the Visual Studio 2010 code editor and demonstrated it being used to make better decisions faster.

You can watch the entire presentation on our YouTube channel.

Dotfuscator 4.6.1000 Released (and other news)

November 9th, 2009 by Joe Kuemerle

It has been an extremely busy few months here at PreEmptive.  In addition to continuing the work for our inclusion in Visual Studio 2010, launching a new website , updating our product fulfillment, working on a PDC presentation , preparing for our spot in the TechEd EMEA 2009 keynote and other top secret stuff, the development team has turned out a huge major release of Dotfuscator.  The big news is there are some nice improvements; the bigger news is that Dotfuscator can now process an entire directory of files, a Silverlight XAP, or an entire ClickOnce application without requiring any manual steps of recreating XAPs or regenerating and resigning ClickOnce manifests.  We call this new functionality Packaging and we have even more plans for it in the future.

With Packaging, Dotfuscator is significantly more flexible and it’s much easier to have a fully integrated obfuscation/instrumentation process for Silverlight, ClickOnce, or a project with a fluctuating list of component assemblies.

This means we can gladly retire a few of our KnowledgeBase articles! Now, you can take the XAP file or ClickOnce deploy manifest that Visual Studio emits, include it as an input to Dotfuscator, and Dotfuscator will parse it and allow you to work with the all the contained assemblies in the user interface just as you would any other assembly.  When you build, Dotfuscator outputs a new XAP or full ClickOnce application (including updated and signed manifests). You have now just roundtripped a XAP or ClickOnce application through Dotfuscator with no additional outside steps required to rebuild your deployment artifacts.

Dotfuscator 4.6 Input Screenshot

In the above screenshot you can see a demonstration of the new Packaging support.  I have added a Silverlight XAP (SilverlightEuCountries.xap) and Dotfuscator shows the application library that will be processed as well as the System.Xml.Linq assembly, embedded manifest and the XML data file that will be included in the XAP file that Dotfuscator will output.  I have also added a ClickOnce application by selecting the deploy manifest (ClickOnceDemo.application) and we see that Dotfuscator will process the application assembly and include the icon file that was originally deployed with the application in the new deployment that Dotfuscator will output.  Finally I have added a directory wildcard (C:\temp\MedicalImage\MedicalImage\SourceCode\CSharp\bin\x86\Debug\*.*) as a third input.  The directory package will process the MedicalImage.exe application as well as it’s ContosoFunctions.dll library.  The the files listed in the Package Artifacts will be copied to the output directory so that the application config file and Microsoft Access database file are now included in the output from the build process.  I now do not have to invoke any post build file copy process in order to have a fully functional application and supporting files as the output from a Dotfuscator build. You can view short instructional videos on the See It Work page for Dotfuscator.

If that were all that was included in this release, it would be big news. But we’ve also added a new feature to our Runtime Intelligence instrumentation as well.  You have always been able to create extra data at runtime and send it back as a name/value dictionary embedded in your usage messages with the Extended Keys feature.  Now we have added a new property (“ExtendedKeyMethodArguments”) to all attributes that support extended keys. This tells Dotfuscator to inject code that gathers the names and values of the instrumented method’s arguments and send them as additional Extended Key data.  This means that if you are interested in exactly which values are being passed to your methods at runtime you no longer have to write additional code to gather and present the data as Extended Keys; you can specify that you want the names and values of all parameters or a subset of the parameters to be collected each time the method is invoked and included in any other Extended Key data that you may be sending back.  We also changed how some of our instrumentation works to provide a better experience for instrumenting add-ins for Office, Visual Studio, or any situation where your assembly may be hosted in a different process.

Since we stay on the bleeding edge our releases always include support for the very latest from Microsoft.  Dotfuscator 4.6.1000 is no exception.  We provide full integration with Visual Studio 2010 Beta 2 and support for .NET 4.0 applications, both obfuscation and instrumentation.

Since Visual Studio 2010 Beta 2 has a Go Live license we also provide a similar Go Live license for the Community Edition of Dotfuscator Software Services included in Visual Studio 2010.  This allows you to use the Runtime Intelligence instrumentation features included in Dotfuscator and to send usage data from your application to the free Runtime Intelligence portal which allows you to analyze your applications’ runtime environments and usage patterns.

Also included in this release are bug fixes and UI enhancements.  The best way to stay informed of any updates to Dotfuscator is to watch or subscribe to the changelog .  You can also follow us on Twitter for updates on what we are doing.

We have been working hard on this release and have much more in store for the future.  Please feel free to contact us at support@preemptive.com with any feedback or stop by and see us at TechEd EMEA , PDC 2009 or CodeMash 2010 .  Keep up with where we are going and interesting articles on our News & Events page.

With that I would like to congratulate the entire development team at PreEmptive for the extraordinary amount of work they have been doing and give a warning to Codemash that the entire development team from PreEmptive is going to be there in force this year.

How do I love thee? Let me count the ways.

August 20th, 2009 by Sebastian Holst

“How do I love thee? Let me count the ways. I love thee to the depth and breadth and height” - Sonnet 43, Elizabeth Barrett Browning

So “what’s love got to do with it?” (Private Dancer, Tina Turner) Hint: if people live for love, then businesses live for money

On July 14th, Microsoft announced Azure pricing and a “grace period” through PDC 2009. A primary rationale here is to enable development organizations to optimize deployment and monetization models to maximize Azure commercial opportunities.

So, whether you are a romantic (like Ms Browning above) or perhaps more hardened like Tina Turner’s Private Dancer (or Stanley Kubrick a la Full Metal Jacket), one thing is for sure - Microsoft wants Azure to “love you long time.” How deep, wide, high or long is the question.

Check out a this article in SD Times - PreEmptive’s Dotfuscator instruments Azure applications By David Worthington – where Dave Worthington makes many of the very same points.

Of course, we announced Runtime Intelligence Service (RIS) Azure support to help developers answer these very questions. While perhaps not as soaring as a sonnet – Runtime Intelligence allows for any .NET component deployed into Azure to be injected (post-build) with session, feature and method level monitoring. The runtime intelligence is streamed out of Azure for analysis. Other than writing a custom solution, this is perhaps the only means to measure adoption, usage patterns and performance inside Azure in near real-time.

Now, my posts are all intended to help you (blog followers) find more ways to make more money (we want to spread the love). So, you will note that I very specifically said the RIS helps to answer these questions. What the Azure development community really needs is an ROI calculator that will combine real usage data (from both legacy and piloted Azure applications) with Microsoft pricing and the offset IT expenses to come up with an Azure ROI calculator. I know there are lots of calculators being written – but how many of them can incorporate actual usage data before and after deployment to the cloud? That’s not our business – but could it be yours?

If yes, let me know and I will make sure you have what you need to call our RI Service via our RESTful API – making your calculator uniquely able to reliably predict cloud ROI.

As always, i have a more philosophical take on this issue on my personal blog at http://apps-are-people-too.blogspot.com/2009/08/how-do-i-love-thee-let-me-count-ways.html