The ITKO Blog: Application Lifecycle Optimization

Webinar 1/18: What is the Lifecycle Virtualization Market, and Why Service Virtualization Matters

You've seen a rapid barrage of market news in just the last 12 months about Service Virtualization (or SV) technology lately. CA buys ITKO for LISA's Service Virtualization capabilities, and many more acquisitions and announcements from major players in this space happening. Why now?

We've been talking about this practice of SV for almost 5 years now at ITKO, but clearly all these companies don't arrive at these conclusions unless there is a market movement afoot with customers. Indeed, Service Virtualization is part of a bigger shift toward more agile development using a new form of virtualization in shared environments such as private and public DevTest Clouds that will allow increased parallel development, with on-demand capacity for performance and earlier regression testing, thereby speeding up the overall application development lifecycle.

One analyst we respect on these matters, Theresa Lanowitz of voke, has a term for this new space that floats above the conventional requirements, development and test tools of the ALM portfolio - she calls it "Lifecycle Virtualization."

Here's a chance to learn about Lifecycle Virtualization and this new generation of technology encompassing Service Virtualization capabilities, and much more. Join Theresa and ITKO/CA "Chief Geek" and founder John Michelsen for this live webinar Wednesday, Jan. 18th:

Webinar: Lifecycle Virtualization - A New Practice of Optimizing Application Development, featuring voke and ITKO

January 18, 2012 1:00pm-2:00pm Central

Theresa has been talking to both end customers and software vendors in this space for many years as an IT analyst following emerging trends in application development. Here's her take on Lifecycle Virtualization from her latest blog "Part of An Overall Lifecycle Virtualization Solution":

"Lifecycle virtualization is defined as the use of technologies such as virtual lab management, service virtualization, defect virtualization, device virtualization, virtualized cloud platforms, etc, to enhance the application or product lifecycle through reducing defects, lowering costs, speeding time-to-market, and increasing customer satisfaction."

We hope you attend this webinar and find out how the application development industry is evolving to meet the difficult challenges of complex, interconnected systems and increasing customer demands for high performance, flawless service. Call it Service Virtualization, Lifecycle Virtualization, or whatever you like -- customers are realizing the value of much faster delivery with less risk today, while saving millions in infrastructure costs.

Also as a primer, we suggest you pick up the latest voke Research Market Overview paper on Lifecycle Virtualization (available for a limited time) which provides a good Overview of this new technology space.

LISA Customers at CA World'11 - An Excellent Hour of Real Stories and Results

Most of us ITKOers are just back from our very first CA World -- and it couldn't have been a more exciting time, as we see LISA solutions becoming a key part of of the CA family of solutions and optimizing the application lifecycle for a whole new set of customers. Thanks to everyone who visited our booth and attended our fun outdoor reception Monday night.

The pinnacle of the conference, for me at least, was the ITKO Customer Session on Tuesday, where some of our leading customers at HSBC, IBM Global Services, Sprint and SoCal Edison shared their real-world stories and results of implementing LISA to eliminate constraints from their application lifecycles.

Highlights included:

• An estimated 50% faster time to market for new product/functionality delivery across the board - meeting management's critical requirement for more agile innovation.
• As much as 94-99.6% faster system testing cycles. The customer said "I would have reported 100% improvement because of the level of automation, but nobody would have believed me!"
• For 2000+ development and test resources, increased the availability of environments to consistently identify defects 2 phases earlier (40-70% cycle time reduction), and realized ROI within 30 days.

One of the coolest things we've ever seen came up in the last spot - a fun internal education videos SCE's Hector Sotelo showed here during his talk - "I Need An Environment":

 

After the session there were some great questions for the group -- and, not unexpectedly, a healthy degree of skepticism from the audience that Service Virtualization and automation with LISA could yield huge results like saving $12M in infrastructure costs, 50% faster time to delivery and 99%+ faster regression and integration test cycles.

But this session was not ITKO telling the story - it was a real LISA customer panel that has been there, and done that -- and the consensus was that while the software does a lot - is is still people that must make the change. The challenges of realizing optimization in the software lifecycle aren't technical in most cases. The panel explained how they got the buy-in and adoption of not just one development or test team, but IT ops, management, and the line of business that depends on software for its offerings.  Anyway, this was a very compelling session to hear, so expect some more observations about it and plans for more customer sessions in the future. We'll let you know when more videos and material from CA World 2011 become available.

 

 

CA World Vision Award Winner – 5 Questions with First Data’s Laura Miller

Here at the CA World 2011 conference, the Agility Made Possible Customer awards were just announced, and First Data Corporation won the Vision Award for excellence in Service Assurance practices for their groundbreaking use of CA LISA to eliminate constraints and establish a Performance Testing Center of Excellence.

Read the press release here: “CA Technologies 2011 Agility Made Possible Awards Honors Customers’ Successes in IT Management and Security”

We have seen this company really take to heart the practice of delivering product to market faster using Service Virtualization to eliminate access constraints and setup time.

I recently had a chance to have 5 questions with Laura Miller, VP of Global Product Development at First Data, about her company’s journey using LISA to optimize performance and deliver product faster.

What is the project that brought on your team’s use of LISA?

We needed to performance test and rearchitect two of our front end financial institution products that both business and end clients will use in their own sites and call centers. It was critical that we have real-time levels of performance, or sub-second response times built in from the ground up. Our consulting partners helped us design a solution, and they recommended leveraging LISA to achieve the testing we needed.

Much of this Vision award is about finding new ways to overcome traditional constraints on software development. How has your group done this?

I like the fact that LISA really takes away traditional constraints. In the old days we would have had to build out the entire infrastructure, even if it was a smaller version of it. Or we would have had to write our own stubs. With LISA we were able to virtualize the mainframes and it took no time at all – it only took us two weeks to get a good representation running.

Also we wanted 24/7 testing, and we often have teams offshore testing at any time of day. With LISA I didn’t have any back-end constraint to moving forward. Not only were we able to get it set up quickly, but we were able to finish testing quickly, and therefore get our product out the door faster.

How important is time to market in your industry and what can IT do to accelerate it?

I don’t think there’s a market today where speed-to-market isn’t important. Look at Apple, FedEx and what they do. Obviously it is critical. For us it is all about the ability to deliver faster, and with higher quality, while reducing our setup time and not having to build new architecture. The setup and configuration of time of LISA also went very quickly as we got skilled people on the job.

The one thing we all know is that testing always gets short-changed. Timelines always get reduced, and that’s not changing. Being able to test 24/7, and not have downtime, really allowed us to push our application and know it would perform.

Behind any successful implementation or modernization there are usually multiple teams that need to get involved – has collaboration improved?

In our organization, collaboration was key on this. Before this initiative, we didn’t have a dedicated performance team in our Testing Center of Excellence, so we had to collaborate and bring in stakeholders from capacity planning, development, infrastructure teams, as well as functional testing and other groups. It was the first time we really brought all these groups together.

