DEV Community

Cover image for Low-Code and Open Source as a Strategy
Conor Bronsdon for LinearB

Posted on • Originally published at devinterrupted.com

Low-Code and Open Source as a Strategy

This article was written exclusively for devinterrupted.com by Thomas Hansen, CEO of ServerGardens.com
.
.
.
Unless you’ve been living under a rock for the last year, you must have heard about this brand new shiny thing called “No-Code” and “Low-Code”. According to Gartner, 50% of all software projects will be delivered before the end of 2021 using Low-Code and No-Code constructs. Even if Gartner’s numbers are inflated, automation processes for generating code automagically have gained traction lately, and it has gained traction very, very, very fast. So obviously we’re way beyond the “hype factor” in regards to these technologies. Hence, in this article, I will try to break down the advantages, and illustrate with an example use case, so you can see the advantage for yourself. But first I need to define Low-Code and No-Code.

The difference between Low-Code and No-Code

Although obviously related, Low-Code and No-Code are actually two completely different concepts. No-Code is the idea of “citizen development”, where people without software development skills can create software. This is typically achieved through drag and drop interfaces, similar to how DreamWeaver worked a couple of decades ago. On the other hand, Low-Code is typically a software system that generates code automagically for you, by for instance reading metadata from your RDBMS, or Swagger, etc.

In a way, you could argue there’s nothing new to No-Code. DreamWeaver has had No-Code constructs since the late 90s, and so have Adobe Flash, Microsoft, and literally every single software company out there beyond some certain size threshold. Visual Basic and WinForms for instance used to have GUI interfaces for “generating code by dragging and dropping components into a visual surface.” While Low-Code it could be argued, has always been around in some ways, due to individual software developers’ ability to reuse Open Source libraries and frameworks, to reduce the workload required to deliver applications.

So what’s new?

Well, let me illustrate with a walk down history lane, and use Gutenberg and the printing press as an analogy for what’s happening. In the 15th century, it would require one human being roughly 18 months to copy a Bible by hand. These jobs were typically done by monks, and because of the resources required to create a Bible, “the Good Book” typically took 300 sheepskins or more to create. One hundred years later, Gutenberg’s printing press became mainstream, and today born again Christians are throwing Bibles at you on the street for free. With mass printing, the cost associated with creating books has plummeted.

This was only possible because of the printing press, and its ability to automate what was previously a manual job. Hence, the more we can automate, the lower our total cost of ownership (TCO) becomes. Such benefits don’t require a Ph.D. in math to understand but are probably intuitively understood by most.

With today’s automation techniques based upon Low-Code constructs, we’re now at the point where we can deliver similar optimizations in regards to “generating“ software systems that result in the same quantitative improvement of the TCO of creating software. To illustrate it as blatantly as I possibly can, let me ask you a question: “Would you want to pay 50 million dollars for your software, or would you want to pay 50 bucks for the same thing?” This is really the heart of the matter. To understand how this occurs, imagine having to create your own operating system to serve your own software. Obviously, such a thing would be madness, when you could just pick Linux off the shelf, and start out with an Open Source system solving these problems out of the box. Hence, the qualitative similarity between Open Source and Low-Code.

A Low-Code use case

Disclaimer: I’m the CEO of ServerGardens.Com, and we exclusively deliver software systems based upon Low-Code constructs, and our own internally created Open Source system we refer to as Magic Cloud. Therefore, I might not be completely without bias. But really, most people can easily reproduce what I’m about to show you here, so it doesn’t really matter if I’m biased or not, since you can test and verify my thesis yourself. Anyways, with that out of the way, let’s illustrate a use case for Low-Code.

One of our clients came to us and asked us to create a CRM system. It needed the ability to track purchasing and selling of horses, and hence a traditional CRM system couldn’t be used, since it was more like a logistic system that he needed than a traditional CRM system. We spent 25 minutes creating a database schema after having asked some questions about how he wanted it to look, and digging through Google Spreadsheet documents which he was currently using for this job. All in all, the process took about 2 to 3 hours before we had a working system deployed into production for the client.

The process was as follows: After we had the database done, we clicked one button, and the computer-generated 1,813 lines of backend code for us; this code again became the input for the next button click, which generated 27,000 lines of frontend code. Even after having removed the boilerplate code you’d typically have around in a manual workshop, we’re easily looking at 10,000 to 15,000 lines of code here, automatically generated for us, in 2 seconds. And the code is perfectly valid Angular code in the frontend, and Hyperlambda and .Net 5 in the backend.

And of course, the code generated by our system is easily several orders of magnitude higher quality, according to every single neutral metric we use to measure quality. In fact, run this code through one of your frontend/Angular developers if you want to assess it from a quality perspective. I guarantee you that he won’t find a single bug in it! Then realize that this code is running here. Try it out for yourself by logging in with admin/admin.

The reasons for the qualitative improvement are quite simple to understand, In fact, our stuff runs in thousands of apps, implying we can share the burden of improving it equally with many projects. Something you’d typically never be able to afford if you manually write code on a per-project basis. To see this effect in the printing press improvements, try reading an old Bible that was manually written by a monk 550 years ago (if you can even find one) — then try to read one of Gutenberg’s Bibles and notice the difference in readability. Low-Code improves both your quality and reduces your cost by several orders of magnitudes.

