Let me tell you about my strange love affair with low-code, even though my story might completely ruin my reputation as an old-school, .NET, and Java programmer and hardcore coder.


Table of contents:

Becoming a Hardcore Coder: Baby Steps

When I was growing up, I had a life-changing experience: my dad bought a ZX Spectrum. That was the one event that blew my mind and forever changed my life. My destiny was set; I was on the road to becoming a hardcore coder.

Not long after I’d gotten acquainted with the ZX and became a whiz at those fun Speccy games, my dad and I started copying code from books and magazines. This is where I first learned BASIC and Assembly. Little by little, the painstaking process of copying the code by hand from print allowed me to understand it. I’d work all the code in and then pray that it would work: RUN, ENTER... and sometimes it didn’t work. It was time for debugging.

In high school, a group of friends and I played with a different set of more powerful machines: the Atari 800XE, the Atari ST, the BBC Micro, and the MSX. Many from that original group would eventually end up working in IT.

When I got to University, I learned how to work with Modula-2 (pretty much based on PASCAL), Java, and C++ — which was how I first got introduced to this whole new notion called object-oriented programming.

How I KISSed and Made Up with Objects, Despite All the Debugging

After some night coding jobs, I eventually ended up with my first proper IT and programmer job right as Y2K was coming. Somehow I became responsible for taking care of the company’s intranet. Then came the day when, as a super user, I managed to use the good old destroyer of worlds command:

rm -rf

Remove. Recursive. Forced. A recipe for disaster.

I panicked. Slightly. The worst part of it all — or just a great opportunity to learn the hardest way — was the fact that the backups did not restore the system to its former state. So, I had to roll up my sleeves and rebuild the intranet. In one night. I got it done, but it was tough. I sure could have used a faster way to solve my problem then!

I remember another project where I had to code a layer on top of the original code because the core was just too rigid and strange. The reason behind it was the fact that it was implemented the KISS way, but this time it meant Keep It Simple and Stupid.

Everything was an object and I mean everything. Usually one draws the line at integers and strings, but in that project’s code even one letter was an object. This meant debugging through a zillion classes before you ended up with the right method. This was the moment I finally started wondering if object-oriented programming was actually the silver bullet everyone was talking about. If so, why on earth was so much debugging necessary?

Chaos Monkeys: Opening the Door to Low-Code

I had conquered major obstacles. I should have been on top of the world. Then the company I was working for grew rapidly and an even bigger company bought it. This started a rollercoaster ride of worry and doubt for this Java programmer and hardcore coder.

Eventually, I ended up working for a non-IT company on a temporary contract. When the contract ended, I asked the company to employ me directly. They said they would love to have me, but there was a caveat: another company had bought them! Fortunately, the other company hired me. And, all the while, I was still working on the same project, mind you! This is an example of the tragically long lead-times projects had in those days.

Nevertheless, my company was satisfied and so was I until… what I thought was disaster struck.

How Low-Code Didn’t Ruin My Career

My company wanted to find ways of getting even more out of my work. They wanted to maximize my ability to code; they wanted to help me become more efficient. So, off I went to an OutSystems bootcamp. They had heard it was all the rage, it was the future of programming, going way beyond your run-of-the-mill object-oriented programming languages.

All my alarms were instantly triggered. Low-code? How could something that hid my handcrafted, precious code be good for me? And I just knew it would probably spit out code that was worse than the stuff Frontpage produced — with 10 times more HTML than was ever necessary.

I was pretty sure my career as a hardcore coder (a badge I wore proudly) was over.

The Bomb

Then during the bootcamp, OutSystems nuked all my preconceived notions about low-code. I quickly saw that I could use the low-code capability for abstraction and functionality and still extend it with my C# code.

And that erased my big concern: what would happen when I reached the limits of what their platform could do? I didn’t know much about low-code, but what I did told me that there was a point where you hit a wall. Wrong.

With OutSystems, I can simply create components with my preferred code,, and each will deploy as a DLL or JAR respectively, encapsulated in a reusable extension component. Basically, for low-level integrations, you just code once with Visual Studio, abstract it as an OutSystems component, and keep on using it with their visual IDE.

A Plutonium Award

I think the solution is elegant. And better than that: it works. I can integrate with my systems and I can integrate with my nemesis, the evil database. If Integration Studio was a nuke, data modeling was its plutonium. The setup to use my external DBs is done once in OutSystems, and that’s it.

After I returned from the bootcamp, my company and I ventured into our first proper project with OutSystems, and that got us an award. And we didn’t stop there. We got certified, we created projects, and that’s when I had my epiphany: when you’re a good developer, low-code will just accelerate your way to the end result.

So yeah, I guess you can say low-code absolutely “ruined” my career as a hardcore coder. Just not the way I thought it would.

Is Low-Code a Silver Bullet? Not Quite, But Close

For some reason IT keeps reinventing the wheel every decade or so, but it’s a big step from the past, and I can’t wait to see what’s next low-code. I hear cloud-native is in the works, and that will open up the low-code world even more.

Just look at what OutSystems did for mobile, for instance. I mean, mobile development - talk about hardcore! Fortunately, OutSystems was all over it and still is. That’s how I became a mobile app developer, using the same tool I’d used since it was version 4.2.

And, now I’m set on the road of low-code and loving it.

Keep looking forward!