Our systems have grown internally and incrementally, over time. It used to not be as critical to worry about this because most apps were mainframe-based. Now these systems have become a dependency for us and even the business side is looking to us to confirm that we meet our client requirements.

What has it been like working with ITKO, now a CA Technologies company?

We’re very excited as a team to win the CA World Vision award this year. We were already CA customers and we have almost every tool they make, including APM, Clarity, and many other solutions. We are working on the next projects of performance testing and automation. 

I have always been pleased with ITKO and what they do with innovation, collaboration with clients and their drive to constantly make LISA a product that makes our lives better. A month ago I met with ITKO leadership and some other customers, and they wanted to hear our input on where they should invest more development time and what they could do better. That’s a very unique culture for a software company. We expect that level of passion and commitment to improve the product from the people who made LISA.

Helping a Telco Run Faster with Service Virtualization

Just got a really great note from one of our lead consultants in the field at a top US Telco provider. One of their major business groups that handles premium mobile content such as  search, games and entertainment, needed to go live with a new customer-facing system.

The highlights? Deployment had zero defects at launch and resulted in more than $3 million in software cost savings for 2011, while saving 4-5 weeks of expected cycle time.

The company had a driving reason to virtualize services, as they had a multi-million dollar upgrade planned for their delivery platform, and with it, a wash of additional licensing and maintenance expenditures.  Many of these costs would be "non value add" services and labor - duplicate licenses, time spent replicating over application servers and customer databases, all to provide an environment for them to use in pre-production to develop and test each new app against.

To top it off, the timeframe was extremely limited - the need for the above implementation was identified in March and the system was due in June this year! The app dev team chose to head off this requirement by implementing Service Virtualization models using LISA. If they failed, they would have been up the proverbial creek without an environment.

Fortunately, they were able to install and implement all of the needed virtual services and launch the new environment in less than 4 months - quite a difference from a process they had never before completed in less than a year. Then, the presence of completed, 24/7 available virtual labs allowed the development team to "shift quality left" and start collaborating immediately and shave 4-5 weeks off their expected customer services release timeline.

Anyway, we love hearing about teams that put Service Virtualization on the line to realize efficiencies and improved quality like this. Kudos!

New Paper: What Should a Service Virtualization Solution Do?

More than four years ago, we released the first version of LISA's Service Virtualization capabilities because we saw a fundamental roadblock occurring at almost every one of our enterprise customers. Sure, they were more efficiently automating functional, regression and performance testing with LISA, but inevitably, teams would complain that they still weren't becoming as "Agile" as they hoped. They were losing productivity due to constraints brought on by other parties they were connected to: partners and other dev teams that either didn't complete their delivery yet, or limited access to their systems.

This is why I'm excited to introduce this new paper I wrote for our 4-part joint IT Thought Leaders Whitepaper Series with our partners at Infosys:

Key Capabilities of a Service Virtualization Solution (Download PDF)
Eliminating Software Development and Testing Constraints by Virtualizing Away Dependencies in the Environment

We have to face the fact that no development team can build and test software in isolation anymore, using repurposed client-server tools. Software lifecycles are becoming increasingly composite and service-based, while an increasing number of smaller, agile teams created interdependencies that must be addressed with a new kind of virtualization - something we called Service Virtualization: the simulation of constrained or unavailable systems for continuous availability throughout the software development and testing lifecycle.

Service Virtualization is now maturing into a widely adopted technology, with many technology vendors embedded, and a market to support it. There are key capabilities any advanced enterprise dev and test team will need to have in a "live-like" virtual service environment that is as close to the real thing as it needs to be, without the constraints of excess coding, maintenance and reliance on big-iron systems to deliver new competitive functionality.

This paper is a good read if you are wondering where Service Virtualization technology has advanced over the last few years. It's not just about replacing the "stubs and mocks" developers used to hand-code with more pat request/responses. Today's apps have become far too interdependent, and fast-changing for that to be sufficient. Testers and developers must be able to recreate complex, composite workflows in an environment that looks and acts just like the real thing.

A smart counterpart at Infosys, Vijay Sairam Pratap, just commented on the story with a very compelling, clear anecdote about the level of realism needed from Service Virtualization to enable robust service assurance in his latest blog from an HP conference. We'll talk about that example, and a couple other newer real-world stories in our next post.

Link to Service Virtualization Capabilities whitepaper download page: http://www.itko.com/resources/service_virtualization_solution.jsp

 

Whiteboard: What is LISA?

Now back to your regularly scheduled programming... We recently improved our video production abilities by leaps and bounds, so here's the latest high-tech whiteboard from ITKO's Founder & "Chief Geek" John Michelsen. Enjoy!

 

How does ITKO's LISA Solution enable Service Virtualization, Continuous Validation, Automation and Defect Collaboration to move development and testing life cycles forward faster with less risk and cost? It shouldn't take long to understand the basic concepts from scratch with this new video. Look for more educational resources here soon.

Video: Measuring Success in Customer Dev & Test Labs

Here's a new video commercial you'll see running in some of our upcoming channels about customer value. Obviously, there are a huge array of "test productivity" metrics like cost per test, cycle time per regression or peformance test suite that we continue to measure. However, with new capabilities of LISA like Service Virtualization, DCM and Pathfinder that have no direct equivalents out there in the market, proving customer value becomes paramount.

 

At iTKO we have a Business Value Assessment methodology to revisit customers at different points after adoption, and measure value delivered to date.

A big part of companies realizing value actually has little to do with our product, and everything to do with how aggressive the company is about scaling their efforts and defining a strategy to achieve the full potential value. This is why we have built out a very strong strategic Services arm and partner ecosystem - as the technology won't matter if the people involved don't adopt it with the appropriate methodology and commitment.

Often successully accelerating timelines or decreasing costs takes a change in mindset. For instance, if the company's IT leadership only thinks about Agile as something developers do while coding, and Testing as a point-in-time activity after deployment, they will have difficulties. The entire software lifecycle needs to be Agile -- and Testing isn't just for UAT, it's part of development, performance tuning, integration, every phase of that lifecycle. Sticking to the definitions of the past can be costly.

Just Landed from #IBMImpact 2011 - Agility is Smart Business

We're back and settled in after an exhilarating flight through IBM's Impact 2011 show in Las Vegas -- and not just because the casino pumps extra oxygen into the room. This year's Impact theme for IBM was "Changing the Way Business and IT Leaders Work." That covers a lot of ground, but so did the solutions on display this year, for instance IBM's acquisition of Sterling Commerce to bring new industrial processes to bear, not to mention new SOA, integration, Cloud releases...

iTKO's theme for Impact 2011 was "Open the Throttle for Agile Composite Application Development," and to commemorate it, we trucked an actual helicopter onto the show floor. Naturally, when you have an R22 dominating your booth, and people playing helo sim games, it makes a lot of people come by and ask "why the helicopter?" iTKO's founder and Chief Geek John Michelsen answers this and other questions in his on-site interview - watch it on the IBMImpact channel here.