How Low-Code improves quality and reduces cost

The way it works is by reading metadata from the database schema, to then use this metadata as a “formal specification“ to generate the backend. The backend exposes a lot of metadata itself, which again is used as a “formal specification“ to generate the frontend. However, the time to market quantitative improvements is simply ridiculous. To understand why realize that a (human) software developer can deliver at most 750 lines of code per month. Our software system delivered at least 10,000 lines of code in 2 seconds. Of course, these types of comparisons aren’t completely fair one might argue, but this becomes a quantitative improvement of 17,280,000 times faster Time2Market! In fact, so far I have not been able to identify a theoretical upper limit in regards to either quality or quantitative improvements. In theory, our software systems can produce 750,000 lines of code per second, which becomes a quantitative improvement of 216,000,000 times faster than a human being.

Hence, we’re now at the point where we can literally throw customized software systems at our clients — almost the same way born-again Christians are throwing Bibles at strangers on the street — simply because of the cost associated with creating such custom software systems for our clients is almost ZERO.

BUT…?

Yes, there is a “but". For instance, our system needs an existing database. The end application will also be database-centric, implying it’s typically for the most part only interesting for CRUD systems, where CRUD implies Create, Read, Update and Delete. However, the last figures I saw in regards to this was that there are 26 million software developers in the world. These numbers are a bit old, and are probably much larger today than a decade ago when I saw these figures. Regardless, the ratio is probably still the same, and the ratio tells us that 80% of these software developers work as “enterprise software developers.” An enterprise software developer is a developer working for a non-software company, where software is a secondary function.

Examples could be insurance companies, banks, hospitals, or the public sector. So let’s imagine there are 21 million enterprise software developers in the world today and 80% of their workload is CRUD. If you don’t believe me, go ask your DBA how many relational databases you have in your company, and whether or not these are crucial for your company to function. Chances are his answer will be, “Our company would go bankrupt if we lost these database systems.” Then realize that every single time your applications are accessing these database systems, they are either Creating, Reading, Updating, or Deleting items from the database — A.K.A. CRUD!

This implies that if you adopt Low-Code and Open Source as a strategy for your enterprise, you can optimize the way your software developers work by (at least) 5x, probably much more. Simply because at least 80% of the work they need to do manually is as simple as clicking a button, and waiting for one second for the automation process to deliver its result.

Also realize that the code generated is just plain old fashion code, that can be easily extended upon by your (human) developers once the process of automatically generating the automated parts is done. Except, of course, your (human) developers start out with something that is 1 million times higher quality than whatever they would typically be able to start out with themselves. Respectfully, but there is no way of saying this politely, so I’ll just say it: Not taking advantage of such improvements is simply madness!

Wrapping up

If you want to play around with the Open Source Low-Code framework that delivered the above results, you can download it for free from our website. All of our tools and Low-Code constructs are 100% Open Source. We also help others strategically make the transition into a Low-Code automated software development ecosystem if they need help. Our services include training of your existing software developers, open-source frameworks, hosting, and, of course, software development at the speed of light! See you at the other side of the Universe mate ^_^

If you haven't already heard, Dev Interrupted is partnering with Dzone to host INTERACT: An interactive, community-driven, digital conference on September 30th - by engineering leaders, for engineering leaders. 1 day, 10 speakers, 100s of engineers and engineering leaders, all free.

Register Now


Join the Dev Interrupted Community

If you haven’t already joined the best developer discord out there, WYD?

Look, I know we talk about it a lot but we love our developer discord community. With over 1500 members, the Dev Interrupted Discord Community is the best place for Engineering Leaders to engage in daily conversation. No salespeople allowed. Join the community >>

Originally published at https://devinterrupted.com on August 30, 2021.

Discussion (6)

Collapse
larsonnn profile image
Lars Feldeisen • Edited on

750lines a month? What the fuck are you doing the whole time?

We're abstracting since the beginning of humanity. So ofc we have some kind of GUI based coding at some time. We have a lot like this in the gaming industry today.

  • Object are generated through the IDE, and you don't need to write them
  • Unreal Engine is just using a whole blueprint system where you just move some boxes.

Web Development is also just sticking existing frameworks together. I work on small sites with react and material-ui and I wouldnt call it coding.
The most time consuming part is the design.

The whole problem or (for someone an advantage) is, less people will understand how to code. Less people now what a database is and what it can do. So more customers for me I guess?! :)

Collapse
leouofa profile image
Leonid Medovyy

As far as comparison with the printing press goes. It was a process improvement to an already existing process.

I’m curious how the maintenance works with something like this? Are you able to regenerate the app and apply bug fixes? Or are you back to regular dev work once the app has been generated?

Collapse
nickhodges profile image
Nick Hodges

You think 10,000 lines of code in 2 seconds is a lot? Obviously you've never seen me work ;-)

Collapse
nobilitypnw profile image
NOBILITYPNW

Seems like an aggressive level of adoption but I don't doubt that more automated code is coming.

Collapse
mellen profile image
Matt Ellen

I hadn't heard of "low-code" so I assumed it was some kind of distinction, like Low German and High German. I was excited to find out about programming done on the plains.

But, alas...

Collapse
conorbronsdon profile image
Conor Bronsdon Author

Lol