Support for Open Source Assembly

While Open Source have become accepted in most corporations, there are still some fears and misconceptions about supporting a full enterprise-scale solution. Because such solutions are typically made up of multiple open source components, it's no longer a process of just downloading the latest version or a patch. The complexities involved are much greater than using an individual components. Likewise, there is no single vendor to turn to when something goes wrong.

Other typical concerns include:

1. There isn't a company behind the open source components. How will bugs get fixed?
2. How are upgrades of the components going to be handled? They all change frequently, and on different timelines, who ensures compatibility?
3. An assembled solution includes many integration points. How can they be maintained?
4. There are more moving parts than my organization is prepared to deal with.
5. My support team doesn't have experience in the latest technologies.

In a sense, each of these concerns is a support organization's need for stability and control, the polar opposite of some of the key benefits of assembling open source components into enterprise solutions. Successful open source components have active communities that drive frequent, useful updates. Assembled solutions integrate a variety of components to leverage the best solution for the given requirements. Open source components frequently leverage the best of new technologies much more rapidly than commercial software. Assembled solutions have the advantage of speed and flexibility. However, providing support is about control and consistency. Software that doesn't change has been the norm, so that's what support organizations are familiar with.

Rationalizing the two worlds, support stability and assembly flexibility, requires experience with the open source world. An understanding of how open source projects and communities operate as well as assembly techniques including SOA and other integration technologies is necessary to successfully provide consistent support for an assembled solution. When understood, many of the perceived challenges faced by support can turn into advantages for providing a better overall solution:

1. While not a company, open source communities provide excellent response to problems with component. Many other organizations are using the components and are open to sharing solutions. Fixes are rapidly incorporated into the code and made available for release. In general, solutions to real problems are resolved much more quickly in open source components than in commercial software due to the frequent release schedule.
2. Different components are on different timelines. However, with open source components, you are not obligated to upgrade at any given time. If a release is produced that is incompatible with other parts of your solution, you can wait to make the component upgrade until the incompatibility is resolved. In fact, if you choose to, you can freeze any given component forever and keep a copy of the source code for the version you are using, mitigating any upgrade concerns.
3. Integration is a challenge. However, open source components are designed for integration, leveraging standards and supporting backwards compatibility. Supporting integration is in the best interest of an open source component because it encourages adoption. Consequently, when challenges arise, they are usually quickly resolved.
4. There are frequently more unique parts in an assembled solution than in a commercial, or even a custom, solution. Assembling wisely and then actively managing the solution is required. The advantage is that components selected at the appropriate level leave more options open for replacement or improvement in the future.
5. Leveraging open source doesn't require being an expert in each of the technologies used by the assembled components. Handled properly, the experts are those who have built the component but you don't need to be an expert to utilize the component.