Think about it - you wouldn't assemble or add parts to a helicopter without simulating that those changes would fly in the real world. And you wouldn't step into the cockpit without logging some simulator hours. There's just too much risk. The same applies to enterprise applications. With so much at stake, the ONLY way to be agile and rapidly deliver new functionality safely is simulation. This is exactly what LISA does with Service Virtualization for complex apps that IBM customers rely upon. By virtualizing away dependencies, data and performance constraints, teams can develop and test in parallel, at much lower cost, without impacting live systems.

All in all, I have to say this is the best show we've been involved with so far. The quality of the content, discussions and caliber of attendees was high. For us, the highlight of the show was our Customer Session on Wednesday: "Application Virtualization and End-to-End Quality without Constraints at Leading Banks and Telcos with iTKO." A special thanks to the LISA customers who came and stood up to talk about results they experienced - you blew away our expectations. We'll cover some of these results in a future post. But for now, here's a few more photos from the show.

 

 

 

Impact2011 Preview Video - LISA for WebSphere, SOA, BPM DevTest

Here's the follow up to last week's post on "iTKO Opens the Throttle for Agile App Dev at IBM IMPACT 2011 - Platinum Sponsor" -- which outlines 4 key sessions to attend at IBM's Impact2011 conference (April 10-15, Las Vegas - register here). In this new Chalk Talk video, John outlines some of the reasons IBM technology customers will learn something at the event:

 

Key approaches John covered in this latest Chalk Talk video - relevant to anyone in enterprise IT but especially tailored for IBM users:

1. Service Virtualization
2. Collaborative Defect Resolution
3. Continuous, End-to-End Testing and Validation

The reality of enterprise applications today is that complexity and rate of change will always increase. So if your company is doing IBM-enabled SOA, BPM, and seeking aspects such as data management and higher performance from applications, it will behoove you to explore ways to increase your agility and open the throttle with some of this new thinking.

Two Strategies for Agile Composite Application Development - SV and DevTest

We just put up a new version of iTKO's Cloud paper "Service Virtualization and the DevTest Cloud" that helps clarify that there are two separate solutions we call Service Virtualization (SV) and DevTest Cloud, and while it makes sense to SV in its own right in any integration or testing project, there are also very good reasons to specificially use it for DevTest Clouds. Here's what we mean:

1. Service Virtualization (SV) is the practice of capturing and simulating the behavior, data and performance characteristics of unavailable or incomplete systems or services that constrain the progress of development and test teams.
   
   In essence, this is a "productizing" of the very time-consuming custom stub-and-mock process teams used to try to do for systems they couldn't get access to or easily copy or virtualize in their own enviroments. Obviously this capability has a very broad set of projects where it could be applied - it can speed up a step in a conventional waterfall-type software project, or really streamline things in an agile, SOA/BPM, decoupled approach. Virtual Services can act as stand-ins for functional and performance testing with almost unlimited repeatability, and little setup time and cost. But by the time you get to Cloud, teams invariably find they have even more dependencies, which calls for something new...
   
   
2. DevTest Cloud is a platform for doing software development and testing in a Private or Public Cloud. By nature, this Cloud-based environment allows the computing resources and infrastructure to be provisioned with complete flexibility - elastically consuming them in an on-demand way to allow the project to proceed with less overhead. A DevTest Cloud contains a Provisioning tool for deployment, and conventionally virtualized hardware and system capacity, but it also contains Service Virtualization capabilities.
   
   Without Service Virtualization, that Cloud-based lab would be subject to the same constraints as your in-house test lab environments: dependencies or "wires hanging out" that constrain teams when needed systems are unavailable or unready for development and testing. With Service Virtualization, these components can be simulated to respond with highly configurable response behaviors and times, along with a near-infinite capacity for high-volume performance validation.

I hope this helps explain why we needed to make the distinction in the whitepaper. Service Virtualization is useful to any complex, composite application development and test project, whether or not that happens in a Cloud-based environment. But within a DevTest Cloud, the practice of Service Virtualization is the catalyst that makes it a truly elastic platform without constraints.

Cool Field Story 3: Self-Service Virtualization

Here's another great story Ken and I gathered after a recent successful deployment. Technology is always rushing forward with more customizable development and test lab solutions for every enterprise.  Even at iTKO we continue to extend leading-edge product functionality for all the unique scenarios that customers bring forward.

Much of the time this type of customization is focused on making automated testing or performance testing more efficient.  But in reality, there are still tens of thousands of manual testers out there, and save for some slight process improvement, they have been largely ignored over the years when it comes to automating their complete environment.

An iTKO telco customer recently showed some examples of how they enabled their manual testers to be much more efficient through the use of Service Virtualization.  After sending transactions through their Front-End CRM UI, they log into their Back-End UI which shows them the detail of the Virtual Services captured behind their System Under Test.  This Back-End UI is something they developed on top of LISA Virtualize, and it exposes the current data inside LISA, such as the status of various Customer Orders, previously executed transactions, etc.

That’s mildly interesting, so testers can at least see if the transactions are properly reaching the Back-End.  However, what’s really clever is that they let the manual testers go in and modify the Back-End Virtual Service directly.  Testers can automatically skip a number of steps to put an order into the completion phase (which would typically take a very long time to enter in the Front-End UI), or they can setup negative scenarios such as an invalid order, error condition, etc.

This lets users decide in real-time exactly how they want the system to behave.  They are able to test a larger number of scenarios simply by being able to create conditions that the test lab normally does not allow.  And manual testers are empowered to setup their own scenarios without involving the DBAs and higher-level Test Data Management architects.  So by being able to quickly “prepare” the virtual environment for a specific test, they do not have to spend so much time setting and resetting test data.

Fortunately for them this has come with a number of positive results as well:

• Functional coverage after the first project stands at 80%, and they plan to reach 90% by the next release.
• Testers are 40-50% more efficient without needing access to specific test data, or getting a DBA to setup a specific scenario
• Testing across the board has started earlier in the software lifecycle, and they are finding defects much earlier in the SDLC
• Oh, and on top of all that they’re already saving over $200K annually, simply by not sending transactions to validate their system against the third-party vendor's test lab system (which was seldom working reliably and had unstable data anyway).

We hope you find these real-world stories useful in thinking about how to improve your own dev and test processes. Let us know what you think, and if there are any software challenges you would like us to cover in future articles!

Cool Field Story 2: From Production Issue to Resolution Virtually Overnight

Here's another great story from the field from iTKO lead solution strategist Ken Ahrens. (You may remember the paper he wrote with me on "Virtualizing Over-Utilized Systems" a few months ago).

When all else (literally) fails... try simulating from Production

One of our banking customers recently told us a success story about how they used Virtualize to solve an issue related to a production outage.  We were pretty surprised because LISA is primarily used for dev and test in the SDLC, and not typically in Operations and Production.  But they said for certain that their production defect was solved because they were able to use Virtualize to recreate the problem scenario.

