Language
.svg){kind=small}
.svg)
.svg)
DevOps started as a revolutionary movement to bring systems administrators and developers closer together and has grown to become a ubiquitous presence in the modern tech industry. DevOps fundamentals are based on the idea that you can improve software release speed, quality, and efficiency by improving communication and ownership across departments and applying Agile principles to infrastructure and development. In this article, we take a look back at the history of DevOps, describe the foundational practices and how they’ve evolved. Then we’ll discuss where we are today and where we’re headed in the future.
Since DevOps places such a heavy focus on turning everything into software, it may come as a surprise that the movement (and the name) was created by a systems administrator instead of a developer. Belgian sysadmin Patrick Debois was frustrated by the divide between IT operations and development teams, finding that it created unnecessary misunderstanding and delays in production. Around 2008, he and other like-minded sysadmins founded the Agile Systems Administration Group. This group believed that Agile development principles could be applied to infrastructure teams to streamline workflows and bring developers and sysadmins closer together.
In 2009, Debois organized an event called DevOpsDays, a portmanteau of development, operations, and days. An impressive group of sysadmins, developers, and other industry leaders came together to discuss how these teams could use Agile and other practices to work together more efficiently and create better quality products in less time. The hashtag #DevOps — and the revolutionary principles that were born from the event — spread like wildfire.
DevOps fundamentals, as they were conceived at the beginning, were based on Agile principles. Over the years, they’ve evolved to incorporate new ideas, best practices, and technologies. Let’s take a look at where DevOps started, and where we are now.
DevOps wouldn’t have been possible without Agile. The Agile methodology breaks software development projects into a series of small and repeatable processes. Every aspect of software creation — development, testing, and deployment — is performed in short sprints in an iterative cycle. This makes it possible to find and fix issues earlier in development and pivot on a dime when requirements change.
Debois and other forward-thinking sysadmins thought that applying Agile principles to infrastructure management would make it easier for the operations team to support development projects. They sought ways to break down infrastructure tasks into iterative processes, both to increase the speed at which they could provision environments for developers and to take advantage of the flexibility of Agile practices. One of the ways they were able to apply Agile to infrastructure was with Infrastructure as Code (IaC).
IaC was developed independently of the Agile and DevOps methodologies, but the technology complements both practices and has thus become a core component of DevOps infrastructure. With DevOps IaC, infrastructure configurations are managed as software code that’s decoupled from the underlying physical or virtual devices. These infrastructure scripts or definition files are repeatable and automatable, increasing the speed and accuracy with which infrastructure teams can deploy new resources. IaC reduces operational bottlenecks in DevOps pipelines because it enables sysadmins to quickly respond to developer requests or changes in development requirements.
IaC technology has evolved over the years, beginning with configuration management tools like Microsoft System Center and progressing to continuous configuration automation (CCA) tools like Puppet and Chef. CCA allows operations teams to quickly and automatically spin up new environments, update existing infrastructure, patch security vulnerabilities, and more without adding significant delays to development cycles.
Continuous Integration, or CI, is the practice of committing and integrating code changes on a continuous basis. Continuous Delivery, or CD, involves continuously delivering code builds to the next stage of the pipeline. Both ideas have been around for a while, but it wasn’t until the advent of reliable and ubiquitous test automation that CI/CD was fully actualized.
Test automation allows developers to constantly check in new code without worrying about integration issues, bugs, or security vulnerabilities. It also ensures that code can be automatically delivered to the next stage without needing to wait for manual tests to run. Modern DevOps teams now rely on CI/CD with test automation to create more streamlined development cycles and increase the speed of software releases.
Though DevOps is possible in on-premises environments, it shines in the cloud. Cloud resources are more flexible and scalable than traditional data center infrastructure, which makes it easier for operations teams to keep up with Agile software development. In addition, Cloud-based infrastructure is often delivered as a service that’s decoupled from the underlying hardware, which makes automation and IaC easier. To fully take advantage of the benefits of cloud infrastructure, developers began to use a cloud native approach to writing and running software.
Cloud native simply means using processes and tools that are built for the cloud from the ground up, rather than trying to adapt legacy systems and workflows to a cloud infrastructure. Often, that means using containers, which were initially developed in the early 2000s but didn’t gain too much traction until Docker came out in 2013. Once Google released the Kubernetes platform for large-scale container orchestration in 2014, cloud native container adoption became even more mainstream. Nowadays, cloud native DevOps is almost synonymous with container orchestration.
Low-code technology is a way to streamline and simplify both the Dev and Ops processes involved in a DevOps pipeline. Low-code is a way of creating, manipulating, and managing software and infrastructure code without needing to manually write everything. Low-code uses GUI (graphical user interface) tools like visual models and drag-and-drop to reduce the amount of tedious coding that’s needed to create software or IaC. It’s particularly useful for things like creating the basic framework of an application or developing prototypes for new features. Low code platforms also provide code editing functionality in addition to GUI tools so DevOps teams can do as much or as little manual coding as needed for the particular situation.
Low-code technology, particularly for software and web development, has been around for a long time. However, these tools have grown more sophisticated and have expanded their reach to IaC management and even software-defined networking. This is especially true in the cloud native and software as a service (SaaS) space, where platforms like Salesforce provide a fully integrated ecosystem of low-code tools and services. Through low-code technology, DevOps teams can further increase the efficiency of development and infrastructure processes for a more streamlined software release cycle.
It’s important to note that DevOps fundamentals have evolved and improved, but the core principles have remained the same. DevOps began by using Agile practices to improve collaboration between developers and sysadmins and create a more streamlined process for delivering high-quality software. Now, DevOps accomplishes these goals through the use of CI/CD with test automation, cloud native practices, and low-code technology. Moving into the future, organizations are relying more heavily on outside consultants to guide their DevOps journey and accelerate their digital transformation, according to the results from the 2021 State of Salesforce DevOps report. In particular, there is a growing demand for Salesforce DevOps experts who can help companies stay at the forefront of cloud native, low-code software development.
Level up your Salesforce DevOps skills with our resource library.
.svg)
.svg)
.svg)
.svg)
.avif)
.avif)
.avif)
