Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
com/developerworks/ibm/library/ar-cotsint/
Level: Intermediate
Benjamin A. Lieberman, Ph.D. ( blieberman@BioLogicSoftwareConsulting.com), Principal Architect, BioLogic
Software Consulting, LLC
22 Aug 2006
Purchasing and integrating a commercial off-the-shelf software (COTS) product can provide substantial
benefits to your development project. It can also lead to massive cost overruns, user dissatisfaction, and even
project cancellation. There is no single "silver-bullet" that you can apply to ensure that COTS product
integration will go well, but certain best practices can increase the likelihood of success. In this article, you
learn how to apply architectural approaches to improve COTS product implementation.
1 of 5 8/22/2006 3:27 PM
COTS product integration: An architectural approach http://www-128.ibm.com/developerworks/ibm/library/ar-cotsint/
This approach creates a working system with minimal functionality to reduce technical risks and ensure compatibility
with requirements. Creating an executable architecture is effective with all forms of COTS products in which the
interfaces and functionality are exercised. The downside of this approach is the need for a fully working system --
albeit an incomplete one. If the COTS product is incomplete or incorrectly installed or configured, it won't be possible
to show a full execution path.
Create a wrapper
Wrappers are code constructs that hide the implementation details beneath a stable interface. Creating a wrapper around
a potential COTS product provides a buffer against vendor changes in either the interface or the functionality. Doing so
also provides a way to test the solution prior to full COTS product availability. You can provide the wrapper with stub
methods that return expected values, thereby allowing development of other parts of the system before the COTS
product is selected or delivered.
Use a simulator
A simulator provides a testing environment that appears to be the same as the final production system. Using a COTS
simulator, you can develop and test your integration plan without installing a full version of the product. For example,
whereas a full billing engine may require multiple mainframes for implementation, you could simulate such a system
on a single server.
Develop prototypes
A prototype represents a throw-away development effort to provide "proof of concept." With COTS integration, you
often create a prototype solely for the purpose of deciding between competing products. The prototype then provides
guidance in the creation of the final system architecture.
In the Plan stage, you plan the next iteration of development, including meeting with the key system stakeholders and
reviewing the goals for the iteration. In the Gather phase, you evaluate the technical risks, create a design, and consider
2 of 5 8/22/2006 3:27 PM
COTS product integration: An architectural approach http://www-128.ibm.com/developerworks/ibm/library/ar-cotsint/
trade-offs. In the Assemble stage, you integrate the system with the COTS components you defined in the Plan stage.
Finally, in the Assess stage, you test the integration to ensure that it was performed as expected.
During the Plan and Gather stages of the integration life cycle, you must consider six additional aspects of COTS
product integration with your software system.
Vendor lock-in or entanglement
In general, avoid tight coupling to a particular vendor -- known as entanglement, or vendor lock-in. Design decisions
that make replacing the selected COTS product difficult increase the risk that the organization will be forced into a
long-term relationship with a particular vendor -- whether it wants to or not. As a result, development decisions can a
have grave repercussions to the organization if not considered carefully.
Versioning
Vendors periodically release updated versions of their products. Your system architecture should incorporate careful
consideration of how a new release will be deployed into all environments (development, test, acceptance, production).
Process changes
COTS product integration may require changes to your organization's core business practices and operations.
Therefore, integration may involve more than just software development; it may affect the full user community. Users
should be involved in the early rounds of integration so that they're aware of potential downstream impacts.
Validate the COTS product
Validation of a COTS product includes testing not only the integration but also the full system functional flows.
Validation argues strongly in favor of an incremental release approach, in which the partial system is delivered to test
to ensure that the component integration is meeting requirements.
Customization
COTS products often provide a limited set of configurable elements that you can tune to the specific needs of your
organization's environment. While this is a strong selling argument, it often raises issues of deployment, support, and
vendor lock-in. Customization should be limited to what's absolutely necessary.
Licensing
Installing and deploying COTS products involves licensing and configuration. Consider these factors in each iteration
to ensure that the final product can be efficiently delivered to the production environment.
3 of 5 8/22/2006 3:27 PM
COTS product integration: An architectural approach http://www-128.ibm.com/developerworks/ibm/library/ar-cotsint/
changes to existing systems or business processes. In this case, the custom scripts require increased maintenance efforts
and complicate release management for new versions. This, in turn, may lead to dramatic increases in ownership costs.
Other frameworks facilitate user interface development, data conversion, or networking. In all cases, the challenge is
the same: Choosing the solution that meets your organization's need with the minimal amount of customization.
Hardware-based COTS products have additional unique architectural implications. For example, consider a
video-on-demand system for a hotel. In this case, each room must be equipped with a specialized video converter box,
perhaps enabled with a built-in Internet browser capability. The solution that must be delivered to the customer has
become dependent on the particular hardware manufacture -- a limit to future product direction or deployments. To
combat this vendor lock-in problem, you may choose to avoid using all the built-in capabilities and instead provide that
part of the system functionality yourself. In this way, a new hardware vendor that doesn't support those capabilities can
be introduced with minimal system changes.
Extending COTS-integrated systems requires a few additional considerations. An integrated vendor may not be willing
to support a competitor's product or interface. A vendor may have partnership agreements in place that prohibits
coexisting with another COTS product in the final solution. Dependencies on a particular operating system or hardware
platform may prevent migration to a new system -- even if the integrating code is supported on the target platform. As
noted above, a COTS vendor product plan may not include a necessary function that your organization wants, but it
may also include moving the product in a market direction that doesn't support your needs, placing your organization at
a disadvantage if the organization isn't insulated against those changes.
Given these challenges, your organization may not realize all the touted benefits of COTS product integration if you
don't deal with these issues early in the project. As the system architect, your role is to provide a range of options to the
organization. Detail all the positive and negative aspects of the available COTS components, including cost in the near
and long term for all potential solutions.
Resources
Learn
For more information about the risks of COTS product integration in existing systems, read " Identifying
Commercial Off-the-Shelf (COTS) Product Risks: The COTS Usage Risk Evaluation" (Carnegie Mellon Software
Engineering Institute, 2005).
4 of 5 8/22/2006 3:27 PM
COTS product integration: An architectural approach http://www-128.ibm.com/developerworks/ibm/library/ar-cotsint/
"Evolutionary Process for Integrating COTS-Based Systems (EPIC): An Overview " (Carnegie Mellon Software
Engineering Institute, 2005) provides a process framework for integrating COTS products into existing software
systems.
To learn more about integrating COTS products, read "Can We Ever Build Survivable Systems from COTS
Components?" (Carnegie Mellon Software Engineering Institute, 2005).
Get more information from developerWorks (including articles, tutorials, and interviews) about IT architecture.
Discuss
Participate in developerWorks blogs and get involved in the developerWorks community.
Benjamin A. Lieberman serves as principal architect for BioLogic Software Consulting, providing expertise
consulting and training on a wide variety of software development topics, including requirements analysis,
software analysis and design, configuration management, and development process improvement. Dr.
Lieberman specializes in object-oriented architectures and distributed computing. You can reach him at
blieberman@BioLogicSoftwareConsulting.com.
5 of 5 8/22/2006 3:27 PM