Archive for the ‘Software Development Lifecycle Management’ Category

« Older Entries

The Forward-Looking Development Organization

Thursday, May 3rd, 2012 by Gabriel Torok

I am giving the keynote at the VSLive conference this month in New York City titled the “Developer of the Future”. As we all know, the software development industry is constantly evolving. While it may be difficult to see those changes day to day, the effects are very apparent from year to year, and what makes a developer or development project successful certainly changes as a result. So, making predictions is always risky and prone to a notoriously low rate of success.

I could focus on the near term and state obvious trends — the demand for developers will not subside. Or, I could stretch far into the future (where no one can prove me wrong anyway) and talk about how “Software will eventually write Software.” Instead, I’m going try to find middle ground – take some risks with my predictions and make those predictions near enough that someone might actually hold me accountable in the coming years.

Applications that just a couple of years ago were available only on a single desktop platform are now available in the cloud or as apps that run on one or more phones/tablets. This trend clearly indicates where the software development market is heading — make the same application available on a multitude of platforms (desktop, phone, tablet, web, etc.). For developers, this means that a new type of expert will soon emerge. Let’s call him or her the “general expert”. The general expert will be valued over the many “narrow experts” that we have today. In the past, being a narrow expert in a single stack such as Windows or SQL Server was seen as a positive. Going forward though, developers will need to navigate across multiple languages and technology platforms to launch a single project.

Moving from the developer to the development team, teams will no longer be able to afford to produce big bang roll-outs and will need to reply upon continuous deployment workflows. Today, services already lack the familiar concept of a version number. What version of gmail are you using? It won’t be long before most applications will also lose their “version” identity. Users will simply expect to be running the latest version of whatever may be on (or connected) to their device. If you use Chrome today, I bet you don’t know what version you have – Chrome is already silently updating itself.

Customer expectations are higher than ever before and their attention spans are shorter. Developers that don’t have an understanding of what drives customer behavior, especially those who are trying to sell apps via marketplaces, will be at a huge disadvantage. Customers eat with their eyes; applications must be visually appealing and dead simple to use.

In any design project you’ll make some good decisions and some bad ones, but you won’t know for certain which is which until you find out from your customers. Rather than try to speak with all of your customers (they won’t always tell you the truth anyway), the use of Application Analytics or Telemetry will be an increasingly important aspect of the software development process. Applications should report back and make “actionable” the production incidents that cause unhappy users. They should also make generic usage information actionable as well (adhering to all privacy concerns of course) to allow for continual improvement based on real world usage and split testing. This is important whether you are building a mobile app, a desktop client application or a mission critical server application.

In summary, in addition to domain expertise, it is more important now than ever to have a broad understanding of platforms and technologies. Also, while understanding of technology is critical, knowledge of your customers, how they use your applications, and what’s important to them about the apps are just as critical. There’s no time like the present (don’t wait for the world to change around you). Get a head start by implementing feedback mechanisms inside your apps today, and make feedback driven development a reality, rather than a vision of what could be.

For more information on how PreEmptive Solutions is helping development today, see: http://www.preemptive.com/pa

Posted in Application Lifecycle Management, PreEmptive Analytics, Runtime Intelligence, Software Development Lifecycle Management | No Comments »

Track Application Usage Statistics for CodePlex Projects

Tuesday, May 11th, 2010 by Joe Kuemerle

Open source software thrives on feedback and participation. Without a good idea of what users want, projects easily become irrelevant. Knowing how many people are actively using your application, as well as which features they’re using (and which ones they’re not) provides significant feedback that helps to focus development, resulting in an improved application that meets the user’s needs.  With CodePlex’s integration of Runtime Intelligence features, project coordinators now have the ability to inject application analytics features into their releases.

