Content Copyright © 2010 Bloor. All Rights Reserved.
Also posted on: The Norfolk Punt
At one session of IBM’s Innovate 2010 software conference, Steve Mills (Senior Vice President and Group Executive, IBM Software) was asked about how IBM manages (and reduces) the cost of building its own software. The answer, he says, is “simply” reuse.
However, in my experience, lots of people try re-use and fail. I know of one bank which predicated the implementation of OO technology on the savings it would get from reusing objects. This never materialised, partly because a competitive, hero-based, dog-eat-dog culture made reusing other people’s work unpopular but also because the objects were never quite what someone else wanted and because having to rely on object names rather than functionality) no one could find objects to reuse.
How does IBM make it work? Well, according to Mills, by not providing any options—if delivery is time-boxed, reusing components (even if not completely ideal at first) becomes the only way to deliver on time and “make the grade”. The implication, of course, is that resources are made available for refactoring components for reuse and that developers are properly managed, by people with a vision. Otherwise you could get into dysfunctional “stress management”:
Manager: “how long will this take?”
Developer: “6 months”
Manager: “You can have 3”
Developer: “OK” [thinks: “I’ll cobble something together from XXX, it should last long enough to let me to move on before anything bad happens”].
There is no good idea that can’t be spoiled through mismanagement. And, as Mills says, managing reuse is a matter of the stick and the carrot, but the time to apply the stick is after you’ve got mass buy-in through use of the carrot.
Another innovative idea at Innovate 2010 is token-based flexible licensing although this is less innovative if you’re a Telelogic customer (it invented the idea, before the IBM takeover; but it’s good to see IBM developing it—it may even escape outside of the Rational brand). The idea of this is flexibility—you only pay for the features of your software that you actually use. Basically, the customer buys a certain number of token licenses. If you use a tool with token-based features, you can check out the appropriate number of tokens (possibly a different number for different features) and use that feature for a given number of users. When you no longer need so many people using that feature (when a project moves from analysis to coding, the mix of features needed will be different) the customer checks in the features they no longer need to license and uses the tokens freed up to license new features for different developers.
There are restrictions. This only works with with floating licenses. It cannot be used for node-locked licenses or licenses locked to a dongle. And I suspect that the devil might be in the detail when you try to make it work in practice in some organisations—but it has been successful from a customer point of view, for Telelogic; and anyway it doesn’t replace conventional licensing models if you don’t like it. I suspect that token licensing will be very useful—cost effective—for those people who really understand their development process.
So, what did I take away from these two conferences, PCTY and Innovate, in general (I’ll be reporting on specifics later)? Well, that there are still some issues: I’m not sure how well developers used to writing conventional applications will take to building “systems of systems” yet—there’ll be resources needed for mentoring this—and I’m also not yet sure how software eonometrics will work in the real world (we need metrics for business outcomes as well as for software development). However, Walker Royce (Vice President, Chief Software Economist, IBM SWG) was persuasive at the Executive Summit at Innovate 2010 and has published several interesting and very practical papers around “agility at scale” in the last several years (here, for example). I really get the impression that software development may be becoming part of the business now, that Systems Theory and Cybernetics may be coming back into fashion—and that we may be seeing the terminal rusting of those pesky silos at last!