However, Virtual Services was not their first approach.  When the Operations people identified that customers were experiencing a performance-related issue, they immediately contacted the Production Support team.  After collecting information about the issue they triaged to find that customer problems were due to a performance related issue happening in the middleware. 

Next, they immediately tried to recreate the problem by generating load in their test lab, but they found that they could not reproduce it there.  The test lab's version of the mainframe could not support the transaction load, so the back-end capacity was never high enough to recreate the problem in the middleware.  At this point, several developers and testers had spent more than a week trying to reproduce the issue, and they still didn’t know exactly what was causing the problem.

They reached out to the bank's performance team (who are avid LISA virtualization experts) to ask for assistance in running the stress tests.  The load team mentioned that for very high volume load tests, they used Virtual Services to simulate the back-ends, which had significantly higher capacity than the legacy mainframe system in the lab.  That way, there was no bottleneck behind the middleware under test.

The only problem was that the data was already set up in the live systems, and the Virtual Services used different data.  Typically this is the kind of problem that can take days to fix with DBAs manually copying records from one system to another and using conventional TDM (test data management) methods to ready all of the data for a test.  Indeed in this case, this effort had already taken place once. So instead of copying all that data to a new system, one of the Performance team engineers looked at their sample responses from Production and used LISA to automatically generate a thousand responses in a handful of Virtual Services in a couple of hours.

Immediately, they were able to generate the proper load on the middleware system, using the Virtual Service backend to eliminate the bottleneck.  They found they were quickly able to recreate the problem and identify the proper fix.  The typical resolution for this type of problem went from being measured in weeks to simply days (over a weekend, actually) through the use of Virtual Services.

The moral? When all else (literally) fails, support problem isolation and resolution with Virtual Services instead of trying to replicate what you don't need. It's predictable, scalable -- and just works!

 

 

John - Talking Cloud Development & Test on TMCnet

Here's a clip from my trip last week to Sys-Con's Cloud Expo 2010 West - I had the chance to catch up with TMCnet Executive Editor Erin Harrison for this interview about DevTest Cloud, and the trends we are seeing at this event.

Enjoy:

 

Here's to a continued - and inevitable - maturing of this sector of the Cloud market. Much of the remaining cost and constraint of IT is in properly equipping very expansive and widely distributed dev and test teams with ready environments that support needed scenarios.

 

Case Study - Test, Integrate and Virtualize Environments at Oracle

When the world's largest enterprise software company makes a commitment to "shift quality left" - and make consistent improvements in time-to-market, labor and infrastructure costs, and delivered quality across product lines, that equates to a case study worth reading.

• Read the iTKO LISA Case Study: Oracle Testing & Validation here.

This year we've been working with Oracle to automate and remove constraints from aspects of their own software lifecycle, and I recently had a chance to interview two of the leads on our projects there.

First, Oracle AIA (Application Integration Architecture) group's Nand Shivkumar described how they were able to Virtualize the company's integration labs, and offer their business-specific process integrations as Virtual Services for other performance and test teams to use for their own parallel development without delays or conflicts over access.

We also talked with the Oracle Fusion ADF (Application Development Framework) quality lead Amitabh Nandan about how they are conducting complex testing, then automating those as test suites that validate their advanced Web 2.0 style interfaces and frameworks for building customer apps.

For a software company that has grown with extensive product development as well as through strategic acquisition of leading product suites, the ability to rapidly integrate and deploy apps depends on having ready lab environments, as well as highly automated testing that can peel the layers of their architecture from the rich UI to the middle tier. Hope you enjoy the story and your feedback is appreciated.

2nd Paper in Infosys & iTKO Series: Service Virtualization for Modern Applications

I just got back from a select QA Leadership workshop in Palo Alto hosted by our partners at Infosys, where I presented perhaps one of the world's shortest talks for one of the world's most complicated tasks: Optimizing the entire application lifecycle in 30 minutes or less!

Obviously I could only scratch the surface, but there's something to be said for the focus that comes out of brevity, and it led to great questions and discussion with joint customers and Infosys leaders like Aparna Sharma (whom I've presented webinars with before) - people who have overcome some of the biggest challenges in software testing.

Certainly a major focus of my talk and an ensuing discussion was the practice of Service Virtualization - the simulation of systems and services that are either constrained or unavailable for use in testing and development throughout the software lifecycle. Service Virtualization is key to eliminating dependencies and allowing multiple teams to work around their constraints and conduct their activities in parallel.

It was a great day -- and on that topic of virtualization, we also have the release of the final version of this brief paper we co-authored with Infosys for the second of a series of articles about best practices for IT, Dev and QA initiatives for modern, service-based applications.

You can download the new paper for free here: Whitepaper with Infosys and iTKO: Service Virtualization for Modern Applications

Here's the abstract: Disruptive innovations such as the internet have repeatedly forced businesses to change quickly or be relegated to history. Every such disruption asks a simple question of service functions in an organization - can they evolve quickly enough? Modern approaches such as service oriented architectures (SOA), along with other similar distributed application architectures, carry great promise and can provide an effective model for lean, agile and componentized IT that can adapt quickly. SOA is one of the most widely adopted enterprise architectural methodologies, but its implementation is anything but simple. Since classical testing methodologies and tools do not fit modern applications well, we have evolved newer more rigorous approaches and products to address increased software complexity and change. Service Virtualization is one of the latest ideas that can provide a faster time to market for software, with higher quality and lesser risk.

This new whitepaper, jointly written by Infosys' Gaurish Hattangadi and iTKO's Rajeev Gupta, focuses on the use of virtualization of constraints as it applies to the problems of developing and testing modern SOA applications. Let us know what you think as you explore virtualizing services in your own software lifecycle. http://www.itko.com/resources/servicevirtualizationmodernapps.jsp.

News Today: Enabling the Defense Community in the Cloud with LISA Virtual Dev & Testing

Today iTKO issues a press release about our support for Forge.Mil, a collaborative software environment for the U.S. Department of Defense. As many of you know we have been following the dedicated work of DISA (DoD’s IT arm), and LISA-enabling their leading partners (such as Harris, Northrup Grumman, Raytheon, and many others) over the last 5 years, as a part of certifying and test services that are contributing to deliver functionality to the warfighter.

Here's the official press release out today:

Optimized Software Virtualization, Test and Validation in the Cloud for U.S. Department of Defense

DISA's Forge.Mil Initiative to Offer Shared TestForge Services in the Cloud, Enabling Faster Delivery of Capabilities to the Warfighter Through Software Release Efficiencies

Most discussion of Cloud to date is focused on either the infrastructure itself (the actual servers and running VMs, or IaaS - Infrastructure as as Service), or the applications themselves that are hosted on Cloud (for instance a SaaS-based offering). But how do we successfully deliver today's complex applications, when all the dependencies and constraints of unavailable systems drag teams down? Nowhere would this challenge be more evident than in Defense, where the work of many distributed teams must go on, while at the same time critical live systems must be secured against the volatility of testing and development.

