The Wicked Witch of the West had it wrong. In the land of Oz, she feared getting wet and melting away, but for software development in our world, becoming liquid is exactly what you should be seeking to do.
The liquid software revolution is already underway, advancing steadily toward reality as DevOps takes firmer hold in enterprises. Development and deployments are moving away from fixed, versioned releases, toward streams of verified software components. Ultimately, this can feed a steady river of trusted continuous updates that flow reliably to computing environments and devices.
So, how liquid are you now? Will your development pipeline be able to easily join the flow, or will you drown in the coming flood?
It’s not just about being ready for the future, either. Even in its nascent forms today, liquifying the software development process produces huge benefits in faster and more frequent releases at lower cost.
This approach emphasizes production of small, functional components instead of big application packages, for more complex, machine-meaningful versioning. It’s enabled by greater use of automation, to produce a seamless and fluid flow of continuous updates.
Truly liquid software has yet to exist, but it’s on its way. The requirements are being driven in part by rich technologies like IoT where thousands of devices need to be kept reliably and safely current, or perform secure rollbacks at high scale when flaws are found.
Becoming liquid ready
How ready are your software development processes to join the currents? How can you help melt the barriers and help your costs decline, and increase productivity and profits?
Here are the essential things you needd to have in place to grow toward liquefaction:
Commit to DevOps
The liquid software revolution aims to produce continuous updates, the next evolutionary outcome in DevOps. So you’ll need to have strong DevOps systems and practices in place now.
Today, DevOps software development practices support continuous delivery (CD), in which code changes are automatically built, tested, and prepared for a release to production. This is made possible by continuous integration (CI) practices, which feed all code changes through testing and production environments after they’re built.
The cycle of CI/CD reduces time to fix bugs and accelerates delivery of features – the essential groundwork for a system of continuous updates.
Where CD produces frequent updates, bringing sets of fixes and features in a new version, continuous update accelerates this with miniaturized updates. Each update may have fewer changes, but occur more frequently, in a system of small, but continuous improvements.
Having the right things in place means investing in the infrastructure that will support it, from your source repositories, to the CI servers, and the ability to manage the large number of binaries that these procedures will produce. Just as important, and at least as challenging, is growing the team culture that makes DevOps thrive.
Move to Microservices
Rivers are made of tiny drops, so liquefying means shifting development strategies to small, focused pieces of software that do one thing well.
In traditional software development, an entire application is tied to a single codebase. But as software has moved to running online, that’s proved slow and costly, and burdensome to scale.
Instead, more development processes demand breaking code into independent microservices that run as separate processes. Applications become a collective, orchestrated effort across them, as output from one independent service is used as an input to another.
It’s an early step to liquifying your software, as specific functions can be readily updated and scaled at low cost. Code becomes more resilient as well, even as the cadence of updates accelerates.
Using container technology like Docker is a good step to shifting to microservices, and building in smaller components that layer into powerful applications. Multiple containers can run in isolation from each other, even as they share the same kernel. And you’ll need the tools that can maintain a registry of those images for deployment through an orchestration tool like Kubernetes.
Establish a Promotion Pyramid
Your CI/CD pipeline will generate a very large number of binaries as code moves from development, test, staging and production, a challenge that will only grow as you liquify toward continuous updates.
Having a clear promotion pyramid in your pipeline will help you to manage that volume. It will bring each release through a uniform life-cycle of staging for validation and QA before it gains a final promotion to where it can found and used. This essential process will distill the rush of binaries down to deploying only those with the lowest risk.
Establishing this clear hierarchy will enable the trusted continuous updates that being truly liquid can deliver.
Achieving this will require tools that can manage the growing quantity of binaries produced, recognize them as units of builds, and control their visibility as they are promoted through their stages.
Informate to Automate
Keeping updates truly continuous means eliminating as many needs for human intervention as you can. Every time a person needs to approve or review something is like damming your updates stream, slowing flow and flooding backward.
The more your procedures for validation, promotion, and deployment of software through the CI/CD pipeline are automated, the stronger and steadier your current of updates will be.
What enables this is metadata, information that lets our automated tools make sensible decisions about whether or not a piece of software and all its component pieces are sound. That includes metadata about the origin of a component, its history, and the results of validation steps.
This information helps choose whether your software gets promoted through its pipeline stages toward release and deployment. It can include internal metadata generated about your own projects and dependencies, and external metadata about other parts (such as open-source components) you use.
That requires the tools that can manage that metadata, which can come from a variety of other tools and sources. It will need to integrate smoothly with your promotion and deployment automation, to help your liquid system cascade smoothly outward.
Liquifying your software development processes pays off in the form of a faster, more resilient, and more reliable flow of updates at increasing scale. When you find yourself shouting “I’m melting!” it won’t be a cry of anguish, but one of triumph.
