"No-Code" is actually Hidden Code

All Software is made from Code, so "No-Code Software Development" is a logical impossibility.

One of the things that makes software development difficult is that you have to write code.

If we could find a way to develop software without writing code, then that difficulty would be avoided, and it would be so much easier.

Thus the invention of “no-code” software development.

Unfortunately there is one slight issue with the concept of “no-code” software, which is that all software is code.

We do not have any concept of software as something that can be executed by a computer system, which is not code.

So if someone claims to have a “no-code” software development system, actually, somewhere, there is code.

A very rough analogy is that of a “no-fuel” engine.

An engine is presented to us. It makes a noise, and there’s an axle which rotates steadily, and there is no fuel tank. What a marvel! What a great saving of money, because you don’t have to pay for fuel to run the engine!

The only problem with this is that almost certainly there is a fuel tank - it’s just that it’s very well hidden from the casual observer.

In the case of no-code software, the code is actually there, somewhere, but it’s very well hidden.

There is one significant difference between “no-code” software development and a “no-fuel” engine, which is that with the engine the fuel will be hidden inside the hidden fuel tank before the running engine is presented to an insufficiently skeptical audience.

Whereas, in the case of no-code software development system, the hidden code is something that has to be created from scratch as a result of the actions of the very user that the code is being hidden from.

“Code” vs “No-Code” Software Development

With the traditional method of writing software, the programmer writes a program in a textual programming language using a text editor, and nothing is hidden from the programmer.

A programmer developing software this way sees the code directly - it’s a sequence of characters from some chosen finite character set, this sequence of characters is what constitutes the code, and it is exactly what they see represented on the screen of their computer when they use a text editor to edit it.

In a no-code software development system, the user takes actions to construct the code, and the UI of the system shows a pictorial representation of the code to the user.

The UI will necessarily imply some model of the actual code, and the user will probably develop a mental model of the code based on their experience of using the UI to construct the code. But they will never actually see the real code, and their mental model may or may not correspond correctly to that code.

Variation: Obfuscated Code

One variation of “no-code” is where the actual code is not hidden, but it is obfuscated. It may consist of data in some binary format that is not directly readable, or it may even be in a format layered over some standard textual data format such as XML or JSON.

So the user may know that the code exists in a file (or files), and they may choose to look at that code directly. But, unfortunately, the code is in a format that is not easy to read, and the user will find it too hard to discern the relationship between the code as presented in the UI and the code as it actually exists in the code file.

Code vs Pictures: Execution

A picture may or may not be worth a thousand words, and a picture of hidden code as presented by a no-code software development UI may or may not accurately and precisely represent the code.

But the picture is not the code, and it is the code that is executed. Computer systems do not execute pictures - they only execute code.

This is the fundamental issue with pictorial software development systems that hide the actual code from you - the thing you are looking at is not the thing that is going to be executed.

“Low-Code”

One variation on No-Code Software Development is Low-Code Software Development.

Where No-Code allegedly contains zero code, “Low-Code” does contain some code that is read and written by the user in textual form.

However, given the observation that “No-Code” is really “Hidden Code”, it would be more accurate to characterize “Low-Code” as a mixture of Hidden and Non-Hidden code.

Indeed, given that the hidden code behind No-Code may actually be more verbose that normal unhidden code that a programmer would write using a modern succinct programming language, “Low-Code” may actually be the exact opposite of what it says, ie it may be “High-Code” that contains more code than what would be in code written directly by a programmer in their text editor.

Comparing Pictorial UI to Text Editor UI

It could be that for some types of programming, one could construct a non-textual pictorial UI which was a better and easier way of writing code than using a text editor.

However, to make a proper judgement as to whether this is genuinely the case, the following conditions need to hold:

• The textual code should be written in a programming language where some reasonable effort has been made to make the language readable and writable in a text editor.

• It should be straightforward to discern the relationship between the pictorial UI and the textual UI. (For example, a mouse hovering over either UI should highlight corresponding portions of the code as represented in both UIs.)

To the best of my knowledge these conditions do not hold for most or any commercially sold “No/Low Code” software development systems.

So finally …

If someone tries to sell you a “No-Code” Software Development system, ask them where the code is.

If they deny that any “code” exists, then you have to persist with more questions -

• What is the thing that gets created when the “No-Code” software is developed by the user?

• What file format is the thing stored in? Where and how is it stored?

• Is there a formal mathematical description of the set of possible things that can be developed?

• How does it get executed?

• Is there a formal mathematical specification of the semantics of execution?

(You might not think about format syntax and semantic specifications when programming in your favourite programming language, but the important thing is that, for most well-known popular programming languages, someone has thought about them.)