BigLever’s recent introduction of the Gears PLE (Product Line Engineering) Lifecycle Framework and PLE Methodology – adding to its long-time BigLever Software Gears offering for product-development management – is as important, I believe, for its potential ability to foster the “agile” products of the future as for its immediate benefit in extending product management to multiple inter-related product lines. BigLever ably describes its offering’s immediate benefits to present customers. I’d like to dwell here on the broader implications of its new capabilities in evolving software development to support not only agile development but also agile solutions.
What do I mean by an agile product/solution? I mean one that is exceptionally and quickly customizable (not just modifiable as the product evolves) at all points in the product/solution lifecycle, both before and after its delivery to the customer. In other words, agile development allows you to change as customer needs change right up to the point of delivery, and then iterate in the next product development lifecycle; agile products allow you to create product lines of multiple related products in which somewhere in the welter of choices is the right version for a “customer of one”, and that customer of one is a large company that needs multiple versions for multiple customers inside the firm.
I would argue that this is an inevitable outcome of today’s trends in software-infused products and product lines. The marketing approach that seeks to leverage one successful product in related areas is now reflected in software-containing products that share a great deal of features, whether the results are presented to the outside world as one product line or several. Increasingly, a marketing and Big-Data focus on customer individuality, and customers’ desire to achieve greater usefulness via customization after solution receipt, makes customization both before and after the sale more and more frequent. I would also assert that most of today’s software development tools assume the old reality of one linear product development lifecycle. Yes, programmers and code are shared across related projects; but across multiple product lines, less so.
Step 1: BigLever PLE and Cross-Product-Line Customization
Again from my point of view, the BigLever offering simply takes a project management/product-lifecycle-management framework and infuses it with the notion that multiple related products and product lines are involved. That’s not as simple as it sounds; for example, doing change management on multiple related development streams is more complicated than doing branching of code versions in a single stream. In any case, the BigLever software predefines a set of “variable” building blocks that represent features, and runs through a checklist for a particular version that determines which customer gets which feature set on which customization of which product – and allows for further post-production customization by the customer.
The rest is details, but important ones. There is a traceability mechanism, a “product configurator”, a “tiered” Methodology (supporting products, product lines, and muitiple-product-line “portfolios”) and the ability to store code sets representing customizable features – a characteristic that effectively creates for the developer a base of industry- and firm-specific software from which he or she can semi-automatically populate a product line.
And it is this last detail that especially excites me, and leads me to talk about agile products.
The Other Shoe: Automated Development With Embedded Customization
It seems to me that the ability to store a “code data store” of feature variations across products and product lines is much like the ability to create a library of object classes: It forms a natural basis for rapid, flexible development. Granted, Gears is focused on managing development across multiple projects, not on creating code itself. Still, taking that code data store and using it to semi-automatically generate new software based on the old is an obvious next step for somebody. And that new software retains the flexible customization of the previous version of a product, product line, or product “portfolio”, baked in, as it were.
Consider such an approach when wedded to agile development. Techniques such as refactoring already ensure that it is exceptionally easy to modify software as you develop it, as needed. Building blocks with customization built in allow not just modification, but also variation/customization to fine-tune for the customer of one. Together, they maximize the agile developer’s ability to go in any direction needed at any time.
That’s why I call the result an agile product, not a flexible one. The distinction between flexibility and agility is key to getting an agile approach’s true benefits. Flexibility can simply cement a sub-optimal solution in place, rather than encouraging major changes as customer needs change. Agility, instead, encourages incremental adjustment that eventually add up to major new functionality, well adapted to the customer. The combination of development agility in modifying existing software, and the kind of customization agility resulting from semi-automated development using building blocks with embedded customization, makes both the process and the result (the product) more agile.
Bottom Line: The BigLever Approach is Worth Incorporating
Let me be clear: BigLever does not force any approach on you. Its Gears solution has a long tradition of working with development toolsets of all stripes. It is my own view that it or a similar solution will in the long run pay off best when paired with agile development. And, of course, the details of the merger of the two have yet to be fully worked out.
Still, given the promise of the BigLever PLE approach, it seems reasonable to me that medium-to-large IT organizations with an array of software development needs that approximate “multiple related product lines” should at least take a close look at the new BigLever offering. Savvy implementers might well go further, and begin to amass a “war chest” of feature customizations for later use in automated development. In either case, the only thing you have to lose is an illusion: The idea that we can go back to the good old days when each project aimed to create a new version of one and only one product.
But back then, you couldn’t even dream of the customer of one. Maybe those good old days weren’t very good, after all. You’re probably better off exploring the brave new agile-product-line world that BigLever’s offering represents.