Code vs. No-code

I co-founded a company called Airplane (https://www.airplane.dev/) which is essentially a low-code platform for building internal tools. But unlike other low-code platforms, the underlying representation of the stuff you build in Airplane is still just normal Python/JS/etc code that you can put in your monorepo, version control, write unit tests against, etc. As a result, there's a lot less vendor lock-in and eng teams can collaborate better at scale. You also don't hit the complexity ceiling that this article refers to.

I don't think Airplane needs to be unique in this regard. Other low-code platforms could allow user-friendly drag-and-drop interactions while still having underlying code-based representations that allow users to get the best of both worlds. I think more no-code/low-code platforms will be built in the future with this in mind.

Today no code seems more like visual basic 6. You drag and drop a bunch of stuff but realistically the meat of it requires more “advanced” knowledge but so does making a really good spreadsheet.

For no code to work one needs to be sure the framework can handle the requirements well, so customizations and workarounds wont be needed. To know the requirements sufficiently well one usually needs something in production, and years of experience with it. Why bother with no/low code then? If a more modern reimplementation is needed, it can be elegantly implemented in one of the bazzilion software stacks out there.

Another big disadvantage is lack of developers that like those kind of things and know them well. Those who do know those frameworks usually cost a lot more. Lots of those relatively niche things, such as mulesoft, are really just means to strengten the vendor lock in, and are sold to management, not engineering leads, on the premise of lessening the reliance on actual engineering. Which of course is a lie.

For example, for simple CRUD apps/internal tools, use a low code platform like budibase (https://github.com/Budibase/budibase). For building a SaaS platform, with relative complexity, that your business is built on, I would venture towards code.

I remember a few (a lot) of years ago when Drupal / Wordpress came into the world. The same questions were asked, but today they solve a problem and they're simply easier to build a site with.

What I do feel is important, is the extensibility of the no/low code platform. I am the cofounder of Budibase and from the beginning, we set out to build an open source, extensible low code platform for a specific use case (crud apps/internal tools). We believe if a tool is a part of the development stack, it should be open source (for obvious reasons).

I would be suspicious about the intelligence of someone who refused to use appropriate tools for specifying software behaviors claiming it too difficult. A baseball pro knows how to work and has a likely good mind, as does a culinary expert. I just don’t know anyone GOOD at a given field who isn’t also hardworking and smart.

What’s the big deal? Why do we seek no-code software development solutions when code is the most precise concise manner to describe software behaviors?

I'm thinking Greek mythology, sirens perhaps.

Learning curves that start with a cliff tend to be self-limiting. Lots of people nope out without even really trying. When you push it out to the horizon people miss it, often at their own peril, and at great profit for Salesforce, uh, I mean, for the vendor. The anonymous vendor.

There seems to be a rise of these low-code tools, and something good may certainly come from it. But when I looked at them (approx. 9 months ago), it just simply wasn't "there" yet. I also don't think that what they offer in 2022 is much better an experience than what I did in 2002 with Microsoft Access (which I've left behind me long since).

If you're using low-code, you're still writing software, and good software is more than a bunch of if statements and function calls, it's a well-considered and understandable architecture too (or it should be)

Low-code makes it easy for non-programmers to write systems, but there's no reason you would expect these non-programmers to understand how to architect these sytems well. This (IMO) is why systems written in low-code tools often become unmaintainable piles of mush.

Coding is like writing a story in a way and imagining the story is what’s hard. Whether it’s written in code, pictures, graphs, or grunts is irrelevant. No-code will not make a good story teller. Sure you will lower the barrier for those with little imagination telling small tales, but it will not help in the epic adventures.

It feels to me that some service should exist that provides the API plumbing I need so I can just write the code that processes data and writes to APIs. Things like zapier can probably do it, but then it becomes a hassle to add arbitrary code to the mix. Does anyone know of anything that can help here?

Problem 2: Coding something is one thing. Version-Controlling it, intergrating it into a deployment chain, running it in different Environments, Reviewing it, scaling it are a collection of entirely different beasts.

Problem 3: As soon as the project hits a requirement where there is no lownocode solution (eg. integration with some custom monitoring system with no premade hooks available), the effort required goes through the roof, because now we have to interface the two worlds with each other, adding a layer of complexity that wouldn't exist if the entire thing had been code from the beginning.

Bottom line up front, I believe that we don’t want to lose the proven expressiveness of code.

Sure, when a project react a certain level of complexity, no-code is not enough and you need real code, and the transition might be painful. But most tasks are simple. 80% of all solution might never reach the level of complexity where code is required. For the remaining 20% it means we now have a working prototype which represent the requirements of the customer, which is much better than starting from scratch with vague specifications.

Web site builders like Wordpress is the classic example. Once even trivial websites required programming. Now most websites can be built in such a system.

If you define code as "something you type" vs tools as "something you go click click", then of course you're in trouble as soon as something like labview or simulink come up.

If you define tools as "things with a narrow, specific purpose, whose features limit them to that purpose" vs code as "tools that are sufficiently sophisticated and flexible to create other tools", then all these debates largely go away.

I learned to code from a book that cost £60, most professionals spend a fortune and years learning their craft.

I constantly find lay people who find out im a developer and then want to show me the code they copy pasted together to get something done. Sure its not pretty but it works and looks as good as any code spat out by a drag and drop no code tool.

The people that like no code don't create software and thats why they like it, they like the idea they don't have to learn anything and can just click a button on a program to make a new program. It never works out like that, its always just code but with an awkward drag and drop ui instead of text.

The real no code solution is a paragraph description of what the software should do and a big green button that gets an AI to create the new software. Until no code can provide a real solution it's just marketing a fantasy to people who don't know any better.

PowerApps/BI is great until you hit a problem. where there is no "connector" provided by Microsoft or you have buy a connector from a third party.

No code just mean as long as there's a free connector provided by Microsoft or pay up

The timings might surprise you though. The tool/language originated in DOS in the 80's and moved to Windows in 1994. It allows you to work at the code, and no-code levels (intermingled) and allows you to write your own code to extend the no-code layer.

Which is what I started doing in 1992 for myself (because I'm lazy), addons which it turns out others wanted as well, and so gradually that has become a big part of my day job.

I still write programs in it though, and it's fantastically productive. Mostly I build web apps now, but there are some big desktop systems in play and the odd mobile app as well.

Trends come and go, and it's interesting to see the current discussion (now calling it no-code - at least it has a new name) while we quietly stay under the radar.

For reference there are maybe 5000 people total using this tool, most are in one-man or very small companies. Most are punching far (far) above their actual programming chops. None have ever seen a VC $. ) Most make a living writing either custom software, or niche products (or not so niche). Some are the underpinnings of very large and successful businesses. Very, very, few evangelise the actual product.

Yes all the negatives are in play. It's a commercial system with infrequent upgrades (budget about $200 per year for the base product, say $500 pa for addons), zero marketing, anyone you hire has never heard of it, it's archaic in some places (pretty good in others), has an IDE that occasionally crashes, plays OK (but not terribly well) with version control and so on.

"real" programmers turn their nose up at it (since the days when real programmers used C), and if it was ever "cool", well, decades have passed since then.

But here's the interesting thing. It allows people to find their place on the programming spectrum. They code as much, or as little, as they care to. Coloring inside the lines you can still make fantastic stuff. I know of companies that make a good living selling a product, and the (sole developer) can literally barely write a single line of code. I know of others who have written all the code by hand, and used very little of the no-code layer. The world is a spectrum and each finds his own place.

To dismiss no-code out of hand is to not really understand it. Word is like no-code to writers. Some use just spell checking, some for formatting, but there are still writers writing long-hand on paper because "that's the pure way, and paper never crashes".

I've written code in assembler. And C. And more. And that's all fun, but it turns out customers don't care what you write in. They care about the solution you are selling. What keeps our company of 50 people going is a program written mostly by 2 people, with code stretching back to the mid 90's,but which easily beats out compeditors for functionality and cost and ultimately means we are a player in our space.

Of course no-code won't solve every programming problem (although dropping to the code layer you pretty much can) but in the real world 99% of actually used, useful programs, are boring re-hashes or CRUD, APIs, Web Services, UIs, and so on. That's the stuff people pay for which keeps the lights on.

And yeah, it's fun to optimise string manipulations using assembler, or python, but that stuff doesn't pay the bills.

Ultimatly no-code (with code) is not a new idea, it'll never be the sexy thing, but it is very productive in the right hands, and it'll be around for ages. Alas it takes time and effort to become skilled and experienced though, just like everything else.

"Since FORTRAN should virtually eliminate coding and debugging..."

https://www.softwarepreservation.org/projects/FORTRAN/Backus...

</sarcasm>

AI is going to expand the field significantly.

Of course, for profit companies probably don't want to implement an off-ramp.

[ Sigmoid curve image ]

Well... if we're just making things up, what we want is tools that have an effort/complexity curve that is just flat, at pretty much zero.

You can't do that though right? It's obviously impossible to make a programming language / system in which the effort doesn't scale in some fashion to the complexity of the task.

What the people selling no-code solutions are selling though, is the idea that a sigmoid like curve, or linear curve, or something might be possible, or maybe already is possible.

...but that is just made up.

It isn't possible with any current systems.

It's not clear that it's possible at all to have a system that works that way.

> The other main problem is how do you avoid the making complexity more expensive?

> This is less obvious.

It *certainly* is less obvious.

Honestly, it's probably provable that it's not possible to have something where the effort is asymptotically bounded as complexity approaches infinity. Fundamentally.

I'm not convinced that any current efforts in 'no-code' display a degree of realism toward approaching that problem at all.

The only real efforts in this space are currently:

- rust.

By having a very complex, very rigid type system, you can reduce the complexity of extremely complex systems (parallel computation) to being slightly less complex. It appears to scale reasonably well. It's not friendly, or easy, and requires rigid discipline that is enforced by the tooling. This is not a no-code solution, and the solution does not scale to no-code contexts.

- copilot.

By generating code based on simple high-level requirements, you can amortize the complexity cost by up-front spend in computational cost in the training and inference steps. This scales to low-code environments. The maintainability and cost effectiveness of the solution are questionable, but this is probably the single closest no-code solution in play at the moment.

It's probably still several years away from being available and reliable enough to use for non-programmers, but this is an extremely promising direction of research.

- excel

Excel is the workhorse of the business. Simple coding approachable for numeric purposes (eg. accountants) has scaled well to general note taking with light-weight coding for business purposes.

This is probably the most successful no-code solution out there, and really it's quite excellent. However, due to network effects, it's reasonably unlikely any other no-code solutions will succeed in this space.

Personally, the no-code solutions I've used have been pretty much: Build once, maintain never, you'll be ok as long as you don't try to do anything hard or custom. It'll be a constant work in progress until it gets too complex, at which point you will either throw it away and start again or commission a 'real' app based off of it.

...maybe that's ok.

I think, 'bin it, start again and you'll get 80% of the way there in a few days of prototyping' is as good as these tools will ever get, and maybe that's all most people need.

We'll see. Maybe AI generated code will revolutionize this space... but, I'm pretty sure none of the other efforts I've seen in it will.

They're all dead ends, that have been tried before, and failed before.