Forge.Mil contains a Cloud-based community called TestForge - with a built-in Platform as a Service (PaaS) for Virtual Service Environments, so all development and test contributors can have 24/7 availability without impacting live systems, and create new levels of efficiency. The Forge.Mil initiative (which includes TestForge, SourceForge as well as providing a cloud platform for other aspects of software lifecycle management) proves that in many aspects of IT governance and innovation, federal agencies continue to lead the way over the private sector. Optimizing software in this sense can not only save time and money, but lives in the field. Thanks to everyone who has helped drive this vision.

Those Guys need LISA!

I frequently joke with my team about finding our next customers in major business publications. Every time I read a headline like the following, I immediately think: “Those guys need LISA!"

Yahoo Tech News: "Apple, AT&T sites buckle as iPhone 4 pre-orders begin"

The fact is, all the agile developers, functional testers and load testing servers they can fire up are not going to help them here.  This is NOT a load testing issue, it’s a virtualization of services issue!

If we met the guys working on all this critical stuff, you would certainly not hear that companies like Apple or AT&T don’t have enough money to buy servers.  In fact, many major companies actually tell me that they have more servers registered in their asset tracking system than they have employees!  These guys will be no different...

So how could these teams have used LISA to prevent this conundrum?

1. Service Virtualize each others' pieces of functionality that contribute to the site experience, so that each team can develop and functionally test their bits, without having to wait for the system to come together later, during integration.
2. Service Virtualize the dependent systems (inventory, customer ordering, account and number provisioning, etc.) so that performance tests at high levels can be performed ahead of time, and each service can size and qualify their environment for the load expected when it goes live.

Some day in the future, they will even want to have intelligent ways to fail over in production during peak load hours, but let's not put the cart before the horse. One of my banking customers puts it eloquently when he tells his component teams to reach a certain performance level on their own: "If your app isn't performing fast enough in your own virtual environment, why should you bother giving it to me to test in my environment?"

OK I’ll stop rambling.  Now somebody let me know when the coast is clear, so I can order my next phone ...  ;)

News Today: iTKO LISA, IBM Rational, and an Open Services Future

We are here at IBM Rational's major Innovate 2010 conference talking to customers about how they can support the application lifecycle with approaches built for today's distributed, Cloud-based architectures.

A good piece of official news came out today: "iTKO Announces Integration of LISA with IBM Rational Software" is about our further integration with IBM's Rational software suite and Jazz development platform, and continued collaboration with their far-reaching ecosystem of application developers and architects.

The new functionality discussed in the release is only part of what we are presenting this week at the IBM Innovate conference (if you are there, come see us at Booth J in the Cloud Zone). Specific use cases include:

• Create RTC work items or ClearQuest defects out of LISA tests with detailed, multi-tier trace information included
• Auto-discover and auto-generate Virtual Data Sets, Regressions, and Virtual Services for constraint-free, collaborative defect resolution and transparency across services
• LISA integrates with Rational Quality Manager (RQM) built on the Jazz platform to manage validation in ALM processes
• Supports collaboration initiatives including the Open Services for Lifecycle Collaboration (OSLC), by providing better clarity into adherence to compositional and integration standards.

Today's news comes after several months of working with IBM at customer sites to better eliminate the constraints of unavailable or incomplete systems through a joint solution we call Application Virtualization. While LISA has been "Ready for Rational" for a long time, this latest integration volley represents some significant net-new functionality for customers.

Your Middleware ended up in my Cloud!

I recently spotted a really good question from our friend Miko Matsumura on the eBizQ SOA/Cloud forums: "When will the cloud start creating deep impact in the middleware space and what segments will be affected first? Enterprise-to-cloud integration? Web 2.0 Application Infrastructure? Modern Internet B2B? Supply Chain?"

Here's what I had to say on the topic: To date I think there has been a generalization of Cloud as a deployment alternative for production servers, etc, when at first there are few enterprise-level, middleware-enabled business processes that can realistically survive in a Cloud without having "wires hanging out" - constraints of over-utilized systems that cannot be placed in the Cloud.

The pre-integration Cloud you mention - well, the Dev & Test Cloud is going to be a significant area of growth over the next 5 years. It is hard to develop and deliver apps for the Cloud, when there are so many dependencies not available in the Cloud - mainframes, 3rd party apps like SaaS, systems of record and other over-utilized and pay-per-use assets that Development and Test teams simply can't budget for, since their use is highly variable. We will need to find a way to take our middleware processes, and other external constraints, and make them available for integration purposes in the Cloud.

I've made it one of my little missions to better describe this phenomenon with a series of YouTube "chalk talks" there's a series of 4 videos. (See our Solution page for Dev & Test for all 4 videos on the right...)

There's a reason why current successes in the Cloud are kind of consumer-oriented, content-heavy apps, and not as much "big iron" multi-enterprise apps and middleware. Pre-Production clouds will be a necessity for Cloud Apps.

The fears that Cloud Apps are not bulletproof enough for serious middleware and integration use are unfounded - good software, wherever it is deployed, is still up to people: good architecture, elegant development, responsible security approaches and early testing. If we give them the means to do their jobs better in Cloud pre-production environments the success will follow.

Why Stubs Don’t Work: Part 1 – Developers & Consumers

I’m frequently asked what the difference is between what we call a Virtual Service, and what developers have done for years, which is “stubbing” and/or “mocking out” a particular service. There are a number of ways I can address this, depending on who I’m talking to.

 First, for the Developer, I’m going down the path that Virtualization is now taking on the task of industrializing or productizing the practice of stubbing itself. Some 20 years ago, when I first started development, I wrote my own database, wrote my own development tools, my own middleware to get components to talk to each other – in fact, I used to code all kinds of things that today, I would never even dream of building anymore.

The requirements for proper databases and middleware became advanced, so that it was no longer feasible for developers to roll their own. Instead, those requirements became a category of software, and vendors started delivering solutions for that space, thus we saw the rise of a database market, and a middleware market, and so on. We see that the requirements for simulating components have become too steep to roll your own. So in that light, we see Service Virtualization as essentially the “space” that is coming out of the requirements of stubbing and mocking.

The second answer I would give, more often to the Consumer of a stub or mock is just how brittle these stubs or mocks have to be in order to be efficient. The whole reason why a team would construct their own stub is summarized as: “I don’t need a product for that, because it is something I can make quickly and easily by myself.”

Well if the goal is to do something quick and easy, the best you will be able to do with this artifact, is do a “round trip” to the stub, to prove connectivity of a particular application to that stub. In reality, there is so much more detail needed by the consumer of a service, that calling it “something you can mock up quickly” means you don’t understand the true nature of the problem.

Let me explain: If every customer response for a stub has the exact same profile, and the exact same address, account balance, etc. all with hard coded values and dates, then that may help the consumer of that stub with ONE data scenario. But, what about customers with high account balances? What about old invoices? What about transactions that occurred yesterday – and will they work the same tomorrow when that date becomes 2 days ago?

