Behind the modern convenience of nearly everything is the art of abstraction. My father-in-law has a tractor from 1930 that he still uses to this day. Despite observing his movements as best as I could, I would not be able to drive it. There’s no gas pedal, instead there’s a throttle, which sits near the steering wheel on a steel quadrant. It can be adjusted up or down, controlling how much fuel pours into the engine. The more fuel, the more RPM. When you let go of the break, the tractor jolts into motion—and you better hope you’ve adjusted the throttle accordingly!
Can you imagine if this was how people had to get from point A to point B? Using a throttle? Luckily, our driving experience has been abstracted from the mechanics of the modern engine. Most of us are familiar with the key, the pedal, the break and the manufacturer has abstracted everything else. We don’t know how it works, but we trust it does.
The process of abstraction has been at the forefront of application technology, not only in how we develop applications and how we test, but also how we deploy and maintain them. The No-Code Revolution has empowered organizations to scale and change faster than ever via abstraction, impacting processes that once required teams of developers so that the business can focus on the business.
In this post, we will examine the evolution of abstraction. This includes not only what abstraction means but also how it impacts DevOp tooling and processes.
Evolution and abstraction
Abstraction hides detail. It allows us to use a piece of code as if it were a black box—that is, something whose interior details we cannot see, don’t need to see, and shouldn’t even want to see. The essence of abstraction is preserving information that is relevant in a given context, and forgetting information that is irrelevant in that context. (John V. Guttag, 2o16, Introduction to Computation and Programming Using Python, MIT Press, p. 49)
In computing, abstraction is about making the user’s life easier. A user interface is an abstraction. The user only sees labels and the values they provide. They don’t see the database. They don’t need to call the update method, or know what table the data belongs to. That information is abstracted from them. Abstractions aren’t just for the end user, the principle makes developers’ lives easier as well. Consider interacting with an API. The API only needs a few values passed in a parameter while the service handles the logic and implementation.
Just over the last few years, abstraction has evolved considerably. A terminal and command line interface was an abstraction from binary code. An operating system is an abstraction from a computer’s underlying hardware. Even Developers are abstracted from most of the operations they interact with – importing libraries and leveraging development building blocks. Now, with no-code and low-code platforms, almost all the details are left to the “backend” while developers get to put the needs of their users first.
From front end websites, to backend databases, the no-code revolution is abstracting everywhere. Nowhere is the evolution of abstraction more welcome than DevOps. Packaging code, testing, tracking, and deploying changes has traditionally been kept to those versed in the world of GitHub, command line, and complicated file directories. It’s getting easier.
How has abstraction served DevOps?
DevOps is first and foremost a mindset of continuous improvement. Continuous improvement relies on a persistent focus on the process. Making processes repeatable, predictable, and limiting the possibility of error is the goal of mature DevOps tooling. And abstraction is the way.
DevOps is a relatively new discipline in relation to development. Development was done in silo, deployments were built from scratch, and ops was only notified when something broke. This causes more production issues, lack of communication and alignment, and many late nights and early mornings.
So, why don’t more organizations opt for DevOps? One of the obvious hurdles to DevOps adoption was the lack of technical skill. Migrating and monitoring changes is technical. In order to place as much emphasis on ops as development, the development team would effectively have to be doubled.
Enter the power of modern DevOps tooling and abstraction, which brings non-developer users at the helm of DeOps to focus on changes, not implementation. The core discipline of DevOps is its processes. Abstraction is what makes that focus possible.
Benefiting from abstraction
DevOps tooling aligns with DevOps processes: Planning, building, testing, deploying and monitoring. Here’s how each have benefited from abstraction:
- Planning: An elegant kanban displays tasks, work in progress, epics, and sprints while the actual data is hosted in the cloud in some database who’s structure is not known by the user. The user benefits from the process automation and integrations, all of which work behind the scenes.
- Building: Libraries, low-code, and no-code solutions let developers drag and drop elements, connect third party applications, and construct powerful automation all while abstracting most of the technical implementation.
- Testing: Calling a method with Espresso, or recording browser interactions are both modern miracles when it comes to testing applications. Tools like Sofy take it a step further by leveraging machine learning and natural language processing to create well-designed automated test scripts without any code. Sofy does most of the heavy lifting for you.
- Deploying: Packaging metadata, containers, configuration management, version control—all of these are parts of the deployment process. As development teams are pressured to make more deployments, sometimes many in one day, abstraction reduces the technical, step-by-step, manual procedural tasks of pulling, pushing, merging, and committing. Frameworks like Jenkins, give DevOps teams the ability to employ continuous integration.
- Monitoring: DevOps monitoring and observability lets teams monitor their entire stack, report on application health, predict future issues, and communicate with the team. Abstraction is once again at play. (Read our take on top Observability tools.)
Conclusion
The evolution of abstraction has brought us where we are now – empowered with the vast collection of low-code and no-code tooling. We’re more efficient than ever, as the hard, repetitive work is being done behind the scenes. The benefits of the abstraction for DevOps bring a major win to the entire organization.
Disclaimer: The views and opinions expressed above are those of the contributor and do not necessarily represent or reflect the official beliefs or positions of Sofy.
