About that low-code apocalypse
It is that cheerful time of year again. Let’s take a moment and ponder about future events which might spell bitter doom over my programming career. The low-code apocalypse.
I have adopted a reading habit which helps me counter the imposter syndrome which one inevitably gets working in todays fast moving tech landscape. In short this means trying to read as much as possible about anything related to my field of programming. I do this to have at least a basis of knowledge to work on in case I need it and it amounts to a weekly reading list of about 30 articles. It is interesting to see certain topics pop up more and more over time and one of these is low-code development, which supposedly will put me out of a job somewhere in the near to distant future.
As far as I understand low-code development basically comes down to creating software without to much actual programming effort. An example would be using some graphical user interface where software can be assembled dragging around building blocks, but I am pretty sure this is just one of the ways you could go about this.
As you can guess from this somewhat naive description it is clear I haven’t actually tried low-code yet, so feel free to use that as a counter argument any time you want. In any case it is an interesting topic and instead of writing an ignorant but comforting article why low-code will not put me out of work, let’s summarise some scenarios why this might, or might not actually happen.
Yep: It is already happening
Obviously I would not be writing about low-code if there wasn’t movement in that area, and there are indeed already suppliers out there such as Mendix, Bubble, Airtable and Retool.
As mentioned I haven’t used any of these so I am not able to give quality feedback on that account. I am pretty sure however they offer an environment with predefined functionality suitable for creating decent software, albeit with the trade-off of being limited to that functionality. Perhaps there is some way to inject custom lambda-like code tied to life-cycle events similar to those in React, Vue etc. But again, I am just guessing here.
Another thing to consider in the area of low-code is the use of Developer orientated services such as GitHub’s Copilot. This can generate code based on a relatively simple textual description, which seems pretty amazing. This is used while programming off course, so it will not put any developers out of job any time soon. But is has much potential as you can image.
All in all you can say that low-code has certainly found its way in a software developers life. It is difficult to judge to which extend exactly, but it is here to stay no doubt.
Nope: First-mover disadvantage
There is this saying in Dutch called the Wet van de remmende voorsprong. This roughly translates to ‘First-mover disadvantage’ (or ‘The law of a constraining head start’ to be more precise) and it means that an initial head start may prove to be a long term handicap. In terms of an online low-code platform this could be due to the need to maintain a complex system which is not suited for quick change anymore, plus the tendency to be complacent with the current way of working. Both of these would hamper innovation and progress, which is bad news for the users of that platform. Especially if there is a degree of Vendor lock-in involved.
Ironically, one way to solve this is having more developers available. Either to speed up innovation of the low-code platform, or helping its customers migrate to better options. There is some lovely irony to be had there.
Yep: Fertile ground for new services
The above scenario does not mean that innovation will stop off course. There is a high demand for new software and enough money to spend. So in short other low-code platforms will step in and offer better and more integrated services, for as long as they can maintain their lead. If anything this will accelerate the possibilities of low-code.
Nope: Developers will mostly use it
I might be wrong on this, but I am guessing the the bulk of low-code users todays are developers. Creating software tends to be a complex affair, especially when it involves intricate business logic. And software that aims to simplify that process is most likely still more elaborate than a regular Excel or Wordpress interface, which on its own can be somewhat of a speciality (sadly enough).
The truth is that developers are accustomed to working with this kind of complexity, so most likely they will also be involved when utilising low-code. That’s not to say that people without a development background could not handle this complexity of course, but it would take a considerable investment of time and effort. Even with a relatively simple approach using a low-code platform to create a functional prototype or MVP, you still get to the point you want to scale up. Which in turn could let you run against the limitations of either the platform in use, your own available time, or the need for new developers (hello irony).
Yep: AI might take over programming
This might actually be somewhat of a killer, but not in a Terminator kind of way.
I already mentioned GitHub’s Copilot and I am pretty sure there are other examples out there. The most impressive feature this has to offer is creating programming code out of relatively simple human readable input. I am not saying that it is currently an option to simply tell an AI program what kind of software you want and it will create it, not by a long shot. But it’s a first, small step. If this would becomes a reality someday it means bad news for the bulk of the developers. And mainly for one reason: the produced code does not need to be understandable by a human.
This would mean knowledge of programming is less relevant since the AI program can always be run again to fix a bug or generate software based on new specifications. A hypothetical AI program like this could also be optimised behind the screen resulting in better code, which also does not need to be understandable by a human.
Perhaps in this case some of the development work would shift to Data Science, DevOps and things such as writing test suites. But it would be bad news for the people enjoying writing software for a living.
Nope: Possibility breeds new software
That AI programming scenario sounded rather ominous didn’t it, but luckily things will not go that quickly. First of all generating code based on human readable specifications is one thing, but actually creating new (useful) software without specifications is another. That will not happen any time soon.
Another thing is that new possibilities often creates more complexity. In software terms, that would simply mean even more software to be created. And that’s good news for Developers.
Yep: There is a limit on how much software is needed
I’m stretching it a bit here, but perhaps a relevant point none the less. At some point we will reach peak-software (to coin a phrase). It sounds rather ridiculous of course, but there will be a moment that software has reached the edges of most places where it can be of possible use. After this that software can be improved, but the golden age of unlimited development opportunities will have passed. I do not think I will see this happen in my lifetime, but if anything something like low-code can speed up this process.
Maybe: But not any time soon
I am guessing that it will take a while before low-code will have a negative impact on my daily developers life. I have not seen any demand for it in my projects yet, unless it is for code quality purposes which will simply raise the bar for all developers. And that is good news, at least after I have had my first coffee of the day.
So there you have, as series of mind blurbs about low-code which definitely have to be taken with a pinch of salt. Predicting the future is notoriously difficult, and I am not particularly good at it. Otherwise I would be more successful with my stocks, which I am not.
In any case, happy 2022!
