Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore.

15 St Margarets, NY 10033
(+381) 11 123 4567



How much time does Low-Code save you?

An hour ago I created a new release of Magic Cloud. This is a humungously large and important release, with hundreds of stabilising fixes and features. However, its primary feature that I suspect a lot of my regular readers will love, is that Magic now automatically wires up foreign keys for you. This implies that if one of your tables have a foreign key pointing into another table, it will display one string field from the other table, instead of just some dumb guid or auto incremented integer value. To understand the feature, take a look at the following screenshot.

The “film_actor” table from Oracle’s Sakila database is a many to many link table between an actor and a film. Such many to many table allows you to populate a film with as many actors as you wish. In previous releases of Magic, the above “film_id” was simply displayed as an integer value. Displaying such foreign keys as their integer or guid value is of course meaningless, and this required manual work after the CRUD generator had done its job in order to get things right and useful. Typically this also required a lot of manual work unfortunately. In this release Magic Cloud will read your foreign keys as it generates your backend, and allow you to declare which lookup field you want to use in the foreign table to display such fields. To understand look at the following screenshot that is taken from the CRUD generator in the Magic Dashboard.

The “Long data” checkbox simply allows you to choose between an auto completer and a select drop down list in the resulting frontend. If you have hundreds of records or more you should probably always choose “Long data” here. This simple checkbox was always a problem for me and quite frankly a large source of manual labour, having to be applied after the CRUD generator had done its job. In this release of Magic, the first screenshot from above was literally created by clicking a button, and I made a big point out of not changing any of its automatically generated code before I deployed it to my demo server. If you want to play around with it yourself, you can test it below.

For a typical CRM system, the only thing I now have to change to handle everything related to CRUD entities and the data itself, is reduced to a simple copy/paste job for file uploads and image uploads. Plus also the displaying of files and images. This is something I can do myself easily in some 5 minutes by manually modifying the codebase after the CRUD generator has done its job – And hence, I’ve reduced the workload for creating CRM systems arguably down to roughly 5 minutes of manual work. The rest of the work my computer does automatically in some 2/3 seconds once I have the database schema. So yes, I can create a typical minimalistic CRM system, and/or other database centric CRUD apps in some roughly 5 minutes, and they’re 100% customisable. Of course, business logic, aggregates, KPI charts, statistics, etc, etc, etc needs to still be manually applied – But that’s the beauty of it, as in you can. The above 2 second process, clicking two simple buttons, still does at least 80% of the coding work required to deliver a database centric backend administration app, such as a CRM system for instance.

I want to emphasise that this scaffolding process or the CRUD generator for the Sakila example database as published by Oracle, creates some roughly 3.500 lines of backend code, and some roughly 33,000 lines of frontend code. Not all of this code is relevant, and some of it is simply boiler plate code created by the guys behind the ngx-rocket-generator, but probably somewhere between 10,000 to 15,000 lines of code can easily be attributed to the CRUD generator. Let’s make sure we’re not exaggerating and use the number 10,000. This becomes a combined result of 13,500 lines of code, that my computer created in 2 seconds.

We know the average (human) software developer can produce between 325 and 750 lines of code per month. If we put 550 as an average, and divide 13,000 on 550, we get the figure 23.6 months. Implying two years worth of manual (human) work. Now these numbers too are probably a bit inflated, since the generated code is a lot of repetition, due to the nature of how data grids are wired up with Angular, so let’s be more generous, and divide this number by 3, to make sure we don’t exaggerate. This figure becomes 7.8 months worth of manual human software development. Implying the following …

My computer using my Magic Cloud’s Low-Code components produced (AT LEAST) 7.8 months worth of human software development in 2 seconds

Let these figures sink in please, and realise that Magic Cloud can start out with any database you happen to have, and arguably replace an entire legacy system, and as of its latest release also automatically wiring up foreign keys, and that it can do it in 2 seconds. Facts are, at its most extreme Low-Code can easily make you million of times more productive – If your project lends itself to Low-Code – Not all projects does (yet!) unfortunately …

So do me a favour please, or rather to be accurate; Do yourself a favour please – Mark your legacy project scattered with jQuery, Durandal, KnockoutJS and God knows what more in your file explorer. Then hold down the SHIFT key, and click the DELETE key. I refer to this software development process as SHIFT+DELETE refactoring 😉

Simply because Magic can reproduce that system, or at least 80% of it in a couple of seconds. No reasons to keep on maintaining your legacy garbage anymore ^_^

Ohh yeah, in case you’re wondering, Magic Cloud is still Open Sauce … 😉

If you’re too lazy to even try the demo server using the above link, you can watch me demonstrate some of its highlights in the following video …

Credit: Source link

Previous Next
Test Caption
Test Description goes like this