Most software engineers love to code (citation needed), so a technology called “no-code” is commonly and understandably met with disinterest or dislike.

That’s a shame, because no-code has the potential to massively improve the day-to-day lives of programmers. Powerful integrated development environments (IDEs) like VSCode hugely accelerate programmer productivity. They help organize, type-check, and refactor code and can save countless hours of work. No-code takes this a step further. Instead of the IDE being built on top of an already-existing language, the IDE is the language.

No-code is actually one of the most exciting things happening in engineering right now. Being able to throw together a user interface in minutes without fumbling with CSS? Delightful. Being able to bang out some business logic without worrying about where your data lives or tripping over syntax? Amazing. Never having to write CRUD logic across multiple layers of the stack ever again? Paradise.

Disclaimer: I’m a founder of Bubble, one of the leading no-code platforms, so I do have a horse in this race. I’m also passionate about building software and have been programming since middle school.

Since no-code has become a buzzword and gets used loosely, I’ll offer a definition. No-code is:

  • A programming language...
  • ...that’s merged with its IDE...
  • offer a higher level of abstraction than the previous generation of general-purpose languages (Javascript, Python, Ruby, Java, etc.).

Unpacking those pieces:

No-code is programming

It’s a common misconception that no-code doesn’t involve programming. No-code, despite the name, isn’t in opposition to traditional programming. Rather, it’s the natural continuation of trends that began with the invention of FORTRAN in the 1950s.

No-code tools are often confused with website builders and content management systems such as SquareSpace or WordPress, but those tools existed long before no-code. Unlike those tools, modern no-code languages such as Bubble are Turing-complete and require the same kind of programming logic that coding does. Programming (precise communication of logic to a computer) != code (precise, text-based communication of logic to a computer).

No-code merges the language with the IDE

IDEs parse code into abstract syntax trees, which is the logical true form of the language. No-code IDEs skip the parsing step and instead allow for the abstract syntax tree to be edited directly. The user interface of the IDE becomes the canonical representation of the program.

When you make the canonical representation of a program the IDE user interface instead of a text file, it opens up new possibilities. Your IDE can render each part of the program in the way that’s most natural. For instance, websites and apps can be rendered and edited visually. You can start asking the question, “What’s the best user experience for this particular language feature?”

No code offers a higher level of abstraction

The natural progression of programming has been from lower-level languages that expose raw access to the underlying computer hardware to higher-level languages that abstract away details that aren’t critical to the intent of the programmer. Assembly language, where you have to understand the intricacies of chip design, is at the bottom of the stack. Garbage-collected languages, like Python or Java, are near the top: Working in Python, you don’t have to think about allocating and deallocating memory like you do in C.

Prior to no-code, progress up the abstraction layer for mainstream programming languages had stalled. Instead, programmers used domain-specific frameworks on top of general-purpose languages to achieve productivity boosts. In web and mobile development, the rise of React on the frontend and frameworks like Express on the backend were the next frontiers of abstraction.

However, programming in a “modern” web framework is still incredibly complex relative to the simplicity of what you are actually trying to express, which is generally a user interface, some business logic, backend queries, and connectivity with other services. Among other things, you have to worry about:

  • The intricacies of HTML + CSS and how they differ across browsers
  • Browser ←→ server communication: what data lives where, how long it takes for data to get from the backend to the frontend, and the protocols used to transmit data (websockets, http, JSON, etc)
  • Database schemas, migrations, indexing, and performance
  • Hosting and DevOps

When you are building apps in a conventional language, you find yourself doing the same thing over and over again: building signup and login forms, writing UI validation logic, setting up hosting and CI/CD pipelines, writing ORM boilerplate, running database migrations, and hundreds of other tasks that have been done over and over again by prior programmers.

No-code languages abstract all of this away. Because no-code IDEs have total freedom to represent concepts in whatever way is easiest to work with them, no-code is perfect for domain-specific languages: The language itself can be shaped to each problem domain you want to address.

The tradeoff for this is generality. No-code languages aren’t general-purpose in the same way a language like Python is, but for the vast majority of projects, this is a good tradeoff. Most programming work happens inside a well-defined domain like web development, so why shouldn’t it happen in a language specialized for that purpose?

Occasionally, when you’re working in a higher-level language like Python, you need to drop down to a lower-level one like C. Perhaps you need to write some performance-critical logic that benefits from the detailed execution control C gives you relative to Python. Python solves this problem by letting you wrap C code as a Python function.

Similarly, no-code languages let you fall back to general-purpose languages when necessary. (Languages built around the assumption you will do this a lot are often called “low-code”). For instance, in Bubble, you can write new components in Javascript that then behave like native Bubble components. No-code languages often interoperate with traditional ones via APIs: Bubble lets you publish an API from your app as well as connect to APIs created in other languages.

So why is no-code the future?

The answer is pretty simple: Programmers are always more productive working at the right level of abstraction for the problem they are trying to solve. Historically, each time a new level of abstraction emerged, it unlocked a productivity explosion. Making programming faster and easier lowers the barriers to entry, and tons of new people flock to the profession. There are orders of magnitude more React programmers in the world than there are assembly programmers because it makes much more sense, both technologically and economically, to use React to solve problems.

I’m personally excited about no-code because it represents the next great expansion of who can create software. We have tons of Bubble users who thought the time and effort of learning traditional programming was out of reach for them and who tell us that learning Bubble changed the trajectory of their careers.

Since software has been transforming virtually every industry, this has a significant societal impact. Expanding the pool of programmers to include everyone who can learn no-code is a massive form of economic empowerment and will let a lot of people participate in creating the future who would otherwise have been shut out.

What this means for you

This is all incredibly good news for today’s engineers. Increases in programmer productivity help everyone; the easier and faster software is to create, the more demand for it there is. Even though it’s easier to program in 2022 than it has ever been, engineering salaries and opportunities keep on expanding.

But economics aside, no-code makes programming more fun. The joy of programming is the magic that comes from being able to precisely express a piece of logic and see it come to life. Programmers are always working to build better and better abstractions to make specifying what they want cleaner and faster; increases in abstraction feel like upgrading from a budget sedan to a sports car.

Of course, there’s always room for deep-diving down the stack to solve complex technological challenges. No-code supplements—not replaces—hard technical problem-solving: If you’re doing innovative machine learning research, no-code gives you an easy way of creating a front-end for your work. Plenty of people still work in assembly, C, rust, golang, and all kinds of lower-level languages because the problems those languages solve still exist. Again, it’s all about working at the right level of abstraction for the problem.

Looking forward

We are still in the early days of no-code. When automatic garbage collection first became widely available, a lot of engineers derided the loss of performance it represented since early systems were often inferior to hand-written code by an average engineer. But as time went on, the state of the art for runtimes improved dramatically, and today, it takes a lot of skill to write a complex program in C++ that outperforms a similar program in Javascript running on a highly optimized engine like v8.

Similarly, no-code platforms are aggressively investing in their performance, robustness, security, ease-of-use, and ecosystem. We’re already seeing a lot of successful businesses base their stack on top of no-code because of the productivity benefits it provides, and we expect this trend to keep accelerating as no-code matures.

The future of programming is a world where projects move fluidly between no-code and general purpose languages, and where more and more people do at least a little bit of programming as part of their jobs. I’m excited to work on building this future. It represents a massive opportunity for the engineers who help create the no-code platforms, for the programmers who use them, and for everyone who benefits from software that wouldn’t otherwise be created.