The problem with a stub that has static data, is that it won’t support the real variety of scenarios that are needed for a real world application. And you can’t just randomize the data – that would be even worse!  Consumers need predictability and control over the data they’re seeing. And they need to integrate that data not only from the simulated application, but from all the other services that might be associated with that particular application they are building.

A simple example: Say you have customer lookup in one service, while you have account management in another service. So if you have Account IDs and Product Codes and Balances that are not aligned properly between the two systems, you will have an application that fails, either at the consumer level, or somewhere in the downstream systems.

When you think about data required to support development in this scenario, stubbing a system simply doesn’t hold up. Considering all the things you would have to do to make that stub more real, you would need a pretty sophisticated framework to build those stubs. So you might start out building stubs, thinking “it’ll only take a few hours,” but you end up taxing your whole project plan with the hidden cost of building the first generation of a stub, and then modifying it over and over again. And by the way, they don’t even work very effectively.

This is part one of John's discussion on "Why Stubs Don't Work." Read part 2 of the blog, where he will discuss Performance Lab uses of stubs, and the "Tipping Point" for moving from stubs to Virtual Services.

Question: Are Pre-Prod Environments Balooning while Production Infrastructure Shrinks?

I recently posed a question to eBizQ and got some good answers, both reasonable and unexpected perspectives. See my eBizQ SOA forum question here: Are Servers Bloating in Pre-Production, but Shrinking in Production due to SOA?

K. Scott Morrison and Joe McKendrick discussed how Virtualization is a tester's best friend in reducing this phenomenon - and yes we have seen virtualization of hardware reducing some infrastructure needs. What about the ones you can't virtualize? I vote the best answer (received by 5:00PM CST) goes to Avi Rosenthal, whose comments highlight why this phenomenon is happening:

"In distributed Service Based, Virtualized and Cloud based environments the number of other environment servers is skyrocketing vs. the number of Production servers. This is true as well for virtualized server instances. The reason for that phenomenon is that Production environments are more controlled because no one can allow uncontrolled Production. The risks of non controlled Development or Test environments are less obvious. As the number of instances grows the number of servers in the non-controlled environments grows more rapidly than the number of servers included in the controlled environment. However, logically the number could be reduced at least to a ratio of 1:3 or 1:4 and not 1:20 if the non-Production environments will be managed and virtualized similar to the Production environment."

Really good point Avi.

However HP's Kelly Emo then came up with the gist of an issue I wanted to address further: the huge rift between measuring costs and effort for Production vs. Pre-production environments. It seems these activities are usually owned by two completely different departments and cost centers within the enterprise as she notes:

"In a majority of customers I speak with, their organization, culture and funding models are no where near having this happen... different silos are managing hardware and software resources and different SLAs are associated with them. In fact, in some cases, SOX compliance keeps organizations from being able to mix and mingle their networks and data between pre-production and operations. That said, I see one place where this can happen.. in the cloud..."

That's a next-generation view. Indeed the cloud is a big piece of the puzzle. However, many of the companies who get excited about the value of deployment savings using VMs and Cloud-based infrastructure to replace servers, simply do not have a reason to care about the number of groups maintaining and consuming dev, test and integration environments.

 The same goes vice-versa for pre-production - when you break up development into smaller, agile dev & test teams, those teams each provision and set up their own hardware and software environments in a largely unregulated fashion - and often find out that there are many dependencies they can't copy or replicate via conventional means. This leaves a lot of cost and effort unaccounted for in the wash of the software lifecycle, or as a cost of per-employee infrastructure or support.

You will see a lot more on this topic from us - while we aren't in the business of virtualizing servers and hardware, we are particularly curious about why companies aren't recognizing the value they get by optimizing Production vs. optimizing their infrastructure at every step along pre-production. Is a ballooning number of servers a side-effect of distributed, agile approaches, or is the symptom we are reporting simply a matter of perception? We'll keep you posted as we do more research in this area.

The News - Working with Harris on Complex Validation Problems

Today iTKO made an announcement about our strategic partnership with Harris Corporation, a Fortune 200 systems integrator we have been working with on several significant projects in the US Department of Defense and other federal agencies. Read the press release here.

What is significant about this?  Many organizations (commercial and government) are realizing that while developers can build and integrate software faster than ever, their testing efforts have proven inadequate at keeping up. These agencies need proactive, automated, and continuous validation to ensure trust and reliability in federated, mission-critical systems that are subject to constant change.

iTKO and Harris are responding to this challenge with a validation and virtualization solution that will appeal to organizations that trust and rely on these systems. Examples include federal emergency management centers, military command and control systems, financial institution trading systems, utility energy management grids, airline traffic control networks, and many others.

While we have been cooperating with leading government contractors like Harris for 4 years on integration projects like these (see this iTKO paper on Federated governance we first wrote 3 years ago...) we have seen a major shift occurring in the way Federal agencies specify and manage their complex applications. They are moving to a shared services / shared components model, where different functional units (or, services) are consumed and managed by different teams, with a central point of certification and testing for these services.

A federated, shared governance model means there is just enough governance enforced at a central level, and authority for managing and using the application components is doled out to the constituents. We compare it to a Federal government vs. state's rights, vs. city council authority model. The federal government might specify a budget for a highway, but it doesn't dictate where parking is located in the city.

This federated model works very well for defense agencies and the many firms that support them, as they are all working toward a common goal - delivering functionality to the warfighter with maximum efficiency. As we have frequently mentioned in this blog, businesses would do well to take cues from how government scales their systems and cooperates to meet goals - they were leaders in SOA and will likely continue to lead the way in many aspects of modern application governance.

Virtualizing Over-Utilized Systems: Part 5 - Virtualize the Behavior

This is the fifth post in our series based on the new whitepaper "The Next Frontier for Virtualization: Over-Utilized Systems" by iTKO (Ahrens, English). In this issue we cover how the practice of Service Virtualization provides solutions for over-utilization of core systems and services needed for testing and development.

Hardware Virtualization Can’t Solve Bottlenecks of Over-Utilized Systems

We’ve reviewed why systems are becoming over-utilized, as compared to under-utilized. The problem is that the hardware and desktop/OS virtualization tools we have at our disposal are great for optimizing under-utilized resources, but they are often incapable of virtualizing the behavior of over-utilized systems.

Even the largest virtual server deployment and centralized management of VMs may not allow for the virtualization of 3^rd party cloud services or mainframe assets.  However, these same concepts of virtualization can be applied in new ways to eliminate bottlenecks in our overtaxed core services.

A Solution: Service Virtualization (or, "SV")

Service virtualization involves the simulation of software service behavior and the modeling of a virtual service to stand in for the actual system during development and testing. Think of it like a “stunt double” for your most constrained, critical applications. Service virtualization addresses each of the aforementioned hardware virtualization limitations such as:

• Providing 24/7, on-demand access to ready test environments managed on your terms
• Removing capacity constraints of over-utilized systems
• Addressing test data volatility across distributed systems and conflicts among teams
• Reducing or eliminating the cost of invoking 3^rd party systems for non-production use

While Hardware Virtualization focuses improvements on the systems an IT team can control, such as servers in the data center and desktop, the complementary practice of Service Virtualization is geared toward optimizing the distributed and shared types of applications that are resistant to being imaged as a hard drive in a hypervisor: the over-utilized systems such as mainframes, partner-managed services and components under development by other teams.

 Let’s look at a sample enterprise with 3 downstream dependencies after applying SV techniques (from the bottom up): 

• Mainframe access problem eliminated:  During an instance when the key transaction system is available, it is captured and reproduced as a sophisticated model of that behavior, which is then hosted as a virtual service and accessible 24/7 in a virtual service environment.
• Database access and data volatility eliminated: Rather than having to negotiate set up and removal of test data sets from multiple sources and partner systems, the team can get a stable set of data to validate scenarios without impacting the live systems or other teams’ test data.
• Mitigated an unavailable or incomplete system exposed through a Web Service: Construct a Virtual Service from a WSDL, SOAP documents, XML samples, and other artifacts, whether or not the service, or the back-end system is available for testing. If desired, the Virtual Service could be accessed as a “pass thru” to intercept test transactions, while allowing live transactions to continue through to the real service and legacy application.

Coming up: 6th and final issue in this Series: Customer Examples of SV in practice, and Conclusion.

Modernizing Legacy Apps: Still Sexy?

Yes, legacy modernization might be about as un-sexy as you can get as far as IT practices go. But we know that these venerable IT assets are a reality of any serious operating enterprise, and making those mainframes and core systems work in today's architecture is still a very hot topic for discussion.

Our John Michelsen recently joined in a good discussion on the eBizQ Forum. Question posed by one of our favorite bloggers, Joe McKendrick: Are Web services protocols such as SOAP and REST and AJAX effective for building SOA off of mainframe, large systems or legacy environments?  Or is message-oriented middleware more advisable?

Well, yes, and yes as John mentions... they better be effective at bringing those systems into a modern architecture, if you are using them. Many developers and architects can get quite dogmatic about SOA vs. REST, or how MOM solutions like ESBs are good or evil.  It sounds like a blanket statement, but the longer we are in the business of aligning IT around business, the more ambivalent we must become about these distinctions.

Anyway I think the Q&As going on there are worth reading, and we are seeing a lot of the "usual suspects" in SOA punditry and integration expertise weighing in.

Webinar 6/18: Automated ALM & Dynamic SQA with iTKO & Forrester's Visitacion

Wanted: A way to tie together the software delivery advantages of Application Lifecycle Management (ALM), with Dynamic SQA, which provides the in-depth quality coverage required for today's complex and constantly changing enterprise apps. What practices and tools are required to make this connection happen?

We are excited about an upcoming webinar on Integration Developer News that should amply address both. iTKO Founder/Chief Geek John Michelsen is joined by Forrester VP Margo Visitacion, a leading expert in ALM and Software Quality. Ensuring predictable results and on-time delivery of enterprise software requires testing, validation and virtualization across a myriad of changing technologies and services. Customer examples and current methodologies will be explored.

Here's the official description and signup link:

iTKO and Forrester Webinar 6/18: "Removing ALM Obstacles for Greater Agility, Cost Savings, and Lower Risk"
Experts from iTKO and Forrester Research present trends / technologies behind automated testing and validation to streamline ALM for higher productivity, accuracy and agility. Attend and Learn how Testing, Validation and Virtualization are being employed to support the best practices of Dynamic SQA (Software Quality Assurance). With with strong Dynamic SQA in place, enterprise IT teams are poised to deliver predictability, patterns and reuse to better manage complex software projects.

Our last webinar on SOA and Integration Efficiency (view archive) had more than 500 attendees, and lots of great questions we were happy to address (either on the session or afterward). We hope you will join us for this one!

Minimize IT Outsourcing Risk with Collaborative Quality - Part Three

This is the third of a four part series that summarizes the key points of our paper on Minimizing IT Outsourcing Risk with Collaborative Quality. You can click on the title to get the complete white paper.

In the last post in the series, we started to look at how to meet the risks and challenges of the outsourcing of IT development. In this post, we will look at how you can handle the changing components and dependencies and achieve validation on an ongoing basis. We will also look at how iTKO enables parallel development and testing without constraints.

In a SOA environment, a change to any service can create "unintended consequences" by causing unexpected failures on other dependent services. Throw in third parties through outsourcing and you compound the risk. To mitigate this risk, you need to continuously validate that delivered components have accounted for other elements in the workflow, and declare those in your tests, providing other team members with visibility into those dependencies.

Now, we need to "coat dependencies with testing" from this perspective, to prevent unintended consequences and run automated tests as needed on an ongoing basis. As a best practice, teams often use our solution to segment continuous validation activities along business process lines. To achieve maximum efficiency, distributed teams need to decouple their own environments from dependencies on live or incomplete systems, so they can continue working in parallel, rather than waiting on each other.

Think about many services engagements, and the amount of effort wasted on providing test access on a live transaction service or critical data source to a service vendor. Often there is a very limited window of time that can be offered by the companies IT ops team. Service Virtualization solves this bottleneck by allowing teams to design, develop and test their own components against changing environments by capturing and modeling the rest of the system (services, data, mainframes, etc) as running Virtual Services that simulate the behavior of the needed target environment.

Now multiple teams can design and test services in parallel and thus eliminate the constraints and dependencies of accessibility, availability and security for incomplete components and live service implementations. In the fourth and last post in this series we look at best practices for the outsourcing consumer.

Minimize IT Outsourcing Risk with Collaborative Quality - Part Two

This is the second of a four part series that summarizes the key points in Minimize IT Outsourcing Risk with Collaborative Quality. You can click on the title to get the complete white paper.

In the last post, we looked at the risks that can come from outsourcing IT development. Solving for these risks, not just through contractual negotiations, but in every day collaboration, can unlock the benefits of outsourced IT and address larger distributed development issues. In fact, if the appropriate IT infrastructure is available to better manage accountability and quality across distributed teams, while eliminating dependencies and constraints that restrict the agility and productivity of these teams, then it follows that these benefits could apply not just to outsourcing situations, but to any distributed team environment.

The first step in meeting the challenges of distributed teams is to gain a commitment across all teams to deliver components against well-defined requirements, in an auditable form, with the ability to accommodate the highly interdependent nature of today’s applications. This requires more than the right attitude, it requires the right tools.  Key testing, validation and virtualization capabilities will help firms mitigate these risks, and foster more collaborative quality across interdependent teams. These capabilities include:

1. A collaborative testing framework that directly verifies all technology layers with a high level of automation, so the team can better meet defined requirements at lower cost.
2. Continuous Validation so both parties can assure that each software component supports all upstream and downstream dependencies, in an auditable form.
3. A Virtual Service Environment (or VSE) which simulates the behavior of the highly interdependent and critical systems the teams must build and test against, even when they may not have access to live or completed components.

