We are currently living through a pivotal time in the software industry. Traditionally, it is well-known that there is a worldwide shortage of software developers and many boards believe that access to developers is more of a risk than access to capital. But in recent history, this has been exacerbated post-covid with the great resignation as many software developers jumped organisations to breathe some clear air.
The resulting demand for software developers has increased again. With many organisations reporting falling well short of their hiring targets. One tactic worth considering to help with this industry trend is to consider the impact that automation can have on a software team. In other words, get the most out of what you already have.
Software teams love to automate. This is not a new concept and your team is likely already doing this to some degree, but what is exciting and new is how some modern technologies and methodologies can be combined in novel ways to take automation to the next level. Especially when taking on large legacy modernisation projects or simply dealing with the volume of work put onto your department.
In this article, we propose that there is an intersection of three important practices that will have a positive impact on your software teams and how they use automation; these are Jikoka, DevOps, and models. Ultimately, this will have a knock-on effect and will have a positive impact on the entire organisation.
Have you heard of the Toyota Production Systems (TPS)? If not, you would have heard of the term Kanban being thrown around. Kanban is more than just a board where issues or sticky notes are moved between columns, it is a software development methodology that rivals Scrum with all of its own practices. Kanban takes a lot of inspiration from lean manufacturing and philosophies such as TPS.
An example is the so-called Kaizen, which encourages continuous improvements through steady increments that simplify operations. A lesser-known practice is Jidoka, which loosely translates to automation with a human touch.
In essence, Jidoka means that humans meticulously build each new component by hand ensuring that the quality is sound and it meets any organisational standards. Then, once the component is ready, they transfer this craftmanship to a machine or robot. Eventually, the value added by the human diminishes, meaning any operator can achieve the same result through automation. This is continuously improved using Kaizen.
Even though parts of the software industry have embraced Kanban and in a sense Kaizen. The other important part of the philosophy, Jidoka, still has more research and potential to make it well-known and practised by software developers.
DevOps will heal the world
Have you heard of DevOps? Of course, you have. It is a hugely popular buzzword at the moment and rightly so. DevOps started in an effort to break down the barriers between development and operations. In a lot of organisations, these two departments are separated and this gap creates a wall. The result can have a negative impact on the organisation with issues such as long release times and poor-quality products.
The question then becomes how do we break down these barriers? Operations want to make sure standards are followed as they are the ones holding the baton at the end of the day after the development team has scattered into the wind. While development teams are under pressure to meet deadlines but those long standard specs from operations are slowing them down and they can’t test their applications in realistic environments. So, how do we heal some of these wounds?
The answer is pipelines.
A pipeline brings another dimension to software development. Personally, I believe it is as important as when Einstein discovered spacetime and showed that time is the fourth dimension. Similarly, pipelines bring a whole new dimension to software development across the axis of time. Software development must be more than just lines of code. For example, through pipelines, we can make a build and release process that is repeatable, which ensures quality. But most importantly, it is automated.
Everything is a model
Have you heard of Model-Driven Engineering (MDE)? Maybe not, but MDE is catching on in Europe and making some amazing inroads. The reason for its gain in popularity stems from its ability to take on some of the grand challenges of software engineering, such as abstraction. In recent times, our industry has learnt that the more complexity you push into source code the quicker technical debt climbs and maintainability is lost. Abstraction is a way to deal with this and models create abstraction.
The first tenet of MDE is everything is a model. And when we say everything is a model, we mean everything; source code is a model, a database is a model, requirements are a model, diagrams are a model, domain-specific concepts are models, data is a model, that thing you drew on the white-board is a model, and on and on … you name it, it is a model.
By accepting everything is a model opens up the world to doing useful things with these models. Software developers can make formal and strong connections (links) between these models to transform, generate, and validate, to name just a few practices of MDE. But the important point is this, the models and the connections between them create the opportunity to automate! Without them, there are air gaps that would need to be bridged with manual processes. And in reality, air gaps are as bad as walls.
There are many challenges to building a successful software project. The current world climate with a shortage of software developers means we need to look closer at how we are building software. We can no longer afford to simply throw more bodies at the problem, we need to get smarter about what we are doing.
Taking some inspiration from other industries on their successes is a healthy exercise. One such inspiration comes from lean manufacturing and the practice of Jidoka, automation with a human touch. In summary, let's handcraft new components as we solve problems but leave a path of automation so we can do it again with less cost and at scale. This makes sense but how do we do that?
This is where the conversation shifts to using DevOps and MDE. The DevOps practice of using pipelines creates a mechanism whereby we can automate many parts of software development while breaking down the walls between development and operations. In addition, by acknowledging everything is a model, we can bridge the air gaps between different systems and create even more opportunities for automation using MDE.
DevOps with MDE is like a good glass of wine and a cheese platter, they just go well together. Using DevOps toolchains in Agile MDE is cutting edge and your organisation can do this today.
Interested in learning more about automation and MDE? The Codebots white paper further explains how automation technology can be applied to software development to help your organisation no matter where you are in your digital transformation journey.