No-code or low-code still means you're creating software, even if you're using a drag-and-drop UI to do so. And if you're building software, you're going to want things like version control, environments, code review, etc. Unfortunately, most of these tools have zero ability to do these things, or have really half-baked imitations of them, and as a result the apps you've built in no-code/low-code are unable to scale as your company grows.
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.
These are good points. I have seen this over and over again - e.g. in a SaaS which is data configured, how do you a) develop and test your work in a sandbox instance, then b) ship those changes across to a prod instance.
This is especially complex in highly data driven platforms, e.g. when you can set up custom fields, then base your custom screens on those fields. Then you want to move a screen from one instance to another and it is dependant on several custom fields which may or may not be already present, but may not be at the latest version.
Unfortunately virtually no customers nor RFPs ask about these things, so they are a low priority until late in the piece and most platforms do a shit job of it.
Your approach is interesting, though most customers in our space at least would blanch if you said words like Python or JS to them, and would not know their git from their got.
Using code as the underlying format for low-code/no-code products is common and long-practiced; sometimes editable and exposed to the user, sometimes just to take advantage of existing code/text tooling.
People have been building NCLC systems for decades, but they tend to thrive best when they settle into a specific domain focus.
At that point, nobody outside the domain hears about them and nobody inside the domain even thinks of them in the terminology of “no-code low-code”
If you start squinting though,
you can spot them all over the place.
Famous example, Photoshop. UI that makes complex things seem simple...and a scripting language under the hood which ties into the (incredibly complex) internal operations, for the multitude of things you really can't do in a UI... and instead you get "plugins" with specialized code doing those complex, not possible to generalize in a simple UI, tasks.
> No-code or low-code still means you're creating software, even if you're using a drag-and-drop UI to do so. And if you're building software, you're going to want things like version control, environments, code review, etc. Unfortunately, most of these tools have zero ability to do these things, or have really half-baked imitations of them, and as a result the apps you've built in no-code/low-code are unable to scale as your company grows.
This.
A phrase that captures this sentiment is that no-code and low-code is "Duck Programming:" It may be marketed as being not-programming, but if it walks like programming and swims like programming and quacks like programming, it's programming. And the code itself is just part of the practice of programming:
> 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.
I personally don't feel like this is the future. It's similar to storing a Word document's XML in source code. The way the visual editing and thinking works doesn't map to the text-based storage format, which then makes source code control little more than backup since it becomes difficult to tell what actually changed. Maybe this doesn't apply to Airplane though, so what I'm saying is more general for visual tools and programming languages.
There's no reason why visual tools and programming languages can't have visual comparison tools. Text is not the end all be all for things that can be compared.
Comparing different versions of a document is separate from keeping track of its revisions (thus providing reproducible builds), and the fact that it is not a text file doesn't negate the utility of the latter.
For example, you can give tools like 'git diff' a custom command to run to compare certain files, such as a visual diff tool specific to a WYSIWYG document format. Even though existing source control tooling leans heavily towards text files, that doesn't mean they aren't still useful for binary files.
The Airplane website gets cut off at the bottom on my laptop screen and because of how you overrided the scrolling I can't scroll down to see what I'm missing.
(Edit: actually I can scroll down but it still doesn't look good having it cut off like that.)
No code is a sales tactic to circumvent engineering folks who would correctly point out that the tool helps with 80% basic use cases and for the remaining 20% engineers have to be involved, but now instead of using python or something appropriate, they have to build it on top of this proprietary crippled framework.
I would argue that’s almost using no code solutions incorrectly because they are good for super initial mvp and validation by people who are non technical.
I’m trying to be an entrepreneur and I’m heavily technical. My struggle is on the business side and figuring out how to talk to people, but I can whip up fully functional mobile apps in like 10-20 hours because I’ve done that so many times, or build a solid backend that can easily scale to millions of people (granted that’s not so hard these days).
I know how hard and intimidating it is for people without a technical background to SHOW their idea beyond a image or PowerPoint. No code helps such people get something working out and I’m sure once they raise money for their validated idea they can hire engineers to build good long term solutions.
I’ve never raised money so idk if that’s reality but I don’t think it’s purely marketing. It’s a valid solution for some people.
Anyone can put videos on YouTube to start but once they find their audience and grow the quality and production of the channel grows as well. No code is the same way. Start with what you can like your smartphone and focus on the content, until you’re big enough to have a team and nice gear.
I’m a heavily technical engineer and also an entrepreneur. I’m looking at low and no-code solutions right now (specifically Draftbit currently) because even if I can whip up something quickly, I can do it even faster with a low-code solution in areas that aren’t my domain. Also when I have a thousand other things to worry about learning mobile app dev as a primarily backend guy isn’t high on the list of priorities.
RAD (Rapid Application Development) is a valid way to brainstorm.
Offloading solutioning to other people or tools is also a valid strategy.
Ultimately, RAD is just a design phase. Commercial No Code companies aren't positioning themselves to be phased out of the design phase, they want to keep collecting your money for as long possible...and if your only advantage is that you have capital to pay someone to do your work for you, you have no advantage over competitors who are likewise capable of doing the same thing, against large companies who can pay much, much more money for the same thing, or eventually against people who figured out how to do it for themselves, more efficiently, than you.
I wish you all the best, so that you don't ever have to worry about learning mobile app dev because you are successful with the no-code mvp and can raise funding to hire mobile devs :)
Engineers end up having to be involved anyway. The marketers and business people who slap something together in no-code don't realize that maintenance is the fat bit of the SDLC and they get to the point where they either get overwhelmed by the complexity of the spaghetti they've made, they don't know how to make changes to make the no-code thing do what they want, or they just get tired of maintaining the damn thing. So over the fence it goes to Software, because "they're good at this sort of thing". And now all they have to do is open JIRA tickets -- or send Excel sheets -- with the changes they want made.
So yeah. No-code. Easy solution for implementing functionality for managers and marketers -- who have a team of developers they can offload the hard grungy bits to.
There are plenty of low/no/visual code environments that are very successful and ergonomic, some of it is free software, some of it proprietary. I refer to it as visual programming from here on, because it is still a form of programming, the 'no code' term is marketing bull that detracts from that basic fact.
A common theme is that visual programming part is a restrictive DSL. So its about configuration and composition. The visual DSL is coded in a general purpose programming language. This model is I think quite powerful.
CMS: In Wordpress for example, themes and plugins are provided via code. Users have varying degrees of freedom depending on said themes/plugins to compose them.
Game Engines: In Unity visual programming is baked in. Programs can expose varying degrees of configurability. There are whole visual programming tools that let you define logic and behavior.
Speadsheets: Already quite powerful on their own, can be extended with scripting languages to gain new capabilities and triggers.
Video and Animations: Very typical for visual programming affordances. Users often get drag and drop interfaces to encode logic and behaviors.
etc...
These types of visual DSLs are incredibly successful, because they allow the programmers/engineers to solve the technically interesting, general problems and the domain experts to solve the domain specific problems.
However I agree that these tools often go too far, especially if they don't respect where a visual DSL should stop. Almost half of the work I get is from clients who previously used a "low-code" solution that got them into a mess, which was slow, brittle and unmaintainable.
No code tools all involve code. What they skip or dont involve are as many decisions and combinatorial effects that most “custom” software gets saddled with. For example in Retool if you want a table you get a table. One table. You can do a lot with it but you skip all the debate about how to do sorting, padding, styles, optimization, etc. Thats valuable.
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.
"realistically the meat of it requires more “advanced” knowledge but so does making a really good spreadsheet."
Same way the no-code developer doesn't want to learn the harder (more useful tool), the coding developer balks at learning a shitty, constraining language. There is no advantage to learning and using a no-code tool, which is likely incompatible with other tooling. The knowledge is "useless". Its the same aversion a programmer has to "sphaghetti code", not because it doesn't job the done, but because the knowledge is specialized in a non-useful manner.
The advantage most developers have found, is that most languages in the C++/Java tradition contain portable idioms - I don't care if you don't know the exact syntax for a for loop, an if statement, etc, once you've learnt to program once, a decent editor makes learning language syntax largely irrelevant. If I were hiring, I would care that you learnt and can use 3+ languages, I don't care which (code) langagues.
Now, there are plenty of idiosyncracies within textual languages - package managers, arbitrary gotchas due to language design (is it a reference? immutable? Does it live on the stack/heap/get auto collected?) - textual programmers shouldn't pretend like we live in a perfect world either. Most no code solutions though are going the complete opposite way of standardization. Its like being told "here's a jail, its your new home" and being supposed to be OK with that.
But to effectively use logic apps, you already have to have some knowledge of programming concepts. Flow control, parsing JSON/XML, parsing strings for meaningful triggers, calling API's.
A non-programmer would have a tough time. A programmer can build some pretty nice automation in almost no time at all.
I have yet to see a really good no-code solution that lets laymen be productive fast.
Excel probably hits the sweet spot for no-code vs low-code vs actual code. The transiion between the levels is completely seamless. If you want to add a complex calculation you can. If you really want to go crazy, you can too. Sure, it's not maintainable, you can't google the formula syntax (because it's translated) etc.
An important aspect of "no code" and "low code" isn't that there is no code being typed, there is "no coding tools", "no code compilation", "no code maintenance".
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.
There’s always that one feature you need that’s not supported, and because you can’t just write some code to implement that feature, you’re stuck.
I’ve told this story here before, but I spent a day knocking out a couple of hundred lines of code to provision users in our system. But we wanted to trigger that provisioning from Okta, so someone else spent months implementing it in Okta’s no code system. And at the end of the day only that dev knew how to use it or how to fix it. We would have been much better off keeping it in Python.
Yup i'm pretty convinced the whole no code thing is just a scam.
People claim it's different from the old school no code and that it's faster to prototype in. Anything I look at is just the same drag and drop blocks of code, scrolling through a library of blocks of every function possible looking for an if statement, it really is a solution in search of a problem.
Management keep asking me to use it because "its easier to work with because you don't need to code!". I ask them if I already know how to code why would it be easier to use a new system I don't know? Blank faces all around.
Yes, I am sure. I am envisioning a hybrid between a GUI reducing the programming to dragging arrows between neat boxes, and co-pilot moving the mouse like an aimbot, freeing the non-programmer from having to do the totally-not-programming things with those arrows. This will be a great future.
I've worked a lot with no/low code solutions. There actually ended up being a lot of code! Surprise. Code is an interface between human desires and customising computers. There are infinite human desires, thus there will be a need for an interface that is 'code', even if it isn't a big file with scary ASCII characters.
My last project with a no-code solution was a visual designer where you flow-chart all the logic for workflows. At a very small scale, it might make sense but even for our meager need it was blown out so big that no one could really understand or modify it. And, worst of all, we were locked into this proprietary solution.
In the end, I re-wrote the entire project in regular code and the end result works better and is easier to modify. We don't need to pay expensive consultants anymore. No extra licensing fee. No special software/server/hosting requirements. And any programmer can work on it -- I can even put new hires on it.
Rewrite in code is way easier than developing in code from scratch. I think your scenario reflects the main benefit of no-code, to let business users fix their own requirements.
This is a good point. Most comments about the rewrite in code being easier might actually be because the functional requirements from the business users have already been made clear without the ambiguity that might have arisen when developing from scratch.
In this case, this is absolutely true. All the requirements were well established and converting it was very quick because of it. But ultimately that doesn't matter because the reason the re-write was done was because the no-code solution failed in it's goal.
The process of developing this solution was funny. We had an absolutely fantastic team doing the requirements and the process was all agile except when it came to the tool itself. At that point, it turned into a waterfall project where everything had to be nailed down before the work was done.
I can mock up a application form very fast so there's really no need for a tool to do that every so slightly faster but in a proprietary and limited way.
> I think your scenario reflects the main benefit of no-code, to let business users fix their own requirements.
wvenable stated that the no code solution was so complicated even the developers could not make sense of it, how does a business user with no development knowledge make sense of it? If the code is in pictograms instead of words I don't think that makes it any easier on the non developer to be honest with you.
I see this being cited a lot but I know from experience the business types like the idea of them being able to do everything themselves, but they won't actually do it.
My business users insist that every part of their site be editable in the CMS which we give them access to, a manual and training explaining how to use it, after 6 years not one of them have ever used the CMS, at most they will login to test I haven't cheated them on the CMS functionality.
They all just phone me and ask me to post a news item or change contact details etc because "I don't understand all that technical stuff" its literally a text box and a save button. I don't see them getting over their fear of technical stuff and getting their hands dirty because its pictures instead of words.
I don't know how my scenario reflects the main benefit of no-code... the visual designer "code" was so complicated that literally nobody could work on it. We were all trained to make changes -- both the business users and a small group of developers. In theory they could make changes but in practice it was just too complex. Some minor things were changeable by them but the big changes started to pile up.
When we converted to regular code, the business users loved it because all the changes that were too complex to do in that product suddenly became both possible and quick. They lost the ability to make small changes themselves but, given that we could do it almost instantly for them, they didn't care. We're all better off because nobody has to know the quirks of this priority system anymore or be limited by it.
> At a very small scale, it might make sense but even for our meager need it was blown out so big that no one could really understand or modify it
A human can hold about 10 objects in working memory, a diagram can help you bump that up to about 20-30 objects, but it gets cluttered. I've been a long time user of mind maps and know they quickly get unwieldy. For more complex information you can use Wiki style web of links but lose the overview mode. Wiki would be more similar to using plain code.
It seems like one of the assumptions behind the no code hype is that product managers know exactly what clients want, and if they could just remove those pesky engineers from the situation they could deliver it. Which should be pretty funny to anyone who’s ever worked on a large greenfield software project.
The argument will continue to raise its head and it's a fair argument. But I think it is important that we evaluate on a per use case perspective.
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 don’t understand the need for no-code software development.
In my admittedly limited personal experience, any domain experts that were worth their salt were smart, and learning a programming language or two to the level required to make useful code contributions wasn’t really a problem.
A physicist often learns some programming language anyway, somewhere along their educational path.
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?
Positive thing about no code is you can take a reasonably intelligent person with almost no technical no how but a willingness to learn and have them creating real software with a good low code solution in a month. Of course they will likely need someone with real experience to guide them for the first 3+ months. You need a really good training program though. Often the sales pitch for what these applications can deliver is overly aggressive though and the user is going to have to start to learn software architecture concepts eventually so everything is not a mess. I moved from full stack development to low-code and have been really impressed. There are of course limits, you can only use the components that have been created for the platform but overall you can produce some impressive applications. There are some very large corporations run by very smart people that have gone all in on low-code for the front end.
> Positive thing about no code is you can take a reasonably intelligent person with almost no technical no how but a willingness to learn and have them creating real software with a good low code solution in a month.
I would expect that of any one trying to learn code tbh. Physics students in uni learn c in less than a month.
no-code software can work just fine if the scope is small - and that's where you find the target audience.
"back in the day" it was super easy to just slap together a GUI software using Visual Studio, Delphi, or whatever you had at hand. Really simple editors to make the GUI, and with basic programming knowledge, you programmed the various functions. Easy as pie.
If you wanted some software to run on a website, you could do the same with Java Applets - if you knew some java.
Again, this is stuff that non-programmers could learn in a fairly short amount of time. Business analysts, professors, engineers, whatever.
But what about these days? Well, even if you're smart - even if you know some basic programming - EVEN if you have the will, webdev is a fucking nightmare if you want something that's not static or very basic. The hoops you have to jump through, just to get your idea ported to a website.
These people are not going to write large applications or services that needs to be fast, scale big, be fully tested, etc. They mostly need some quick and dirty apps that can solve things, and without a too steep learning curve.
I'm wondering if anyone reading this thread (maybe ones who are shaking their head as they do so) knows of an existing meme for things of this sort. 'Snake oil' is the completely wrong metaphor here.
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.
I tried Appsmith, Budibase and a few others, because I had a need for some admin UI for a startup, and I thought that low-code would get me there quickly. I thought I could take a shortcut. I'm an experienced coder, so my biases surely play a role here. I was expecting these low-code tools to offer abstractions to make the effort for low-complexity problems very low (like the article suggests). Instead, I found that they were really just a point-and-click version of the code writing I'd otherwise do. All the complexity was still there (at which time the ergonomics of the tool becomes very important, and let's just say... that didn't help). I think the article is thus also flawed in some of its assumptions and conclusions.
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).
I wanted to love Appsmith but I kept running into telemetry code, including a hard coded segment id baked right into the base docker image. Sorry, but I can't defend your business needs during security review.
First of all, thanks for trying out Appsmith and doing a security review. The link you pasted is actually an out-dated installation script that we used to use only for tracking if a user is facing errors during installation. This script has been deprecated approx 10 months ago. We should probably remove it from the code base as well to reduce confusions. Now, you can spin up a Docker container directly without having to go through any shell script.
Having said that, Appsmith doesn't track any PII data from an installation. Any & all telemetry within Appsmith is strictly opt-in. You can disable this as well when setting up Appsmith or any time afterwards. Please check https://docs.appsmith.com/telemetry#disable-telemetry for details.
We understand that security is paramount to users of Appsmith and thousands of teams use Appsmith to interact with sensitive data. Hence, we take data security very seriously. If you have any concerns about our security practices, I'd love to hear from you at security[at]appsmith.com. We will aim to fix any such concerns immediately within the product.
I've had the displeasure of re-implementing some awful systems written in a no-code platform.
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.
The problem with code vs no-code is that the only barrier it removes is the code. The “code” is the easy part.
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.
This is an understatement. Main problems are versioning, collaborating, maintenance.
Coding is like writing a story with other authors, with each chapter inspired by /writing-prompt, and publishing the whole book with new ISBN for every typo.
If app-publishing is fast, {no|low}-code wins. The obvious caveat being, that it is not a full fledged system where you can build yet another no-code platform on top of it.
So I was recently very attracted to some no-code platforms because I have a simple cloud based application that interacts with some APIs, authenticating with OAuth2. I know what I want to do, but as a primarily systems developer with very limited web development, I have no interest or desire to start creating websites to perform user authentication (not least when I only have one user), along with storing credentials securely, running a server etc etc.
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 1: The point where the two curves meet is almost always met sooner in a projects dev-cycle than expected.
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.
The idea of using spreadsheets is very clear, data in tabular form and charts. If that is the requirement, most low-code platforms would suffice too.
But, then the expectations are not articulated and managed properly, and management being management, thinks that they can retire grumpy oldies who build complex app in favor of low-code apps.
Which is itself built on the flattened rubble of 4GLs. A couple companies made a go of round-tripping from UML to code, but you know someone was hoping to stop that merry-go-round on the pretty pictures.
I'm sure there is a place for no-code tools, but LabView left a very sour taste in my mouth after seeing how much it was abused to do things it was pretty much the worst tool imaginable for.
The worst tool imaginable, that you have and know how to use, beats many more suitable tools that you don't have and/or don't know how to use.
I don't like no-code tools. I think they fall into the Evil Wizards category. (Roughly, they trap you into a dungeon that you can't escape or extend.) But they do let people who are not us do things that they could not have done without the tool (or, if they could have, they would have needed us to do it for them). That's powerful.
"They're a bad idea for professional programmers" is very different from "they're a bad idea for everyone". The only gotcha is, the non-programmers need to learn when to stop trying to extend what they've built with the tool, and get the mess re-written by people that can code.
That sounds elitist. (It even sounds rather elitist to me!) But it's really no different than knowing when to take your kid to the ER instead of trying to fix them with your first-aid kit. Some things you can do as an amateur, and that's good. It's empowering! But you need to know when you need more than an amateur.
A lot of negativity towards no-code in the comments, which I think is misguided. These tools also makes developers lives easier and help us serve the customer better.
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.
Unqork uses Unqork to deliver most all of it's SDLC capabilities because yes, as some folks stated to start this: no-code is still creating software and you need visibility, governance, etc around it.
Agree with your complexity vs effort graphs but that is exactly where no-code tools have worked well for me. Example: Our CRM has a very complex data model and Salesforce UI is hard to use. With a no code tool, I can wire up a simple UI and use their connector to populate the fields and allow folks to make changes in a much simpler / somewhat automated way. This saves us a few hours per week and it took me 3-5 hours to build. I don't really need VCS, code reviews etc. here. If I ever had a bunch of related use cases like this, I would then want to invest in a yes-code solution to solve the combined set of use cases.
The problem, as is often the case, lies in definitions.
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.
As developers we like to think we are super smart because we learned to code but it's really not that much of an accomplishment.
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.
And learning to code is investment in a skill that builds up on itself like a snowball, whereas no-code tends to be disposable as platforms come and go.
This is where low code is good. It can be a great on ramp to deep coding. FlutterFlow seems to strike a good balance, as you can use the OpenAi codex in writing custom functions.
I'm a tad unusual in this discussion, because I write add-on code for a no-code tool (that you've never heard of, or instantly dismissed if you have.)
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.
Wow. As someone working on developing a no/low-code solution, that was an insightful comment to read, thank you. I can see your words are based on personal experience.
I like that you acknowledge the potential issues and weaknesses of the approach, but lean hard on the value it can offer. I agree with that too, from my own experience seeing how the system I'm building, imperfect in various ways, is valued by a growing userbase in the real world.
I especially relate to the strange niches where such solutions can be found to be powerfully practical, solving all kinds of needs for the end user (who are often businesses using such tools internally). People have remarked on how Excel spreadsheets have been ab/used to great lengths, providing tangible benefits as well as possible nightmares.
> ..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.
Personally I feel it's 80/20, or less still - but I do believe no/low-code solutions are pushing the threshold described in the article, where they're better/simpler/easier to use and solve user needs, without going into the world of code. I think it's still an exploratory field, finding what patterns work best, the right primitives for people to work on a higher level of abstraction than code.
I think perhaps a critical part of the equation is in creating a seamless mix of code and no-code.
In my environment I never have to choose between the two. I code when I need to code, I use the automation when it suits my need.
Take excel as an example. It already does a lot (no code) but allows you to code (vb script) when you want to and if you have the skills.
My field is even more niche - I'm the guy writing new code, then exposing that code, and integrating that code, into the no-code layer.
I'm not limited to "what is available" - it's a full language under the hood. Well multiple languages actually. In addition to the system language I can also write C, or even assembler, that's all part of the system. So I just drop down as far as I need to go.
I think “code” is already at the right layer of abstraction. “Code” already solves this problem and has the curve the author’s looking for. “No-code” is a simple case of the wrong abstraction.
A form submit is akin to function call, so it's just how much your function would do. You could build a form that just move a hex to a register, and you will get assembly programming via lots of user interactions.
I think no-code fad will get blown away by a) a tech crash and b) the next gen of web frameworks that implement all we've learned about GUI/UX/DX over the past decade
I enjoyed the no-code vs code intersection framework. I would like to add that one needs to take into account that the no-code/low-code curve is _dynamic_: tools are always pushing to the right so the intersection between curves is not always static.
I don’t think so. They are (typically) hard to test, don’t use version control, don’t handle edge cases from pick-a-customer, etc. Fine for trivial use cases. Hard for anything special.
This will in fact be the case. If we can instruct an AI to draw a picture of Donald Trump catapulting himself over the Eifel Tower, then software can be instructed to write working code with basic English. It's just a matter of time, and the writing is on the wall for us.
This viewpoint manages to miss the purpose of nearly all software engineering.
We've already solved the tough algorithmic challenges relevant to most industries and those software engineers spend their time writing specifications that just happen to be programs. Their job is to have hours of discussion and think through edge cases to provide an exact description of the business requirements. Good engineering means thinking through edge cases and gray areas while the PMs and designers capture broad requirements from users and focus on high level details. You're not going to replace engineers in this capacity without human level, general AI.
Further, you cannot capture the needs of a tech-enabled business with natural language descriptions while remaining unambiguous and changeable. If you had an AI to write your programs, you'd still have engineers writing specifications into the AI (and even more importantly, deciding on those specifications down to the most intricate if details).
We will in fact see an explosion, or at least mild expansion, of software engineering into areas that are algorithmically challenging. AI will manage to solve the tough algorithmic parts and engineers will drive the AI through increasingly specialized languages. In this world, AIs will act like compilers.
But it's just super futuristic and naive to think that a PM will tell GPT-3 what to make like a Google Home and have it pop out the other side.
Have you seen the GPT-3 programming demos? It is super futuristic. We programmers are still going to be needed, but what we do will evolve. Just look at how much Github Copilot gets right. It's still early days so there's still a lot it gets wrong, but there are a lot of improvements yet to be made.
It’s still a tool though. If these AI tools simplified the work of sw engineers there would indeed be fewer of our ilk wielding these tools but a larger chunk of engineering would move towards maintaining and co-evolving these tools. I don’t really see an end to it while I do see an end to my own willingness to keep up with it.
Whether or not Copilot makes it, that's just how tech industry is. First there were mainframes, then there were desktop computers, then there was the Internet, then there was the smartphone. Tech evolves and if you want to stay relevant, you've got to keep learning along with it. Or not. There's still a market for COBOL programmers.
> So in an ideal world, what we need is tools that have a effort/complexity curve that is both visible, and looks like this:
[ 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.
Probably because most people hear no-code and think "simple apps built by biz users." Unqork is building a no-code platform for professional developers.
Disclaimer: I work at Unqork and I’m a professional developer. Our target audience isn't citizen developers. Sure, no-code makes it easier for business users to get more involved in the development process, but apps built w/ Unqork are built by developers. I’m talking complex, enterprise-grade stuff.
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.