Is No-Code the Future of Software?
By: Arpan Dhatt
Tags: No Code, Programming

Introduction

The prospects of creating software without code are enticing. If you are a budding entrepreneur, you can create an app without learning to program or hiring expensive developers. Even large companies can save money by avoiding the hassles of software engineering. It seems like no-code is the future that should already be here. However, there are some fundamental issues with no-code development that limit its potential.

What Even is Code?

If we are so gung-ho about getting rid of code, we should have a good understanding of what is and isn’t code. Per the dictionary definition, the word code means “program instructions” in the realm of software development. However, getting rid of instructions for computers is infeasible. For this reason, we are going to define code as it is used colloquially. This is a little harder to describe but is familiar to many people. This might ring a bell(don’t worry about understanding it!):

fn calc_scores(students_to_valid_schedules: &BTreeMap<String,Vec<[String; 8]>>, tries: usize) -> Vec<(f32, Vec<usize>)> {

let mut lengths: Vec<usize> = students_to_valid_schedules.values().map(|schedules| schedules.len()).collect();

let mut scores = Vec::new();

let mut rng = thread_rng();

for i in 0..tries {

let random_perm = create_random_permutation(&lengths, &mut rng);

let mut random_schedule_perm = Vec::new();

for (i, (student, schedules)) in students_to_valid_schedules.iter().enumerate() {

random_schedule_perm.push(&schedules[random_perm[i]]);

}

let score = calc_set_score(&random_schedule_perm);

scores.push((score,random_perm));

prune_scores(&mut scores);

}

return scores;

}



fn create_random_permutation(lengths: &Vec<usize>, rng: &mut ThreadRng) -> Vec<usize> {

let mut out = Vec::new();

for len in lengths {

out.push(rng.gen_range(0,len))

}

return out;

}

That was a bit of code from one of my shorter projects written in Rust. If you are unfamiliar with programming, it might seem a little intimidating. Even if you do have experience in programming, but for higher-level languages(e.g. C#, Python), there still might be some peculiar symbols and syntax that seem unnecessary. Let’s keep going up the chain of programming languages. Here is some Javascript:

const list = new LinkedList();

list.add("red");

list.add("orange");

list.add("yellow");



console.log(list.get(1));



for (const color of list) {

console.log(color);

}

console.log(list.remove(1));



console.log(list.get(1));



const array1 = [...list.values()];

const array2 = [...list];

This might be a little easier to understand for some people. There are fewer strange symbols and the syntax is cleaner. I’m assuming everyone would still consider this code. Let’s take it up another notch. Take a look at this Python:

def graph_mat(title, values, width=10):

maximum = max(values)

mat = []

mat.append(title[:width] + " " * max(0,width - len(title[:width])))

for value in values:

mat.append(bar(value/maximum, width=width))

return mat





def graph_all_mats(data_dict, iters, width=10):

mats = []

for key, data in data_dict.items():

mats.append(graph_mat(key, data, width=width))



for l in range(iters+1):

row = ""

for mat in mats:

if len(mat) > l:

row += "|" + mat[l] + "\t"

else:

row += "|" + width * " " + "\t"

print(row)

Python is considered one of the most readable programming languages out there. It was created to make getting started in programming as easy as possible. Now it has become one of the most popular languages and number one in fields like data science. However, most people would still consider this code. Let’s take another step forward into Scratch, a programming language very different from the ones we have looked at so far:

This is used around the world to teach elementary students how to code. By using these blocks rather than text, they can avoid the intricacies of complex syntax and the pitfalls that can come from mistyping. However, this can still get complicated, as you see above. We can keep going, but we have already discarded one of the most frustrating parts of programming to most people: typing. This is about as far as general-purpose programming languages can get. They don’t get much simpler from here. Now, let’s delve outside general-purpose languages and into tools that are for specific purposes. One common example is website generators like Squarespace, Wix, and Weebly. These help users create websites by letting them drag and drop page elements like text and images rather than pieces of code. They have hidden the code because the flexibility demanded from the tool has reached a tipping point. Where that tipping point is depends on the application.

In summary, these no-code platforms are just another part of the spectrum of programming, just like where Rust, Javascript, and Python are. In the end, you are still giving the computer instructions. If we go back the dictionary definition, you are coding. You may not be typing code, but dragging and dropping instructions for the computer to execute. The complexity of the instructions will still depend on the complexity of the goal. If you just want a website with some images on it, you don’t need to know how to write loops and understand data structures. You just need to a find a tool that puts your images on a website. If you want to build an app that does privacy-preserving contact tracing then you are going to have to get your hands dirty, and a website generator isn’t the best choice(or even a choice at all) for building something like this.

What’s the Verdict?

The answer is “not completely”. No-code development will find its way into many applications. It already has. Lots of signal processing applications use no code-development. Instead of coding, people construct flow-charts of mathematical operations. Many websites already use tools like Wordpress and other services to delegate programming to someone else. If you are building something that has been done many times before, such as a showcase website for your product, it can likely be done without any programming, and the result can be built quickly and reliably. However, all of these tools have their limitations, namely flexibility. The amount of instructions the computer needs doesn’t change. No-code is viable only when a large part of the problem has already been solved and you just put the pieces together. The future will still have a lot of complex and novel problems that haven’t been solved before. In those situations, no-code is a no-go.

-Arpan Dhatt, an Unbiased Developer