In the context of the profound changes we’ve already discussed, it should come as no surprise that software development in the Social Age has changed as well.
In a 1676 letter to his rival Robert Hooke, Sir Isaac Newton talked about the importance of earlier discoveries by his predecessors: “If I have seen a little further it is by standing on the shoulders of Giants.”[1]
Newton’s comment applies as much in our day to open software as it did to the discoveries he described in his brilliant Principia Mathematica. In the world of open software, building on the work of others is a fundamental principle. Collaboration, sharing of ideas, and discrete contributions made by a group of individuals produce powerful results—often rivaling and surpassing those produced using traditional software development methodologies.
Sir Isaac Newton Painting by Anfernee Waller at MCMS (1889)
Open software does not just refer to the traditional concept of open source but refers to the process and methodology of creating software collaboratively. The collaboration might be completely open to anyone who wants to participate or it might be driven by a smaller subset of contributors with similar interests or experiences. For example, a corporation can start an open software project across multiple organizations and include external contributors such as partners, ISVs (Independent Software Vendors), customers, and academia. The outcome can be kept as part of the intellectual capital of the corporation or made publicly available through an open source license agreement. As with other software creation, open software consists of two major elements: Development and Distribution.
• Open collaboration development methodology—Open collaboration occurs at many levels, from sharing ideas and concepts for a project, to sharing code that has often been constructed following an agile methodology. The drivers for collaboration vary, but the core of the methodology is a symbiotic relationship between the leaders that started the project and the collaborators. A successful open software engagement is one in which everybody wins and recognition is insured because of the inherently transparent development process. Many enterprises have recognized the value of collaboration and social tools and create their own solutions using open collaboration. Even when the resulting code is not made publicly available, these corporate open development initiatives leverage great minds across the business, resulting in the best possible product.
• Open source distribution—If you want your hot, new solution accepted broadly, what better way than to give it away! Later in this chapter, we look at some high-profile examples of open source distribution. Essentially this method of distribution is the bread-and-butter of many companies, especially startups that leverage the LAMP software stack—an acronym for Linux, Apache, MySQL, Perl/PHP/Python, and lately could also include Ruby. Using LAMP, a host of consortiums, companies, and technical communities create software that is made available for free. Keep in mind, however, that just because software is in the open source community, it doesn’t necessarily mean that it was created in an “open collaboration” methodology. Code is sometimes made available in the open source community as a defensive strategy to blunt another company’s competitive advantage, or when a company goes out of business. In some cases, software is made available as open source because the original creators need assistance from the community.
For example, a startup company might have the resources to create a solution that works with ten devices, but there are another 200 services from five different software platforms and vendors that could benefit from the solution. By making the code available to the open source community, the members of the community can help create additional extensions to support new services. A good example of the way companies have leveraged this concept is Jaiku—a micro blog service similar to Twitter. Google acquired Jaiku in October 2007, and went to work diligently to integrate the tool into their Google app engine. A few months later the entire JaikuEngine was declared open source under the Apache License 2.0 and is now available on Google Code Project, where anyone can use it and run their own JaikuEngine instance. Although Google will no longer actively develop the Jaiku codebase, it was smart to make it open source, because now it can benefit from the contributions of thousands of passionate developers. These contributions ensure the services remain vibrant with new service extensions.
With an understanding of the two elements of open software—development and distribution—we turn our attention to the virtuous cycle of development at the heart of open software. The common tools of the LAMP stack and the collaborative power of social networking (wikis, blogs, and forums), which facilitates open development, combined with the boundless energy of dedicated programmers, have converted open software into a powerful business strategy. Geographically separated communities of programmers (including the best minds in a particular technical discipline) can collaborate to improve open source code, each for their own reasons. Financial pressure to bring a solution to market quickly might drive one company, whereas market pressures to lower the cost of overall IT solutions through reuse of software might drive another. For some open communities, it seems there is just a pragmatic recognition that Social Age collaboration is here to stay and that proprietary platforms are often just relics of an earlier technological age.
Combining open collaboration methodology and open source distribution creates a potent virtuous cycle. The cycle begins with a great idea that addresses a problem or customer pain-point.
Prototyping by the originator of the idea—whether an individual or team—is next. In this step, the value of the solution is validated and credibility is established. With the confidence gained from approval by their peers, innovators might publish a paper about their idea and findings. The technical community reviews, evaluates, and critiques the idea, often using public forums, wikis, or blogs. Additional ideas emerge from the discussions, and eventually, a strong technical leader emerges in the community. This leader typically has great technical insight and charisma and is frequently a community connector. He or she takes the lead to create an open source project to build a new implementation.
An Open Source Success
Elias Torres
Elias Torres is director of engineering at Boston-based Lookery, a user-targeting service company. Elias is also an enthusiastic participant in open source communities, especially those focused on distributed and collaborative systems projects.
“Open Source communities are an excellent vehicle to grow your technical abilities,” Elias said, “because of the freedom you have to experiment. The collaboration and support provided by other users and developers in the community is a great encouragement.”
Because open technology is free, Elias said that companies using open source projects can focus resources on their core business rather than on building solutions “from scratch.” These companies add value and innovation by carefully combining software and hardware. They create reliable and profitable products and services.
Elias noted that there is a welcome abundance of information available on the Internet when evaluating open source projects and their technologies. Use cases, competing product analyses, tutorials, bug archives, and mailing lists are all available. Perhaps most importantly, you can quickly—and directly—contact project authors.
Highscalability.com, for example, is a great place to learn about the best architectures and software to build scalable Web sites. Prepare to be dazzled by the amazing amount and quality of information freely available, not only on highscalability.com, but also on any Web site focused on open source.
Open source and collaborative software development are a new mind-set in software; they are part of a cultural revolution that is enabled and driven by the incredible power of social networking.[2]
The company or team that built the first implementation will sometimes make the code publicly available with the hope that it will get assistance from programmers in the open source community. As the community starts collaborating and building code together, more synergy is created. With time the “long tail” of contributors, along with a passionate core team of programmers, can often create a better implementation.
With a new open source implementation now available, programmers use the open source community to generate more reference implementations that fit their industry and solutions. Collaboration generates many code examples and a wealth of educational material. Relevant forums, wikis, and blogs become a testament of the project evolution, technical decisions functionality, and problems encountered along the way. The virtuous cycle keeps progressing and augmenting the value provided by the open source community, as seen in Figure 8.1.
At the heart of a successful open source project are good collaboration tools that enable communication, social interaction, and tracking of source code. Traditional Source Control Management (SCM) systems, such as CVS (Concurrent Versions Systems), don’t fit well with the dynamic aspect of open source, in which the software code is modified and forked constantly by many people loosely linked by collaboration tools. Linux is an example of a large open source project that experimented with alternative SCM approaches. In 2002 Linux used BitKeeper to track the operating system kernel changes but finally moved to Git, in June 2005, as the official tracking system for Linux.
Git was designed and implemented by Linus Torvalds (best known for his contribution to the Linux kernel), who had the idea to create a distributed SCM. Git differentiates itself from other traditional SCM in that it was designed for open source collaboration; with Git, forking and merging are greatly facilitated. Git also maintains ancestry on the history of prior branches and makes possible keeping track of changes across many source trees. Better yet, it minimizes bottlenecks by enabling multiple replicas of the code via “pull” and “push” capabilities. These capabilities help contributing programmers have the source code in multiple, decentralized locations that harmonizes with the way in which the community works. The Linux kernel has thousands of line changes every day, with thousands of programmers around the world contributing to the code. This dynamic rewrite of the Linux code actually generates a completely rewritten kernel every couple of years. Another key factor contributing to the success of an open source project is the quality of the community that supports the effort. The community needs a strong leader or core team to establish good communication and attract a variety of technical skills. The open source community leaders not only contribute back into the community with changes, but they also create work streams to explore alternatives and use their influence to gain acceptance. A great example of this kind of leadership, and of the virtuous cycle, is the Apache Software Foundation. The goal of Apache is to teach a small group of developers, who work on open source projects, the best way to grow, communicate, and collaborate efficiently to make the project a success.
Among the best-known examples of open source software are the Linux operating system, Apache web server, mySQL database, and interpreted programming languages such as Perl and PHP. Referred to as the LAMP stack, these are usually installed on Linux servers and capable of running on most operating systems. The technology industry has rallied around the LAMP stack as a viable alternative to more complex and expensive commercial solutions.
Most web applications today require the dynamic presentation of end-user-submitted content. The LAMP stack supports the development and deployment of such systems, offering a solid operating system, fast database, integral programming languages, and an increasingly popular web server. Some of the most popular Web sites today were built completely on an open software platform, with custom software riding on top.
Open software, however, goes beyond the idea of open source. It is best considered a superset of open source—applying the principles of working out in the open, supporting standards, designing for integration, and planning for extensibility to commercial solution development. This is a profound departure from traditional software development, where a small number of stakeholders drive the vision and requirements for the development team.
A myriad of other applications might enjoy significant benefit from a more dynamic, communal approach to software design and creation. Open software demonstrates the possibilities of team-developed software and the culture change required to do it well. In many ways, open software aided by social tools can be seen as an industry revolution and establishment of a new mind-set. It is this new mind-set, coupled with financial pressures and a desire for standardization, which will push further adoption of open source and collaboration development processes.
Even if you don’t shop at Amazon.com, you probably go there (as we do!) to compare prices or read merchandise reviews. But what’s behind the scenes at this incredibly fast retail Web site? Tens of thousands of servers linked together around the world all working with no failures, right? Wrong! At Amazon.com, the systems are failing constantly. With tens of thousands of servers, avoiding system failure would be impossible. The key to Amazon.com’s “always on” service is to effectively and transparently manage failure. Werner Vogels is the Amazon.com CTO and mastermind of the cleverly designed Dynamo solution, which runs on Amazon.com core services, providing this “always-on” level of service. In an October 2007 paper, Vogels and several key technical leaders of Amazon.com described Dynamo and the strategy behind this key-value storage system.[3]
This paper was a great milestone in software development because it made the intellectual property available to the technical community. This sparked great interest and development activity. Immediately after the paper was published, many technical and thought leaders began creating improvements and ideas for implementations. Many LinkedIn engineers got involved in early implementations that resulted in a new open source project called Project Voldemort.[4] LinkedIn is now one of the supporters of this open source community providing resources to contribute to the code and—it is hoped—gain influence in the direction of the open source project.
Jay Kreps, senior software engineer at LinkedIn, is the leader that created Project Voldemort. Jay drives and inspires the team; he provides the strong leadership required to ensure a successful open source project. Project Voldemort is a compelling example of the virtuous cycle of open software at its best. In this case, powerful technology concepts moved from Amazon.com to the dynamic creativity of the open source collaboration environment.
Google was selected in 2008 as the best global brand by BusinessWeek.[5] And no wonder; who doesn’t make regular use of this powerful and appealing technology? Google is, of course, a good—some would say the best—search engine, accessing massive data on thousands of servers, but there’s a not-so-secret ingredient that drives the Google business.
That ingredient, called “MapReduce,” was describedd in a 2004 paper[6] by Google’s Jeffrey Dean and Sanjay Ghemawat. This technology reduces and manages large data sets and is at the core of Google’s success with search engines. Dean and Ghemawat’s paper described in detail the MapReduce structure and implementation. After it was in the open technical community, this paper inspired incredible creativity for the best way to enable large-scale, parallelized computations across large computer clusters.
Shortly after the publication of Dean and Ghemawat’s paper, open source advocate and search specialist Doug Cutting stepped up to the task of creating a new open source project. Hadoop was the result.[7] The Hadoop project charter was essentially to create a new, open source implementation of MapReduce. Yahoo quickly saw the value of using the open source community to help improve its search technology. It supported Hadoop development by hiring Doug Cutting, who now is dedicated fulltime to leading the Hadoop community. Yahoo has benefited by the Hadoop community effort and uses it to improve some of its services.
Open source software equals free software, right? Well, not so fast. In the early years of the Internet, when open source was first on the scene, it was heresy to suggest that software could one day be “free.” Proprietary commercialization of software was dogma in the technology business. After all, when a company spent millions of dollars developing an application, didn’t it have the right to reap the rewards of that effort? Didn’t it have the right to shrink wrap, at the cost of a few dollars, a couple of CDs and a user manual and sell it for hundreds of dollars to recoup its investment? And what about intellectual property? Recall the browser wars of the late 1980s and early 1990s when Netscape and Microsoft® battled it out in the marketplace and later in the courts. It was in this context that the power of the people first began to be felt in the realm of open source software, and we started to hear the term “Linux” everywhere we turned.
Just because the operating system and development languages were free, however, didn’t mean the applications wrote themselves. There is a cost to anything that contributes value and, with open source, the cost is usually not monetary in nature. Consider the key attributes of open source software and their related costs:
• Transparency—The source code for the entire solution is made available for anyone to download, inspect, compile, build, use, extend, and redistribute.
Contributors work out in the open, creating an interesting and public peer pressure to deliver good code. In the early days of television, a children’s program closed with the host looking through her “magic mirror” at the camera and saying, “I see Bobby, and I see Jane, and I see Eric....” In the world of open source development, the magic mirror is held up to every developer; and that developer’s work is subject to intense peer scrutiny—and comment! Delivering solid code and frequently updating an open source application carries a nonmonetary cost of time, attention, and uncompromised personal commitment to the development community.
• Diversity—The core development team is often diverse, representing individual and institutional views. This means that the requirements for a given solution are not controlled by any one owner. Leaders emerge in open projects, but primary responsibility is sometime distributed across a few diverse individuals. Meeting the needs of a broad user base means a price must sometimes be paid in terms of compromise and flexibility with individual requirements.
• Commitment to collaborate—Finally, open source software is developed in a highly collaborative fashion. If the seventeenth-century poet John Donne had been cranking out open source code in 2009, he might have said, “No developer is an island, entire of themselves.” Effective open source teams need to be constantly engaged in dialogue, as with a traditional development team. As we said, open development increases the pressure of the team to deliver to the best of their capabilities. And because the collaboration extends to anyone who wants to contribute, bugs are more easily identified in this context, and code extensions and patches can be more efficiently surfaced.
Taken as a whole, these three characteristics of open source software highlight perhaps the primary cost of this important resource: One individual or one organization cannot control the evolution of the open source product. The primary means of influencing development is through contribution, which means businesses must dedicate development resources to an open project—not just a wish list.
Although software might be available through open source at no monetary cost, the risks and investments are still important considerations that must not be overlooked by the would-be open source developer.
In the Social Age, collaborative open source development is not just for developers. As we might expect, collaborative development now extends to end users as well.
In an earlier age of software development, the opinions of users, if not distained, were certainly often minimized. “We know what consumers want,” was the self-confident assertion of many developers and decision makers. In the Social Age, however, such an attitude has increasingly been shown to result primarily in lost customers and dwindling market share. When consumers are given a voice through the power of social networking, development cycles are enriched through meaningful and relevant user feedback. Features aren’t added just because a developer thinks they’re neat; they’re added because they meet or exceed the expressed expectations of the target user.
Here we return to the tremendous power of the virtuous cycle, executed most efficiently in the context of social networking. How do we know what consumers want in their software? With the combined power of open software and social networking, they tell us!
In addition, when solutions are designed and developed collaboratively, there is shared investment and recognizable satisfaction when the product addresses the specific concerns of a contributor. Open source development moves beyond the logistics of code sharing and management; it moves us to a model of cocreation. This is a model that thrives in an environment of openness, collaboration, and the acknowledgment of interdependence in achieving success.
As early as 1999, IBM’s innovation labs were leading the way in open source development. Working with the enterprise instant messaging product Lotus Sametime, innovators explored integration with other IBM products and the use of publish/subscribe messaging as a means for unique collaboration. Although Sametime is not specifically an open source application, the development methodology—including intense user feedback—was quintessential “open” and provides helpful insights into the process.
The Sametime 7.5 development team had an existing Sametime user base to leverage for feedback and testing during the development of the upgrade. There was also an enthusiastic, knowledgeable community of early adopters for Sametime 7.5, which embraced and helped develop other innovation projects at IBM through the Technology Adoption Program (TAP). Although ultimately a resounding success, the Sametime 7.5 development process was not always smooth. Growing pains were felt as early adopter feedback was integrated with the typical software development process.
“It was difficult—painful—to the team to receive such negative feedback so early,” said Sametime development team leader Konrad Lagarde.[8] “One thousand people in a week [testing] the alpha 1 was bigger than we thought. A lot of developers were not paying attention initially to the bugs that were found in the [alpha 1 and 2] releases. Alpha 3 and 4 is when we hit 5,000 [users], and the development team was starting to see the impact of their work—and starting to fix the bugs and really pay attention to things. [At one point we were managing] 2,100 bugs in bugzilla!”[9]
Because of the tremendous synergy between the user community and development team, in the course of six months, the Sametime 7.5 team ultimately released nine alphas and four betas. This is only meaningful when one considers that a milestone in typical, traditional software development is one beta per year! But the business result of open development was clear: Leveraging the collective intelligence of the early adopter community dramatically shortened the software development cycle, while simultaneously returning a much more usable product.
As we said, this success didn’t come without a price. Change and growth can be stressful but are also usually deeply rewarding. Moving from a single beta per year in traditional software development to three, four, or even five betas in open development can certainly create stress points. Specifically the Sametime 7.5 development team faced a different kind of stress, arising from the requirement to act on and incorporate near-real-time customer feedback. As Sametime development team leader Lagarde said,
There was a lot of churn for the team, and a lot of stress, but we saw a reality in how the product was really improving. We could validate things directly with our customer, [which] is incredible. They could vent, they could be honest, [they] could receive builds to show [that] what they were saying was being addressed—real time, on demand and immediately.[10]
Just how successful was the Sametime open development project? Before the first copy shipped to a customer, more than 50,000 enthusiastic early adopters at IBM had upgraded from Sametime 3.1 to Sametime 7.5 as their regular instant message tool.
As he reminisced about the experience, Konrad Lagarde said it perfectly: “Good software is not designed by committee; but it is validated by a community.”[11]
The move to open software is a cultural movement at most organizations, an evolution of sorts, in much the same way the Social Age is an evolutionary advance from the Information Age. The evidence that open development is embraced by commercial enterprises can be seen in the drive to standardization in the context of service oriented architecture (SOA), and in the integration of existing open source as the basis for commercial offerings.
There is undeniable power in approaching solution development with an open software mind-set. Done properly, open development attracts diverse talent from outside the formal walls of an organization, who both benefit from and contribute to the solution. Which developer wouldn’t benefit from having more eyes on the code? Any developer will tell you that addressing challenges and issues as early as possible is always a good thing. Less-seasoned developers can be educated on how to best approach software engineering challenges. Finally, empowering the development community, even in a traditional business, and democratizing the creation of a solution, efficiently distributes responsibility and ownership. The result is high morale and shared commitment to accomplish more.
Leadership is distributed in open development and, just as in any democracy, a few individuals help guide others to achieve the collective goal. The open software methodology is a conscious approach to create better software solutions by lowering the center of gravity or decision making to the team doing the work. This is a substantial departure from the traditional organizational hierarchy, where decisions are made at the top by managers or project managers with limited knowledge of the intricacies of the code. The loosely connected network of the open software community is a substantial business advantage over traditional software development.
Open software transforms the proprietary nature of traditional solution development. For decades, consumers were confronted with the carefully shielded black box of commercial software development. Who knew how the solution worked? The attitude seemed to be, “You don’t really need to know, do you? It works, doesn’t it?” And when modifications were needed for specific purposes, the black box seemed more like a black hole.
With the growing popularity of open source, however, the computer code is open to essentially anyone. The reuse of the code is, therefore, much more likely, and the resulting solutions much more broadly adopted. The dawn of the Social Age brought a new mind-set that increases usage of open software solutions, lowering costs, and accelerating time to market, as illustrated in Figure 8.2. This is one of the powerful drivers for leveraging open software to deliver business value, but there are other ways it can transform your business as well.
To understand what it takes to succeed as a globally integrated enterprise, the open software movement is a good place to start. Leveraging the many advantages of open software development is critical when managing and facilitating communities that cross geographical and organizational boundaries. Global development is not about simply hiring developers in an emerging market, as you might do at your domestic locations. Instead, global development means successfully extending the capabilities of your existing team to the places it is needed and using the talent best able to deliver on the specs. The technologies and mind-set used to successfully drive open source and open software apply to successfully building global development teams as well.
Mature open source software has often been developed by dozens of developers and includes generally applicable features and functions. For example, most server-based open operating systems, such as Linux, come with e-mail services, which enable a company to provide the capability without custom development.
The cost of supporting an open solution is different than its development—usually less. A more readily available and affordable skill set can be used to run and support a developed product.
Participation is one of the key costs of open software and one of its major benefits. Genuine participation in development communities can strengthen the team and align specific business goals with the overall solution. In some cases, open source software is even adopted as the foundation for commercial products and services. Some commercial open source licenses for proprietary products ship with source code for ease of integration and extension. Three examples of this trend include the IBM HTTP Server, Drupal content management, and Sun Microsystems’ MySQL database.[12]
The IBM HTTP server has long used the Apache web server as its foundation. IBM contributes developers to the Apache web server community, but more importantly it ships the software as part of its WebSphere®[13] product line. Through participation and extension, IBM can provide a feature-rich web server that integrates tightly with its other products, specifically IBM WebSphere Application Server.
IBM’s focus and development is not in changing the underlying web server—that’s handled by the developers participating in the Apache community. Instead, IBM focuses on extending the web server as the basis for an integrated solution that is simpler and more fully featured.
Drupal is an open source content management system (CMS) with a vibrant development community that has transformed the core solution from basic Web site building to a feature-rich collaboration platform. A few years ago, a small startup, Acquia,[14] began offering commercial products, services, and support for Drupal. Acquia packages the core Drupal engine and includes select extensions from the development community, along with its own modules.
In many ways, Acquia acts as a bridge to the open source community for its customers, ensuring the publicly available extensions have a high reliability and a well-defined release schedule. Two modules included with Acquia’s distribution enables it to understand the usage of its Drupal distribution and notify customers of updates. Formal support rounds out Acquia’s services, providing hesitant businesses confidence with an open source platform.
In 2008, Sun Microsystems purchased the company that held the copyright for the extremely popular open source MySQL database. With 11 million installations, MySQL is simpler to use than many commercial counterparts. MySQL—the “M” in the LAMP open source software stack—offers enviable low maintenance and is included by Sun as part of its overall software and services portfolio.
IBM HTTP Server, Drupal, and MySQL highlight real business solutions using open source as a foundation. In many ways, open software is a natural fit with commercial opportunities because the focus of the community is on the best possible software development. In the example of Acquia, its presence actually solidifies and matures the image of the Drupal offering. Open source software can enhance a product portfolio—and a bottom line—and can often be delivered as a competitive differentiator.
Innovation in the software business can be tricky, especially in the context of open source. In cases where the product distinguishes a business—for example Adobe’s Photoshop—open solutions are not viable options. Adobe is certainly aware of open source GIMP (GNU Image Manipulation Program) but is unlikely to use or contribute to the GIMP code. On the other hand, a company that is focused on Linux-based video manipulation might see GIMP as a complementary asset, especially if the feature is not a competitive differentiator. Where the goal is innovation, rather than a specific development platform, open source software can be a powerful innovation accelerator.
Innovation results from thoughtful design and experimentation and is crucial for distinguishing any business from the competition. To experiment—in products, processes, or services—a well-established business builds on established platforms, which accelerates innovation by providing a foundational starting point. Future innovation for competitive advantage will happen not in making adjustments to the base but in radically rethinking the capabilities on top of that base. Although this approach is most easily seen in product innovation, process and service innovation follow the same pattern.
Prototyping is a common activity in innovation and requires a design (in reality or on paper) using existing known elements. Often the process of prototype design creation and testing yields invaluable lessons and seeds ongoing improvements and transformation. Open source software facilitates and accelerates prototyping, leading more quickly to the ultimate goal—innovation.
Consider the Drupal example. With Drupal, a business can construct a content management system similar to the Acquia distribution as a way to enable Web 2.0 experiences. Perhaps a key business driver for the company is to understand user experience when searching for information. Innovating with Drupal offers distinct advantages. First, the basic capabilities already exist—content management, user registration, and so on. Second, extending the platform is easily done with PHP, a popular and easy-to-write development language. Third, the company’s proprietary search engine can easily be integrated with the platform, creating a rich test environment. These three factors focus development on the business goal of understanding the way users search for information and the way searches change over time.
Leveraging open source and open software as the basis for accelerating innovation is a powerful, relatively painless approach to solution development.
In the context of the open source movement, open software involves a set of principles that can drive transformative culture change in an organization. Consider the three attributes previously noted in open source software:
• The source code for the entire solution is made available for anyone to download, inspect, compile, build, use, and extend.
• The core development team is often diverse, representing individual and institutional views.
• The software is developed in a highly collaborative setting.
Wouldn’t every business benefit from having more of these traits throughout the organization? When encouraged as a cultural shift, traditional behaviors can change in the context of a more open-minded approach.
First, self-motivated teams allow management to refocus on the overall organizational vision and act as a sounding board, rather than overseeing day-to-day operational execution. Power is shared in this model but so is responsibility. Operational teams in this setting are not only self-motivated but also embrace increased responsibility for the outcomes and success of their work.
Second, the traditional management team begins to value diversity in building its teams. Diversity introduces new thinking and ideas; it acts to stabilize the team’s self-interested activity, exploring reasonable alternatives—a sort of check and balance. The group benefits from the variety of thought, whereas management gains from a team balanced through individual selection rather than top-down command and control.
Third, moving work into public forums highlights the responsibility of each individual to the shared goals of the group. Management supports an overt shift in sharing work products, as it does with software development, inviting critical thought at every step of the process.
For management, there’s a trade-off in this scenario. It gives up a level of operational control, but gains—or regains—the roles of visionaries, diversity mavens, and high-performance culture czars, while retaining the ultimate power of veto. Such behaviors can take time to adopt, even with progressive teams. For a time, there might be some adjustments to the new freedoms and the increased emphasis on results, rather than on process and hierarchies.
Applying the attributes and behaviors of grassroots organizations to formal business can be a powerful by-product of the open source movement, where the focus is not on software development but on culture change.
Open Source Software has created many business opportunities, but there remain notable challenges in leveraging these solutions. The legal issues of open source and its potential impact to the business are not widely understood. The community nature of the development environment presents another issue. A community is not an enterprise, and the specific challenges of business use are sometimes ignored or minimized in this setting. Likewise, an individual company doesn’t have veto power in the community. Despite committed participation, a company might find it is out-voted by the community when it comes to the future of the solution. Finally, open source software is still software, which means there will always be bugs. Let’s consider these issues in greater detail.
Copyright laws generally give authors an implicit copyright for their work, but they can also often register their work for public and legal recognition of rights to their work. For example, in the United States, these rights include reproducing the work and creating derivatives based on the original work, among others. When deciding whether to work with someone else’s creation, be sure to consider the copyright holder and the restrictions of the license.
Sorting out individual copyright is best left to experienced legal counsel, but for those who choose to go it on their own, there are public licenses that define what others can do with the work. Examples of public licenses include Creative Commons, GNU, Apache, and BSD. Each license has different characteristics, which permit, prescribe, or restrict specific actions.
Legal issues tend to be the primary reason many organizations prefer to work with open source that is represented by other companies, such as IBM, Sun Microsystems, and others. Fully understanding your legal rights and obligations—preferably with the guidance of an experienced attorney—is a necessary first step when considering open source development.
Open source software is often the product of small groups of individuals that share a common vision. As development teams grow, design, and implement, decisions are often dispersed. Fragmented solutions or bloated software can result. Although this can happen in any large software organization, open source is particularly challenged in this regard.
In addition, enterprises often require specific performance, scalability, and distribution characteristics from their software—requirements sometimes absent from open source solutions. Standard corporate architectural and development practices are largely unknown to open source communities. This can mean these solutions are difficult to adopt and integrate into existing formal development environments. Considerable planning and potential participation in the open source community are sometimes required to successfully leverage open source for a specific business need.
Participation can be a key to influencing open source projects, but participation does not necessarily mean control. If there are organization-specific capabilities that are incompatible with the goals of the open source project, those capabilities might need to be developed outside the community. Control also cannot be exerted by a business when it comes to the longevity of an open source community. There is no formal agreement that ensures the developed product will exist in the future, and no guarantee that the community will remain intact. Participation is clearly a line of defense for a community that dissolves, but it only partially addresses the risk. The vitality of the community is a critical part of evaluating the maturity of an open source project.
With all the wisdom gained in his decades in the computer business, Fredrick Brooks, Jr., soberly reminds us that software is software, and all software has bugs; including—we’re sure he’d agree—community-developed software. Despite the potentially increased number of people reviewing open source code, bugs will always be part of software development.
Content management systems (CMS) are extremely powerful tools enabling people with limited technical skills to author, review, publish, and manage web content. Popular commercial CMS products include Fatwire, Vignette, Interwoven, Adobe Contribute Publishing Server, and Lotus Web Content Management. In this space, the open source options outnumber commercial offerings 2:1. Wordpress, Joomla, and Drupal are popular open source CMS tools. Web content administration and authoring is done with these tools through a web browser, so changes to the site appear instantaneously. By comparison, with traditional static content replication systems, changing even one word on a Web site might take hours and involve half a dozen people.
CMSs are the foundation for building much larger communication and collaboration spaces. Some CMS systems, such as Wordpress, are best-known for their blogging capabilities. Joomla is known for traditional web content and site creation. Drupal offers a far more complex set of tools that integrate many capabilities into a single platform. When compared with commercial offerings, these open source tools are extremely lightweight—typically “one-click” installs.
Support for custom business processes and workflow management are the reason for the complexity of most commercial CMSs. Open source content management tools are great for small and medium businesses that are not as concerned about rigorous, auditable transactions.
All the open source packages mentioned here offer custom themes enabling you to match your business’ design standards. The more specific the requirements, the better the technology fit. Understand the role of open source in your environment and plan accordingly.
Open software is another manifestation of the powerful collaboration possible using Social Age tools and methods. Whether a small group of developers gathers around a specific project, or a worldwide team collaborates on a major corporate initiative, open software provides the necessary development framework to make it happen.
• Open source tools push against the traditional hierarchical nature of organizations and focus on people connections.
• Open source is merely a subset of capabilities that support grassroots-style workforces. As businesses continue to grow beyond local borders, the flexibility of their workforce and the technology that enables them will be a major success factor.
• Keep in mind that free is not always free of expenses. The costs of a commercial offering should always be compared with the costs of “free” open source solutions. The axiom “You get what you pay for” applies in the world of open source and in the commercial software market.
• Smart selection and application of open source tools, based on your business goals and culture, can enable your workforce in profound ways. Incremental introduction and careful future upgrades of these tools help ensure success. Even if you end up with a commercial offering in a particular area, open source is an excellent way to determine if a specific capability will catch on.
• Creating and enabling the grassroots culture in your organization, using open source technology as a starting point, is one of the most significant ways to generate growth for your business in the Social Age.