Projects hosted on CodePlex can use either the free version of Dotfuscator (included in Visual Studio 2010) or the commercial edition to inject application analytics features into their binary distributions.  The application analytics automatically tracks how many times is run in the wild and the duration of those runs. This provides a measurement of application popularity beyond counting the number of downloads.  Basic system profile information, such as which operating systems and framework versions the application are run under, is gathered and reported on as well.  Additionally, feature usage within the application can be measured including the number of executions as well as their duration.  Total application runs per day statistics are available on the projects statistics page on CodePlex and detailed usage data is available from a link on the statistics page.

With the understanding that there can be privacy concerns, Runtime Intelligence instrumentation transmits no personally identifiable information.  It is also very easy to surface the built in Opt-In/Opt-Out functionality in the library and give individual application users the choice to participate in the program.

The individual usage data is aggregated and daily application usage is viewable on the projects statistics page as well as links to detailed reports of application and feature usage.

Instrumentation of applications compiled against .NET 2.0 and higher (including Silverlight 2, 3, and 4) is supported by Dotfuscator Community Edition.

Projects that use custom attributes to decorate their injection points are permitted to redistribute the PreEmptive.Attributes.dll library as part of their source code.  The library is only necessary for compilation of the application and references to it are stripped out during the instrumentation process, so it does not need to be included in binary distributions.  A signed downlevel version of the attributes library is available on the CodePlex Runtime Intelligence Integration project page (http://runtimeintelligence.codeplex.com/releases ) that can be used in any project targeting .NET 2.0 or higher.  This library is also allowed to be generally distributed with project source code.

Any project hosted on CodePlex can now take advantage of the deep knowledge into user activity that Runtime Intelligence Services provides by reviewing a sample walkthrough here and implementing this new feature into a future release.

Posted in Dotfuscator, Dotfuscator CE, Microsoft, Runtime Intelligence, Software Development Lifecycle Management, Uncategorized | No Comments »

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

Thursday, 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

Tags: , , , , , ,
Posted in Application Lifecycle Management, DashO, Dotfuscator, Dotfuscator CE, IT Operations Management, Microsoft, Opportunity (swOt), Runtime Intelligence, Software Development Lifecycle Management, Threat (swoT) | No Comments »

Back to the Future

Monday, August 17th, 2009 by Vadim Polner

Introduction

In this article, I will offer you a unique look at the rise of agile practices. You will see how core agile values of instant feedback and communication manifest themselves in different forms throughout history. You will see how Runtime Intelligence embodies the essence of agile software development, and how it helps software succeed.

The Age of Antiquity

Athens and Jerusalem! The rivalry between them resulted in major battles throughout history and spilled over to our times.

The book of Talmud, a magnificent compilation of biblical commentary and legal analysis, was put to writing in the ancient Babylonian academies of Sura and Pumbedita. Similar to Extreme Programmers of today, scholars worked in pairs, pouring over and discussing the meaning of incredibly difficult texts. To the Sages, the Text was the embodiment of the Master of the Universe Himself. It communicated to them in a very real and tangible way. Greek logic was an extremely useful tool, but not a solution to all of the world’s problems. In the dusty halls of ancient academies, the Sages perfected the art of close reading, reasoning by analogy, and pattern recognition.

The Greeks, on the other hand, perfected the art of logic, philosophy, and mathematics. The Universe could be a living organism to them, but it did not interfere with the lives of mere mortals. In the Greek mindset, the Universe did not actively communicate with us. The notions of theory, formalism, and proof - all made their way into our worldview through the Greeks.

The Age of Reason

Similar to the Greeks before them, the great men of the Enlightenment saw the world as a big mechanical device. The Universe functioned like a big clock, and human beings were like specks of dust in this gigantic mechanism. The world abided by a strict set of mathematical rules, and the future could be predicted if only all the variables were known.

The Age of Reason exerted its influence on software engineering as well. The field of program verification was consistent with its worldview. Programs were seen as mathematical structures whose correctness could be proven by analytical means without ever executing them. Program verification made great contributions to computer science, but it never replaced the empirical and intuitive approaches to software engineering.

The Age of Modernity

Our age witnessed the birth of quantum, chaos, and the Big Bang theories. The Universe is no longer a mechanical clock it used to be. All of a sudden, a human being becomes an active participant once again.

In modern software development, we see a shift from formal and theoretical approaches to people-oriented ones. Active participation and communication start running like golden threads through agile practices of today.

In the art of unit testing, for example, unit tests collaborate with you on several different levels. They communicate the intentions of your programs and allow you to concentrate on the implementation details later. Unit tests let you break the dependencies in your code and make your programs decoupled and cohesive. They provide you with an instant feedback about the overall health of your system. You can execute thousands of them and get a result within seconds or minutes. Unit tests give you the confidence you need when you try to adapt to changing requirements of the outside world.

In the age of modernity, your applications become active participants and communicators too. Enter Runtime Intelligence.

Runtime Intelligence and Agility

In the world of Runtime Intelligence, there are no theories to predict which features your customers will like. There are no formal proofs about your software usage. There are no surveys to figure out how your applications are used.

Similar to unit tests of the art of unit testing, your applications themselves communicate with you. Based on their instant feedback, you can quickly make important business decisions. You can see which features provide the most value for the money you spend, which features your customers rely on the most, and which features need further development. You can adapt much faster to the rapidly changing world around you. This is the essence of being agile.

Great ideas do not exist in an intellectual vacuum. They are often a reflection of their times. If we want our software to succeed, we must pay close attention to the lessons of history. As we embark on a journey back to the future, one thing is certain. Our past is behind us. Our future is still in our hands.

Posted in Runtime Intelligence, Software Development Lifecycle Management | No Comments »

Lower the Cost of Knowing

Monday, July 6th, 2009 by Gabriel Torok

Before tools like Survey Monkey were available, you could conduct surveys. But the cost was much higher, often including costs of envelope stuffing,  outbound and return postage, incentives such as a dollar in each envelope (to try to increase the response rate), data entry costs, and long time delays. Given the hassle and costs, you might be forgiven for making important decisions based on sparse data. In America, it’s called going with your gut. The rapid proliferation of low-cost web-based survey tools is a clear indication that lowering the “cost of knowing” stimulates organizations to “go find out.” In the past, companies did not survey as extensively because they felt they couldn’t afford the higher costs, and perhaps they did not value knowing enough to invest more.

Likewise, before point-of-sale systems were widely available, retailers were able to track customers and their buying habits, but at a very high cost and hassle factor. It was probably easier to “go with your gut”. Now, point-of-sale systems are a multi-billion dollar a year business and retailers are at an extreme disadvantage if they don’t use one.

A lower cost of knowing continues shifts in our desire and use of information. Developments such as nearly free international communication to practically ubiquitous Internet search have made knowing quick and easy. For example, today it is possible to very quickly discover which vendor has the best price and service. Improved information allows everyone to make better and faster decisions.

And yet today, many software producers still take a reactive “go with your gut” approach to understanding how their customers use their applications and measuring the satisfaction they receive from them. That is because historically, it’s been difficult and expensive to measure how users - individually or in aggregate - actually use applications. In other words, they perceive the cost of knowing as higher than the value of knowing.

This will change as new options significantly reduce the cost of knowing for software producers. In tighter economic times such as now, getting low cost, accurate and timely insight into software behavior, stability and performance will become essential. Successful software producers will benefit from the value of enhancing the customer’s experience by proactively understanding problems and opportunities and acting decisively based on their knowledge. What your customers aren’t telling you might be hurting you. After all, why would you rely only on your “gut” or a handful of customers for feedback when you can easily listen to your applications in a broad and precise way?

Tags: ,
Posted in Application Lifecycle Management, IT Operations Management, Runtime Intelligence, Software Development Lifecycle Management | No Comments »

« Older Entries