Knock down the wall—or build a window in it
In today's challenging business arena, innovation is the key to creating a competitive distinction—and software-driven services often make that innovation possible. Toward that end, the need for software that's bug-free, high-performance, and feature-complete is greater than ever.
For this reason, organizations are increasingly pursuing in-house, custom software development. Such applications, however, often fall short of delivering the intended value because of the way the software lifecycle spans two separate groups: the development team (that creates software) and the operations team (that oversees the production environment in which that software runs).
Put simply, these groups are often divided by a logical wall. When development is finished with a build, it is commonly said to "throw the build over the wall" into operations. But if that build, once deployed, seems to have technical issues, operations will throw it back—reverting to an older, trusted version of the software instead that lacks the new features.
This situation is clearly suboptimal from a business standpoint. To begin with, it creates delays before a final, acceptable version of a build can be deployed and creating value—delays in which customers aren't being satisfied, and competitors have a chance to woo those customers away. Additionally, however, the overall expense of the software lifecycle goes up considerably, because the labor costs involved in building and deploying many versions of an application, before finding a suitable one, are multiplied with each new build.
Wouldn't it be better if it were possible to link these two teams logically—sharing information across their tools in such a way as to increase the odds that an application build would be successful from the start? Or, if problems did occur, to help the development team identify and resolve those problems as quickly and accurately as possible, so a fixed build could speedily be created and rolled out?
Integrate your development and operations teams to get better software, faster
This is the premise behind IBM's recent strategy of integrating its development and operations solutions, represented by the IBM Rational and IBM Tivoli portfolios respectively.
"Cloud computing, already a very hot area, stands to get still hotter, because a cloud can take on an important new role: assisting in the development of applications that drive innovative, customer-requested services."
Few organizations are as well positioned to do this; few even offer solution portfolios in both categories, whereas IBM is a recognized industry leader in both. And IBM's extensive history of successful customer consultation, in addressing the development/operations divide, is also directly on point. Because IBM is familiar with some of the most common pitfalls associated with integrating development and operations teams, IBM can incorporate that insight into its own portfolios, helping its customers to avoid those pitfalls.
Furthermore, because IBM is also a leader in cloud solutions, it can achieve even more than that. It can help organizations not only integrate their data, tools, and teams across development and operations, but actually leverage a shared cloud as an underlying architecture on both sides. This means that cloud computing, already a very hot area, stands to get still hotter, because a cloud can take on an important new role: assisting in the development of applications that drive innovative, customer-requested services.
How, specifically, do these integrations work? Let's consider a couple of different scenarios, both of which leverage IBM Rational Performance Tester, or RPT, on the development side, and IBM SmartCloud Application Performance Management, or SmartCloud APM, on the operations side.
Create accurate simulations of the production environment before releasing a new build
Imagine that an organization believes its customers would be interested in a new service. It needs new software to drive that service. Naturally, the IT development group is chartered with creating the software.
In a perfect world, this new software would be perfectly tailored to the eventual production environment... even though it wasn't created in that environment in the first place. Unfortunately, this is a difficult goal to achieve. Many variables, such as the fluctuating levels of business workloads in real-world production environments, stand in the way. An application that seems to hit performance targets in a development system, in other words, may come up short once actually deployed.
What's needed, then, is accurate data about real-world demand levels. Fortunately, that data is available—from SmartCloud APM, which is busily tracking and analyzing application performance in the cloud. This organization therefore requires a way to route that data into its development tools.
Just this integration now links the two IBM solutions. Specifically, IBM Rational Performance Tester, which is used to assess build performance, can draw production data directly from SmartCloud APM. The development team can then use it to create an accurate environment in which to test the build.
This means performance bottlenecks can be discovered, and their root causes can be isolated and fixed by the development team, long before the build goes live. Ergo, the build is far more likely to perform as expected, creating the value the organization hoped it would—and far less likely to have to be rolled back into development for more work.
Give development teams the operations data they need to isolate and fix application problems
Of course, even such an optimized process won't always yield a perfect build every time. Some deployed applications will inevitably have issues—and those issues, once discovered, will have to be fixed.
Here, too, the new integration can help. Suppose a new build has been deployed into the cloud and isn't performing up to specifications. In this situation, SmartCloud APM will proactively detect that a problem exists and alert the IT team. The question now becomes: Is the problem due to the new build (meaning the development team needs to get involved) or is it a problem with the production environment (meaning it can be solved entirely on the operations side)?
Fortunately, SmartCloud APM can, thanks to extensive root-cause analysis capabilities, answer that question, verifying that indeed there is a problem with the build itself. Such an analysis will, of course, generate data—data that the development team could certainly benefit from having.
Via the new integrations, SmartCloud APM passes that data to Rational Performance Tester, which launches in context to illustrate just what went wrong in the new build. The development team can then more easily diagnose the issue and take steps to repair the faulty code. Subsequently, it can validate the fix works as intended, and roll the fixed version of the application back into production—at which point SmartCloud APM will again begin to track and quantify its performance.
In short, the organization benefits in two clear ways:
Both benefits help the organization roll out new services faster, and ensure that customers are benefiting from those services as much as possible—essentially creating a royal road to business success in today's software-driven world.
Pulse 2013 Call for Speakers is now open!
Did you know clients who present at Pulse may receive free admission? Submit your proposal today!
Speak at Pulse
Leverage and contribute to the collective wisdom around Tivoli