No-Code and Low-Code Development: The Ultimate Dev Time-Saver
By applying low code, save 90% or more of your time
Join the DZone community and get the full member experience.Join For Free
Editor's Note: The following is an article written for and published in DZone's 2021 Low-Code Development Trend Report.
If you ask 100 developers what no code is, you’re likely to get 100 different answers. However, what is often agreed upon is that no-code development offers the ability to create software without needing dozens of software developers working — often for months at a time — on software before delivering a working solution. Essentially, this means that no code is the process of automating software systems.
How Does No Code Work?
Yet again, there are as many answers to this question as there are people with opinions about the concept — I can only answer this question by explaining how I implemented a low-code and no-code software system myself.
Internalized Standardization Processes
Standards are imperative if you want to implement your own no-code solution. If you can implement internal standards regarding how your code is built, the computer can then make assumptions about how the code works. The reason for this is because of a little-known fact: Your computer doesn’t understand code!
While I understand this may sound a bit absurd, it is fundamentally true. If it wasn’t true, we wouldn’t need interpreters or compilers, and the computer could simply execute your code directly without needing to change it before execution. However, if your computer can assume that all of your
HTTP PUT endpoints are updating a database entity, it no longer needs to understand the code, and it can generate an entity UI interface, wrapping the input arguments your endpoint requires.
PUT assumption above is true, however, you could use tools such as Swagger to extract metadata about your endpoints and create a GUI, wrapping all your
PUT endpoints. The same is true for all CRUD operations. Typically, we use
PUT for update,
POST for create,
DELETE for delete, and
GET for read.
The beauty of this approach is that as a general architectural design pattern, regardless of whether or not you’re interested in no code, implementing such internal standards makes your code more easily understood. Once a human developer understands one endpoint, they have effectively understood all endpoints that the API exposes.
Based on that conclusion, no code is simply the natural side effect of applying a good design to your software, implementing conventions and rules that everyone can follow to understand the system. In fact, whether or not your existing codebase can be “no-coded” arguably becomes the definition of how much quality it possesses. If your code doesn’t align with these rules and conventions, it’s likely difficult to understand. If it’s difficult to understand, then it’s oftentimes badly architected. But if it is built upon a good architecture and able to wrap these standardization constructs, it grows organically without any ceilings, similarly to how biological organisms grow, exclusively based upon standardization mechanisms.
This is the reason I chose “Server Gardens” as the name of my company I must confess — simply because good standards and conventions, allowing for correct assumptions, results in less cognitive load to the point where the computer can automatically “grow” your code. When you are armed with internal standards, the process is more similar to how biological organisms grow than how software is typically engineered.
This is an excerpt from DZone's 2021 Low-Code Development Trend Report.
Read the Report
Metadata is possibly the most under-appreciated paradigm we’ve ever had in regard to the art of creating software. Metadata, simply put, is “data about data.” For instance, when you send a text, the message is the data. Metadata are things such as “how many characters did your message contain,” “what time was the message sent,” “which phone did you use,” etc. Hence, metadata is an axiom describing properties about the data you’re interested in.
When it comes to your codebase, metadata consists of components such as “which database connection is this code relying upon” and “what input does this endpoint require.” For existing software systems, Swagger is a great tool for extracting metadata. Once you have metadata, you can automatically scaffold POCO classes and methods around your code, consuming your code where no code grows up from the ground almost organically.
Now, metadata capabilities from tools like Swagger become pale in comparison to what a specific metadata-designed programming language gives you. In the previous section, we said, “Your computer does not understand code.” If you can solve this problem, your code becomes metadata.
Once the entirety of your codebase exclusively consists of metadata, your computer can create 100% accurate assumptions about every single line of code in your codebase. If you can achieve this, the computer can easily answer questions like, “Does this method log?” and “Which database tables is this code using?” These questions are impossible to answer using metadata extractors such as Swagger, but they are implicitly given if you use a metadata programming language.
For an example, check out my own creation: Hyperlambda. Hyperlambda, of course, is at the core of Magic and the reason why Magic can do what it does. Fundamentally, it’s just a tree structure, which is Turing complete, and your computer is capable of executing without interpreting or compiling. This way of thinking turns the entirety of your codebase into “metadata.”
Once the computer has access to every pixel of metadata, your computer now “understands code” and can draw 100% accurate assumptions about the code; thus, it can now create automated processes wrapping, your codebase and solving every problem imaginable.
Combining Metadata and Standards
To better understand the true power of meta data, the following screenshot originates from a system created that starts by reading meta data from the database. Database meta data consists of information like, “What are the names of your tables?” and “What are the primary keys of your tables?” Next, it generates a web API, wrapping your tables in Hyperlambda. Finally, it assembles a complete Angular front end, wrapping the web API. Basically, the software system in the following screenshot was, in its entirety, created without a human being adding as much as a single line of code to it.
The software system in the screenshot was created in one second. The system consists of roughly 3,200 lines of back-end code and some additional 30,000 lines of front-end Angular code. The average human software developer can produce roughly 550 lines of code manually per month. Ignoring all other aspects, the above software system would have required one human software developer roughly 60 months to complete. The computer created it in one second.
So is no code just a bit of excitement, or is it our undeniable future? To answer that question: Let’s address what the above software system does not do. Primarily, it does not end up with a result resembling exactly what you want — and unless its back-end code is generated around a 100% perfectly applied “standard,” it kind of freezes, stops, and is unable to proceed. It requires assumptions to be correct if it is to succeed. And more often than not, it also requires a bit of manual coding after you are done.
As the inventor of this system, I have obviously used it a lot. But after the initial “wow,” you will probably realize as I did, that it’s not really a threat to your job because once the computer has done its job, it will require (some) manual coding afterward. And even if it did everything, there is still deployment, orchestrating multiple systems together, and enterprise architecture left for the human to do — in addition to database designs required for it to function.
In summary, allow me to answer one final question:
Q: Will no code steal your job?
A: Only 80% of the most boring parts!
Regardless of how intuitive our no-code and low-code tools become, the end result will always need a human touch. No and low code is about empowering the end user. Once you realize that simple fact, you also realize you have nothing to fear from it.
|Thomas Hansen, CEO at ServerGardens.com
@mrgaia on DZone | Creator of polterguy.github.io
Autodidact software developer with 40 years of experience, since the age of 8, and 20+ years as a professional software developer, creating enterprise software for dozens of companies around the world. Now the CEO of ServerGardens.com, a company exclusively creating no-code and low-code tools.
Opinions expressed by DZone contributors are their own.