With these capabilities, the consumer of services should not just receive code assets, but also the deliverables they need to rapidly validate them - collaborative testing is matched to functional requirements. This is important, since resolving a misunderstanding early in the requirements phase can be orders of magnitude less expensive than fixing it later in deployment. So how can we move testing earlier into the lifecycle, to save costs and improve quality?

If the offshore partner’s testing is not tied to functional requirements, there is no way to know if there is any value to the test. The key to achieving collaboration is to demand that each component a team delivers is also comes with a suite of working tests that prove its functional requirements have been met. That way the next team, whether local or offshore, can iterate on testing from there.

For instance LISA tests are saved as .XML documents, then the business team can augment these processes by combining them with traditional requirements docs as executable test assets in ALM and Test Management tools. From this foundation, the tests become part of a continuous build and validation process, where regressions are proven to match defined requirements in later testing cycles. In our next post, we look at how you can handle the changing components and dependencies and achieve this kind of validation on an ongoing basis.

Federated Computing demands SOA Governance & Testing

We recently read an article specific to the Federal Government's efforts that was very interesting and relevant. Our work with government agencies has exposed us to the concept of "Net-Centricity" which is a more overarching term than SOA. Net-Centricity (in my informal definition) represents a commitment of all departments and parties, across different authority domains, to work together to meet common goals through IT.

No matter how advanced the architecture design is, SOA alone won't deliver the vision of Net Centricity, with its expected agility, reuse and functionality benefits for the warfighter - if there is not trust instilled between teams and authority domains that must share and support an alphabet soup of IT systems and services. So in essence, the government's Net-Centric effort mirrors SOA and IT Governance efforts.

We recently read an article from Federal IT consultant Warren Suss that does a great job of covering this topic, titled "Streamlining IT Governance." It is good to hear someone talking about this. SOA Governance requires testing and certification of services, to ensure that there are no unintended consequences of change that can impact mission threads (or "workflows" in layman's terms).

In previous posts we have mentioned how Federal agencies are ahead of the business world in many aspects of SOA - due in no small part to this shared mission. In this space, we have seen these Net-Centric plans come a long way toward delivering a high level of quality and shared responsibility over the last 3-4 years.

Suss states: "Today, we recognize that important information can reside anywhere in the enterprise. What’s needed is a way to allow users with the need to know to get their hands on trusted information from anywhere in the network. Governance decisions, as much as technology decisions, determine the standards, rules, infrastructure and services that enable — or hinder -- the rapid discovery and sharing of information and capabilities."

We agree that Net-Centricity is about the practice first. Federal agencies seek to control a web of compartmentalized systems, by federating governance, so the teams that support the systems have some centralized standards, but not so much control that teams don't have local authority over local issues.

We must also talk about the technologies that support the federated environment of agencies and teams leveraging shared services. Strong testing and SOA policy validation on a continuous basis is crucial for ensuring trust in this type of shared environment. We also have a lot of research around Service Virtualization capabilities that eliminate the dependencies and constraints of these shared environments. When we can break interdependency and access constraints with virtual services, teams are able to develop and test without stepping on each others' toes in the software delivery lifecycle.

Intermediating ESBs for SOA: The Final Webinar?

OK, sorry to mix metaphors, but it is time to put this can of worms to bed (???). If you've been following this blog you couldn't help but notice the many posts on the apparent ESB vs. SOA controversy. All of this started with an innocent little interview John did for SearchSOA - where the topic of Intermediating multiple ESBs came up. This article created a tornado of posts from some heavy hitters on SOA topics over the last month.

Given all of that, we decided to have our own little webinar on the topic Monday - and we were glad to find dozens of you Chief Architects and senior IT & Dev Managers attending - and asking some great questions about how to rationalize ESBs with their existing technologies, and enable your SOA initiatives going forward.

You can watch an archive of this informal, and informative webinar, with iTKO's John Michelsen, and Chris Kraus here: http://www.itko.com/site/resources/esbwebinar.jsp. Chris demonstrates a little software how-to in the middle of the session for those to like to see the screens.

Hey, are ESBs evil? We don't think so - we've always considered them to be another valuable building block in SOA for many of our customers. The key to success here is making sure you are using ESB platforms, even if they are of different flavors - for doing what they do best in the integration process. An ESB does not make an out-of-the-box SOA. However with good design and architecture principles, and strong validation and Governance, you can mitigate the risks of working with these technologies and bring a lot of your legacy and transactional technologies into the SOA fold with much more ease.

Virtualization of ESB messaging behaviors (and the underlying apps and mainframes they expose) is another way to address these ESB intermediation constraints between teams - say if I'm on the webMethods (SAG) team and need access to the TIBCO team's messaging framework. Or if I'm using Oracle/BEA Aqualogic and need to interact with services exposed through the SAP XI messaging tools. Our counterpart on the other team may want to limit our access to these systems - especially if they are supporting live business requirements. The ability to virtualize away those inter-team dependencies, and have a realistic, stable Virtual ESB earlier in my design/develop/test lifecycles can take away much of the cost and delivery timing constraints inherent in intermediation.

Is this the final time we'll visit this controversy? Maybe not - as long as there is complexity and change in SOA, which is the case for virtually every decent sized enterprise IT shop, there will be a need to rationalize multiple technologies. After all, we have to keep doing business today, despite mergers, compliance changes and new competitive pressures that make us keep bringing in new technologies.

We invite you to sit in on the session and make up your own mind -- and welcome your comments on the content.

SOA Best Practices: Continuous Testing and Validation

Several weeks back I gave you a real life experience that typified why our test strategy we call the Three C’s has Complete as one of those C’s. This blog will give you a different real-life experience on why Continuous deserves “C” status.

I was meeting with a Director of development at one of the worlds largest financial institutions. Many of their trading applications have absurd levels of complexity and variability along with, of course, radical performance expectations. Really cool stuff.

A certain critical service was running on a major SOA platform. The vendor released an update to that platform, and the team responsible for this service ran their unit and service level tests -- doing more than most teams I’ve seen. Turns out, they all passed, and in fact the service performed its main function 12 milliseconds faster -- COOL!

Then again, maybe not.

They deployed the patch and watched their entire currency trading system grind to a near halt!

Wait, you sped up the service and slowed down an application? Yes. Turns out the performance of the service prevented timing issues in the orchestration layer from surfacing in use by an application.

Of course it wasn’t obvious to the team that this was in fact the issue -- they were blaming the vendor, then their new code changes looking for how they could have wrecked the performance. They went on for days losing millions until they figured out what was really happening.

The Continuous C solves for this type of problem. Take those same tests you would automate at the orchestration and solution levels and run them on a continuous basis at those points of integration, pre-production. You’ll get immediate notice of this type of issue along with much clearer identification of the root cause.