{"id":21232,"date":"2018-10-15T10:42:48","date_gmt":"2018-10-15T15:42:48","guid":{"rendered":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/"},"modified":"2018-10-15T10:42:48","modified_gmt":"2018-10-15T15:42:48","slug":"a-cambrian-explosion-of-devops-tools","status":"publish","type":"post","link":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/","title":{"rendered":"Project to Product: A Cambrian Explosion of DevOps Tools"},"content":{"rendered":"<figure>\n<div class=\"feature-image\"><img decoding=\"async\" class=\"aligncenter size-full\" src=\"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/mik-kersten-project-to-product-blog-series-850x357.png\" alt=\"Project to Product: A Cambrian Explosion of DevOps Tools\"><\/div>\n<\/figure>\n<p><span style=\"font-weight: 400\">Any discussion of how to scale the benefits of DevOps invariably lands on tools. The planning, tracking, automation, and management tools we use define the &#x201C;ground truth&#x201D; of where and how work happens. One of the most interesting, and at times challenging, aspects of agile and DevOps transformations is the sheer volume of tools involved. How many are required? Must there be so many? Before we proceed further on our journey of defining value stream architecture, let&#x2019;s look at how this ground truth has evolved to get us where we are today.<\/span><\/p>\n<div id=\"ez-toc-container\" class=\"ez-toc-v2_0_80 counter-hierarchy ez-toc-counter ez-toc-grey ez-toc-container-direction\">\n<div class=\"ez-toc-title-container\">\n<p class=\"ez-toc-title\" style=\"cursor:inherit\">Table of Contents<\/p>\n<span class=\"ez-toc-title-toggle\"><a href=\"#\" class=\"ez-toc-pull-right ez-toc-btn ez-toc-btn-xs ez-toc-btn-default ez-toc-toggle\" aria-label=\"Toggle Table of Content\"><span class=\"ez-toc-js-icon-con\"><span class=\"\"><span class=\"eztoc-hide\" style=\"display:none;\">Toggle<\/span><span class=\"ez-toc-icon-toggle-span\"><svg style=\"fill: #999;color:#999\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" class=\"list-377408\" width=\"20px\" height=\"20px\" viewBox=\"0 0 24 24\" fill=\"none\"><path d=\"M6 6H4v2h2V6zm14 0H8v2h12V6zM4 11h2v2H4v-2zm16 0H8v2h12v-2zM4 16h2v2H4v-2zm16 0H8v2h12v-2z\" fill=\"currentColor\"><\/path><\/svg><svg style=\"fill: #999;color:#999\" class=\"arrow-unsorted-368013\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"10px\" height=\"10px\" viewBox=\"0 0 24 24\" version=\"1.2\" baseProfile=\"tiny\"><path d=\"M18.2 9.3l-6.2-6.3-6.2 6.3c-.2.2-.3.4-.3.7s.1.5.3.7c.2.2.4.3.7.3h11c.3 0 .5-.1.7-.3.2-.2.3-.5.3-.7s-.1-.5-.3-.7zM5.8 14.7l6.2 6.3 6.2-6.3c.2-.2.3-.5.3-.7s-.1-.5-.3-.7c-.2-.2-.4-.3-.7-.3h-11c-.3 0-.5.1-.7.3-.2.2-.3.5-.3.7s.1.5.3.7z\"\/><\/svg><\/span><\/span><\/span><\/a><\/span><\/div>\n<nav><ul class='ez-toc-list ez-toc-list-level-1 ' ><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-1\" href=\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#The_Catalyst_for_DevOps_Tool_Diversification\" >The Catalyst for DevOps Tool Diversification<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-2\" href=\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#Why_the_Explosion\" >Why the Explosion?<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-3\" href=\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#Dealing_with_Diversity\" >Dealing with Diversity<\/a><\/li><\/ul><\/nav><\/div>\n<h2><span class=\"ez-toc-section\" id=\"The_Catalyst_for_DevOps_Tool_Diversification\"><\/span><b>The Catalyst for DevOps Tool Diversification<\/b><span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><span style=\"font-weight: 400\">We&#x2019;re at an interesting time in the evolution of DevOps tools; the sheer number of available tools points to a sort of Cambrian explosion of tool specialization and diversity. Is all this diversity necessary? Will a big wave of consolidation drive the extinction of most of these tools? What are the lines of specialization driving the diversity, and do we need to consider them when architecting our software value streams? We need to address these questions and inspect the ground truth captured in today&#x2019;s toolchains in order to inform the discussion of how to abstract away the tools&#x2019; implementation details to focus on the architecture of our value streams.<\/span><\/p>\n<p><span style=\"font-weight: 400\">For two decades starting in the 1980s, the company providing the majority of enterprise IT shops with software development tools was Rational. For many organizations, the entire software lifecycle was tracked within the Rational toolchain. While it&#x2019;s tempting to poke fun at heavy-weight tools while talking DevOps, Rational created a toolchain that was incredibly sophisticated and effective for its time. Along with the tools, Rational created the Rational Unified Process (RUP), a cohesive and tool-supported process framework for software engineering. RUP provided IT and software delivery organizations with end-to-end visibility, control, and predictability for large software initiatives, thereby becoming the poster child for waterfall methodology. In the 1990s, both the toolchain provided by Rational and the process and methodologies around it expanded rapidly.<\/span><\/p>\n<p><span style=\"font-weight: 400\">Then, in the 2000s, agile happened, largely as a reaction to problems with the command-and-control style of managing software delivery that waterfall and RUP enabled. The agile movement was followed in the 2010s by the DevOps movement, and both have now disrupted the age of waterfall. <\/span><a href=\"http:\/\/insights.stackoverflow.com\/survey\/2017.\"><span style=\"font-weight: 400\">The 2017 Stack Overflow survey<\/span><\/a><span style=\"font-weight: 400\"> indicated that 76.9 percent of the respondents use agile methods, whereas 26.9 percent use waterfall (n5 25,771). Although many large organizations still follow the waterfall model, the benefits of faster lead times and smaller batches that come with agile and DevOps are now part of the well-documented state of the practice.<\/span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"Why_the_Explosion\"><\/span><b>Why the Explosion?<\/b><span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><span style=\"font-weight: 400\">A disruption this fundamental can bring with it a change of an entire market. In this case, the DevOps tool market formed to fill the gap created by the waterfall model&#x2019;s displacement. You can glimpse this disruption&#x2019;s scope through the GrowthPoint Technology Partners DevOps Startup Landscape Map (see Figure 1), courtesy of Jake Kaldenbaugh, who carefully tracks the tools space.<\/span><\/p>\n<p><span style=\"font-weight: 400\">Most of the many vendors on this map are vying to provide a repository or automation layer for a segment of the software value stream. What&#x2019;s fascinating are both the sheer number of vendors and the distinct tool categories that have emerged. Another piece of evidence comes from a study in which my company Tasktop examined the toolchains of 300 Enterprise IT organizations. We determined that 70 percent of those organizations already integrated three or more tools and that 40 percent integrated four or more tools.<\/span><\/p>\n<p><span style=\"font-weight: 400\">In addition, the adoption of open source tools, such as Git, has rapidly increased over the same time frame. The 2017 Stack Overflow survey indicated that Git has achieved 69.2 percent adoption (n5 30,730), with Rational ClearCase at 0.4 percent by comparison.<\/span><span style=\"font-weight: 400\"><sup>1&#xA0;<\/sup>This very rapid adoption of Git and its disruption of heavier-weight tools indicates an important trend. Agile, DevOps, and open source all have something in common: they&#x2019;re driven from the bottom up, with each focusing on empowering the practitioner. Like other disruptions, they represent a breakup of the top-down control model and a &#x201C;democratization&#x201D; of the tool chain. What&#x2019;s clear from Figure 1 is that this bottom-up democratization goes against the one-size-fits-all mentality of the tools that preceded it. The sheer number of tool categories indicates a specialization of tools that didn&#x2019;t exist before. That specialization is driven by the needs of the different types of work involved in software delivery.<\/span><\/p>\n<p><span style=\"font-weight: 400\">As software development has scaled, practitioners have sought tools specialized for their roles. For example, a tool that tracks customer tickets and focuses on service-level agreements (SLAs) differs considerably from one that tracks issues in an agile backlog or one that that&#x2019;s targeted at business analysts modeling customer use cases and workflows. Under the hood, the tools might appear nearly identical in terms of their data models and collaboration facilities and workflow engines. That&#x2019;s why in the past, organizations could use a single tool for the different tasks. However, as the work has scaled, so has the number of practitioners.<\/span><\/p>\n<p><span style=\"font-weight: 400\">As a result, practitioners have demanded user experiences that provide systems of engagement tailored to their role. This has pressured vendors to specialize their offerings, with the resulting Cambrian explosion of the toolchain. Consider the various categories to be different evolutionarily stable strategies for vendors, with diversity within and across categories driven by a resource-rich market of organizations building bigger and bigger software.<\/span><\/p>\n<figure id=\"attachment_9818\" aria-describedby=\"caption-attachment-9818\" style=\"width: 924px\" class=\"wp-caption alignnone\"><img class=\"lazyload\" alt height=\"688\" data-src=\"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/screen-shot-2018-10-15-at-11.38.06-am.png\"><figcaption id=\"caption-attachment-9818\" class=\"wp-caption-text\">FIGURE 1. A glimpse into the exploding number of DevOps tools, which are filling the gap created by the waterfall model&#x2019;s displacement. (Source: GrowthPoint Technology Partners; used with permission.)<\/figcaption><\/figure>\n<h2><span class=\"ez-toc-section\" id=\"Dealing_with_Diversity\"><\/span><b>Dealing with Diversity<\/b><span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><span style=\"font-weight: 400\">So, are these tools actually headed for a mass extinction? The analysis of the 300 organizations&#x2019; toolchains revealed two types of tool diversity. <\/span><i><span style=\"font-weight: 400\">Fundamental diversity <\/span><\/i><span style=\"font-weight: 400\">adds value by increasing software delivery productivity. For example, teams developing Java applications might be more productive using Jira, whereas teams developing with Azure and .NET might be more productive using VSTS (Visual Studio Team Services).<\/span><\/p>\n<p><i><span style=\"font-weight: 400\">Accidental diversity <\/span><\/i><span style=\"font-weight: 400\">doesn&#x2019;t contribute positively to organizational goals. This category includes tools inherited through mergers and acquisitions or similarly functioned tools that were selected independently owing to a lack of centralized governance. For example, an organization could have three bug trackers: a 20-year-old legacy tool created in house, a new developer-favoured issue tracker, and an open source issue tracker that resulted from an acquisition.<\/span><\/p>\n<p><span style=\"font-weight: 400\">From a value stream architecture viewpoint, both types of diversity must be accounted for. Accidental diversity should motivate organizations to consolidate and rationalize. This activity is relatively straightforward; it simply implies that the value stream should contain only one tool for each required tool category. What&#x2019;s more problematic is when organizations can&#x2019;t distinguish between accidental and fundamental diversity.<\/span><\/p>\n<p><span style=\"font-weight: 400\">While examining value streams, we&#x2019;ve identified six varieties of fundamental diversity:<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400\"><i><span style=\"font-weight: 400\">Stakeholder specialization<\/span><\/i><\/li>\n<li style=\"font-weight: 400\"><i><span style=\"font-weight: 400\">Scale specialization<\/span><\/i><\/li>\n<li style=\"font-weight: 400\"><i><span style=\"font-weight: 400\">Platform specialization<\/span><\/i><\/li>\n<li style=\"font-weight: 400\"><i><span style=\"font-weight: 400\">Zone specialization<\/span><\/i><\/li>\n<li style=\"font-weight: 400\"><i><span style=\"font-weight: 400\">Supplier diversity<\/span><\/i><\/li>\n<li style=\"font-weight: 400\"><i><span style=\"font-weight: 400\">Legacy<\/span><\/i><\/li>\n<\/ul>\n<p><span style=\"font-weight: 400\">Although all organizations should aim to weed out accidental diversity, the norm today is a heterogeneous, best-of-breed toolchain. While the fast growth of startups and new vendors means some consolidation seems inevitable, enough need exists for specialization that I predict the heterogeneity will grow further before shrinking.<\/span><\/p>\n<p><span style=\"font-weight: 400\">For example, enterprise IT organizations are starting to move away from the project-aligned value streams that have a lifecycle aligned to the project time frame and budget. Instead, organizations are employing the software-and-tool-vendor approach of product-oriented value streams. This shift from <a href=\"http:\/\/projecttoproduct.org\/\">project to product<\/a> is resulting in the growth of yet another category of product management tools, somewhere between traditional requirements and agile planning.<\/span><\/p>\n<p><span style=\"font-weight: 400\">Also, as software development becomes more complex, so will the specialization of the toolchain. This is similar to other fields (such as the medical field) in which the benefits of the division of labor have caused ever-increasing specialization in expertise. As software complexity grows, so will the number of specialized practitioners, driving further specialization of the tools.<\/span><\/p>\n<p><span style=\"font-weight: 400\">The problem is that, when we try to analyze and improve how software is built, the morass of tools makes it difficult to see the forest for the trees. No single tool has a model of the end-to-end system. Yet value streams will continue to be defined in tools, with each delivery stage implemented in a specific tool&#x2019;s scheme and workflow model. But to take the next step in DevOps, we need to start thinking end-to-end. The only way to achieve that is to establish an architectural discipline for managing the layer above the toolchain.<\/span><\/p>\n<p><span style=\"font-weight: 400\">The evolution of toolchains will continue, as will the specialization that meets the needs of each stakeholder involved in software delivery. Here, I outlined why this specialization, and the resulting tool diversity, is a fundamental aspect of the modern DevOps toolchain. To learn more about how we approach raising the abstraction level and modeling the layer above the toolchain, click on the front cover of <\/span><i><span style=\"font-weight: 400\">Project to Product<\/span><\/i><span style=\"font-weight: 400\"> below to pre-order a copy:<\/span><\/p>\n<p><a href=\"https:\/\/www.amazon.com\/Project-Product-Networks-Transform-Business\/dp\/1942788398\"><img class=\"lazyload\" alt height=\"312\" data-src=\"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/07\/project-to-product_mik-kersten.jpg\"><\/a><\/p>\n<p><b>Sign up to the <\/b><b><i>Product To Project<\/i><\/b><b> newsletter<\/b><\/p>\n<p><span style=\"font-weight: 400\">This is the fourth blog in a series promoting the genesis of my book <\/span><a href=\"https:\/\/www.amazon.com\/gp\/product\/1942788398\/ref=as_li_qf_asin_il_tl?ie=UTF8&amp;tag=itrevpre-20&amp;creative=9325&amp;linkCode=as2&amp;creativeASIN=1942788398&amp;linkId=ffdc9afd5d2bc7ae3d2336db701fd0c0\"><i><span style=\"font-weight: 400\">Project To Product<\/span><\/i><\/a><i><span style=\"font-weight: 400\">. <\/span><\/i><span style=\"font-weight: 400\">If you missed the first three blogs, <\/span><a href=\"\/mik-kersten\"><span style=\"font-weight: 400\">click here<\/span><\/a><span style=\"font-weight: 400\">. And to ensure you don&#x2019;t miss any further blogs, you can receive future articles and other insights delivered directly to your inbox by signing up to the <\/span><a href=\"https:\/\/go.tasktop.com\/Mik-Kersten-List-Signup.html\"><span style=\"font-weight: 400\">Project To Product newsletter<\/span><\/a><span style=\"font-weight: 400\">.<\/span><\/p>\n<p><b><i>A version of this article was originally published in the March 2018 issue of IEEE Software<\/i><\/b><b>: M. Kersten, &#x201C;A Cambrian Explosion of DevOps Tools,&#x201D; &#xA0;<\/b><b><i>IEEE Software<\/i><\/b><b>, vol. 35, no. 2, pp. 14-16,&#xA0;<\/b><b>&#xA9;2018 IEEE <\/b><b>doi: <\/b><b>10.1109\/MS.2018.1661330<\/b><b> &#x2013; <\/b><a href=\"https:\/\/ieeexplore.ieee.org\/document\/8314153\"><b>Original article<\/b><\/a><\/p>\n<p><b>References<\/b><\/p>\n<ol>\n<li style=\"font-weight: 400\"><span style=\"font-weight: 400\">G. &#xA0;Kim et &#xA0;al., <\/span><i><span style=\"font-weight: 400\">The &#xA0;DevOps &#xA0;Handbook: &#xA0;How to Create &#xA0;World-Class Agility, &#xA0;Reliability, and Security &#xA0;in Technology Organizations<\/span><\/i><span style=\"font-weight: 400\">, &#xA0;IT Revolution, &#xA0;2016.<\/span><\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"<p>Any discussion of how to scale the benefits of DevOps invariably lands on tools. The planning, tracking, automation, and management tools we use define the &#x201C;ground truth&#x201D; of where and how work happens. One of the most interesting, and at times challenging, aspects of agile and DevOps transformations is the sheer volume of tools involved&#8230;.<\/p>\n","protected":false},"author":222,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"_editorskit_title_hidden":false,"_editorskit_reading_time":0,"_editorskit_is_block_options_detached":false,"_editorskit_block_options_position":"{}","footnotes":""},"categories":[9547,9544,9543],"tags":[],"class_list":["post-21232","post","type-post","status-publish","format-standard","hentry","category-devops-teams","category-project-to-product-shift","category-value-stream-management"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v26.8 (Yoast SEO v26.8) - https:\/\/yoast.com\/product\/yoast-seo-premium-wordpress\/ -->\n<title>Project to Product: A Cambrian Explosion of DevOps Tools | Tasktop Blog<\/title>\n<meta name=\"description\" content=\"One of the most challenging aspects of agile and DevOps transformations is the sheer volume of tools involved. How many are required? Must there be so many?\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Project to Product: A Cambrian Explosion of DevOps Tools\" \/>\n<meta property=\"og:description\" content=\"One of the most challenging aspects of agile and DevOps transformations is the sheer volume of tools involved. How many are required? Must there be so many?\" \/>\n<meta property=\"og:url\" content=\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/\" \/>\n<meta property=\"og:site_name\" content=\"Planview Blog\" \/>\n<meta property=\"article:publisher\" content=\"http:\/\/www.facebook.com\/pages\/Planview-Inc\/89422974772\" \/>\n<meta property=\"article:published_time\" content=\"2018-10-15T15:42:48+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/mik-kersten-project-to-product-blog-series-850x357.png\" \/>\n<meta name=\"author\" content=\"Mik Kersten\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@Planview\" \/>\n<meta name=\"twitter:site\" content=\"@Planview\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Mik Kersten\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/\"},\"author\":{\"name\":\"Mik Kersten\",\"@id\":\"https:\/\/blog.planview.com\/#\/schema\/person\/6be5164e0beb8c6fe553a8baed3610c1\"},\"headline\":\"Project to Product: A Cambrian Explosion of DevOps Tools\",\"datePublished\":\"2018-10-15T15:42:48+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/\"},\"wordCount\":1651,\"publisher\":{\"@id\":\"https:\/\/blog.planview.com\/#organization\"},\"image\":{\"@id\":\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/mik-kersten-project-to-product-blog-series-850x357.png\",\"articleSection\":[\"DevOps Teams\",\"Project to Product Shift\",\"Value Stream Management\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/\",\"url\":\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/\",\"name\":\"Project to Product: A Cambrian Explosion of DevOps Tools | Tasktop Blog\",\"isPartOf\":{\"@id\":\"https:\/\/blog.planview.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/mik-kersten-project-to-product-blog-series-850x357.png\",\"datePublished\":\"2018-10-15T15:42:48+00:00\",\"description\":\"One of the most challenging aspects of agile and DevOps transformations is the sheer volume of tools involved. How many are required? Must there be so many?\",\"breadcrumb\":{\"@id\":\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#primaryimage\",\"url\":\"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/mik-kersten-project-to-product-blog-series-850x357.png\",\"contentUrl\":\"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/mik-kersten-project-to-product-blog-series-850x357.png\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/blog.planview.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Project to Product: A Cambrian Explosion of DevOps Tools\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/blog.planview.com\/#website\",\"url\":\"https:\/\/blog.planview.com\/\",\"name\":\"Planview Blog\",\"description\":\"Leading the conversation on digital connected work\",\"publisher\":{\"@id\":\"https:\/\/blog.planview.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/blog.planview.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/blog.planview.com\/#organization\",\"name\":\"Planview\",\"url\":\"https:\/\/blog.planview.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/blog.planview.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/blog.planview.com\/wp-content\/uploads\/2015\/06\/planview-logo-black.png\",\"contentUrl\":\"https:\/\/blog.planview.com\/wp-content\/uploads\/2015\/06\/planview-logo-black.png\",\"width\":280,\"height\":66,\"caption\":\"Planview\"},\"image\":{\"@id\":\"https:\/\/blog.planview.com\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"http:\/\/www.facebook.com\/pages\/Planview-Inc\/89422974772\",\"https:\/\/x.com\/Planview\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/blog.planview.com\/#\/schema\/person\/6be5164e0beb8c6fe553a8baed3610c1\",\"name\":\"Mik Kersten\",\"description\":\"Dr. Mik Kersten started his career as a Research Scientist at Xerox PARC where he created the first aspect-oriented development environment. He then pioneered the integration of development tools with Agile and DevOps as part of his Computer Science PhD at the University of British Columbia. Founding Tasktop out of that research, Mik has written over one million lines of open source code that are still in use today, and he has brought seven successful open-source and commercial products to market. Mik\u2019s experiences working with some of the largest digital transformations in the world has led him to identify the critical disconnect between business leaders and technologists. Since then, Mik has been working on creating new tools and a new framework - the Flow Framework\u2122 - for connecting software value stream networks and enabling the shift from project to product. Mik lives with his family in Vancouver, Canada, and travels globally, sharing his vision for transforming how software is built, and is the author of Project To Product, a book that helps IT organizations survive and thrive in the Age of Software.\",\"url\":\"https:\/\/blog.planview.com\/author\/mik-kersten\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Project to Product: A Cambrian Explosion of DevOps Tools | Tasktop Blog","description":"One of the most challenging aspects of agile and DevOps transformations is the sheer volume of tools involved. How many are required? Must there be so many?","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/","og_locale":"en_US","og_type":"article","og_title":"Project to Product: A Cambrian Explosion of DevOps Tools","og_description":"One of the most challenging aspects of agile and DevOps transformations is the sheer volume of tools involved. How many are required? Must there be so many?","og_url":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/","og_site_name":"Planview Blog","article_publisher":"http:\/\/www.facebook.com\/pages\/Planview-Inc\/89422974772","article_published_time":"2018-10-15T15:42:48+00:00","og_image":[{"url":"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/mik-kersten-project-to-product-blog-series-850x357.png","type":"","width":"","height":""}],"author":"Mik Kersten","twitter_card":"summary_large_image","twitter_creator":"@Planview","twitter_site":"@Planview","twitter_misc":{"Written by":"Mik Kersten","Est. reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#article","isPartOf":{"@id":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/"},"author":{"name":"Mik Kersten","@id":"https:\/\/blog.planview.com\/#\/schema\/person\/6be5164e0beb8c6fe553a8baed3610c1"},"headline":"Project to Product: A Cambrian Explosion of DevOps Tools","datePublished":"2018-10-15T15:42:48+00:00","mainEntityOfPage":{"@id":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/"},"wordCount":1651,"publisher":{"@id":"https:\/\/blog.planview.com\/#organization"},"image":{"@id":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#primaryimage"},"thumbnailUrl":"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/mik-kersten-project-to-product-blog-series-850x357.png","articleSection":["DevOps Teams","Project to Product Shift","Value Stream Management"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/","url":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/","name":"Project to Product: A Cambrian Explosion of DevOps Tools | Tasktop Blog","isPartOf":{"@id":"https:\/\/blog.planview.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#primaryimage"},"image":{"@id":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#primaryimage"},"thumbnailUrl":"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/mik-kersten-project-to-product-blog-series-850x357.png","datePublished":"2018-10-15T15:42:48+00:00","description":"One of the most challenging aspects of agile and DevOps transformations is the sheer volume of tools involved. How many are required? Must there be so many?","breadcrumb":{"@id":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#primaryimage","url":"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/mik-kersten-project-to-product-blog-series-850x357.png","contentUrl":"https:\/\/media.planview.com\/tasktop_blog\/wp-content\/uploads\/2018\/10\/mik-kersten-project-to-product-blog-series-850x357.png"},{"@type":"BreadcrumbList","@id":"https:\/\/blog.planview.com\/a-cambrian-explosion-of-devops-tools\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/blog.planview.com\/"},{"@type":"ListItem","position":2,"name":"Project to Product: A Cambrian Explosion of DevOps Tools"}]},{"@type":"WebSite","@id":"https:\/\/blog.planview.com\/#website","url":"https:\/\/blog.planview.com\/","name":"Planview Blog","description":"Leading the conversation on digital connected work","publisher":{"@id":"https:\/\/blog.planview.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/blog.planview.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/blog.planview.com\/#organization","name":"Planview","url":"https:\/\/blog.planview.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/blog.planview.com\/#\/schema\/logo\/image\/","url":"https:\/\/blog.planview.com\/wp-content\/uploads\/2015\/06\/planview-logo-black.png","contentUrl":"https:\/\/blog.planview.com\/wp-content\/uploads\/2015\/06\/planview-logo-black.png","width":280,"height":66,"caption":"Planview"},"image":{"@id":"https:\/\/blog.planview.com\/#\/schema\/logo\/image\/"},"sameAs":["http:\/\/www.facebook.com\/pages\/Planview-Inc\/89422974772","https:\/\/x.com\/Planview"]},{"@type":"Person","@id":"https:\/\/blog.planview.com\/#\/schema\/person\/6be5164e0beb8c6fe553a8baed3610c1","name":"Mik Kersten","description":"Dr. Mik Kersten started his career as a Research Scientist at Xerox PARC where he created the first aspect-oriented development environment. He then pioneered the integration of development tools with Agile and DevOps as part of his Computer Science PhD at the University of British Columbia. Founding Tasktop out of that research, Mik has written over one million lines of open source code that are still in use today, and he has brought seven successful open-source and commercial products to market. Mik\u2019s experiences working with some of the largest digital transformations in the world has led him to identify the critical disconnect between business leaders and technologists. Since then, Mik has been working on creating new tools and a new framework - the Flow Framework\u2122 - for connecting software value stream networks and enabling the shift from project to product. Mik lives with his family in Vancouver, Canada, and travels globally, sharing his vision for transforming how software is built, and is the author of Project To Product, a book that helps IT organizations survive and thrive in the Age of Software.","url":"https:\/\/blog.planview.com\/author\/mik-kersten\/"}]}},"_links":{"self":[{"href":"https:\/\/blog.planview.com\/wp-json\/wp\/v2\/posts\/21232","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.planview.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.planview.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.planview.com\/wp-json\/wp\/v2\/users\/222"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.planview.com\/wp-json\/wp\/v2\/comments?post=21232"}],"version-history":[{"count":0,"href":"https:\/\/blog.planview.com\/wp-json\/wp\/v2\/posts\/21232\/revisions"}],"wp:attachment":[{"href":"https:\/\/blog.planview.com\/wp-json\/wp\/v2\/media?parent=21232"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.planview.com\/wp-json\/wp\/v2\/categories?post=21232"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.planview.com\/wp-json\/wp\/v2\/tags?post=21232"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}