In Defense of No-Code’s Potential
buttondown.email
buttondown.email
Anyway... I thought I'd struggle without a language to call into but in fact they work really well. I settled on Isadora (on a metric of fastest-time-to-cool-output) and I haven't hit a limit yet.
So my reason for writing all this is that I think, and I know I am rambling here, that domain specificity is an important factor in the success of a low/no code tool. Generality exposes the complexity ceiling.
Isadora has GLSL too, and a JS actor which is nice for stuff which gets tedious to patch like a calculation with more than one operator. I have used that one a couple times.
It's about how easy and how consistent the idioms are.
If we look at frontend js... There is a new framework every other month because no one really found out the most minimal, straight and dumb way, to create a UI.
Give me grokkable code over pithy code everyday.
A guy can dream at least.
If you select a set of actions from a "flow" in the PAD low code UI, copy to the clipboard, and paste into a text editor, you'll get the code for the original steps in a language called Robin[1][2], a DSL for Robotic Process Automation.
If you paste a selection of Robin code back into the PAD UI, PAD automatically generates the corresponding low code steps.
Public work on the Robin language appears to have ended in 2021. I seem to recall having read that MS acqui-hired the team and shut down the public-facing side of the project, but I may be misremembering that part.
1. https://web.archive.org/web/20210306173947/https://www.robin...
Recorded steps in the GUI generate code that can be manually edited.
They center more around code, and then builds app and flows based on the code/scripts you create. It's been a really pleasant experience for me. The first time I looked at the product I did not quite get it. But when I tried it I was hooked. It was not what I expected but what I needed.
You can have your code in git and use vscode and push scripts up to windmill if you like, I do and like it. You CAN also edit flows and apps from vscode. But I'm quite sure you do not want to - meaning it's JSON you will change and not the underlying svelte scripts.
I actually started using windmill after I described my pref. low-code solution on HN and what I felt was missing and got a response back saying that I was describing windmill.
The foundation of the "off ramp" to me is an RDBMS - I've been evaluating these tools by pointing them at the same db and working on the same app which has been very illuminating. It might be a bit trivial for HN, but I really should write it up properly somewhere.
I'm happy if the data and its constraints are in a robust RDBMS - OK, Postgres! - that is something I can build on, in parallel potentially.
This is the critical argument against no-code, the one argument omitted from the article: No-code doesn't make programming go away. Any time you have graphical flowchart symbols or whatever specific enough for a computer to execute, you have something isomorphic to a computer programming language. Except it's more difficult to change, maintain, move around, read or edit with different tools, version control, etc. No-code is programming, with extra hassle. And the hardness doesn't go away -- in fact, businesses that adopt no-code tools so their marketers or managers can create automation tasks, tend to throw those tasks over the wall to the software engineers once their original authors find that programming is hard and they have much better things to do with their time than debug flowcharts.
I'd add the option of commercial hosting and support to that list, which led me to Budibase - great product, although in the end I was left feeling "no code - but so many clicks!", although I have not gone back to look at v2. https://budibase.com/
The author might care to take a look at Saltcorn, which is in the "Goldilocks" zone for me - enough of everything, not too much of anything. I should write that up myself. https://saltcorn.com/
(edited to add line re. web vs. native)
It's opensource - so you can self-host. The UI is quick and responsive.
But my favorite part of it is that it centers around code. Other tools like zapier and retool (my experience) and budibase (your experience) are so much many clicks and if you drop down to code (aka the off-ramp) you need to program in a input field. With windmill you have an LSP and the Monaco editor (the code editor that powers VS Code) and you can have sync to git. So if you like you can sit and program in vscode, but are you doing small changes you can do it in the web gui. So code is "native" to windmill and it feels so nice.
(no affiliation, just a happy user)
> Reorder a photo directory from year/event/photo to event/year/photo
> Check daily on a few airbnbs to see if any lowered their prices
> Sending a PDF on your computer to your kindle via Amazon’s “email the file” thingy
> Check if there’s a Cubs game today to avoid the trains
> Take some structured data and put it into a template
I believe that all these kind of tasks will be fully doable through ChatGPT(-like) assistant.
No-Code solves the coding part but you still need to be able to express the requirements, which is difficult for someone who doesn't have the thought process of a coder.
ChatGPT also solves the requirements part in that you can speak in English and be vague and (if you're lucky) it understands what you mean, just as a senior coder might.
I've seen non-technical people build some really cool things off of the back of spreadsheet data using things like AppSheet and Google Looker Studio (not sure why they changed the name from Data Studio). And now with Excel adding a ChatGPT formula and Google Sheets adding their own AI-driven features, power and non-power users alike will be able to really up their capabilities using only plain-language queries without having to devise complex algorithms or formulas (I realize ChatGPT isn't flawless yet).
If only we could onboard a friction-free process from Excel to git! Some way to configure Github Actions, say, and have them upload their sheet somewhere. #ExcelOps
I think it would be easier then to say, "Here's why a real app would scale better." And they would be 100% behind that.
>What does an algorithm look like?
Flowcharting and diagramming pre-date computers and used to be popular ways to define software workflows --- why hasn't that directly translated into coding?
The Drakon Editor folks short-circuit this with the idea that the desirable option is always straight down --- is that a viable solution?
The Node Editor folks have solutions which some folks use, but there are also sites filled with literal visual spaghetti code:
https://scriptsofanotherdimension.tumblr.com/
It's been the better part of a century since Herman Hesse wrote _The Glass Bead Game_, but the most flexible systems still end up as a wall of text, which can be hard to format, or which one limits to plain text --- all-too few programmers avail themselves of:
http://literateprogramming.com/
One promising development is Nintendo's _Game Builder's Garage_:
https://www.nintendo.com/store/products/game-builder-garage-...
(which when I gifted it to a co-worker's son was described as "This is the greatest game ever!")
These days I mostly do 3D, so have been using BlocksCAD:
https://www.blockscad3d.com/community/users/67750#/?_k=7br97...
and OpenSCAD Graph Editor:
https://github.com/derkork/openscad-graph-editor
I'd love to see a similar tool for making a GUI program.
I am interested in this space. I wrote something I called living documents which is a GUI for composing together behaviours.
There are screenshots here:
https://github.com/samsquire/liveinterface
The idea was that you could create a data model and widgets as easy as embedding them in a document.
Jupyter Notebooks seem a step in the right direction, but there's no provision for the appearance AFAIK.
> Native > > I can see some of the benefits of cloud-based no-code, but then you can’t work with the computer. Ideally it should also “feel” like a native program, too.
That would've made for a good argument in 2000, maybe in 2010, but today? Corporate computers are usually locked down too much to allow installing native programs (and for good reason); while more and more households no longer bother with a full-on computer, relying more and more on phones and tablets.
If you really want to bring no-code in the form of easier automation to the masses, it has to be accessible from a web browser. Especially if has to run regularly to check on things; even among those who still have a desktop, many wouldn't want to keep it running 24/7 nor can necessarily guarantee good enough network connectivity.
Locally we're playing with "no code" but we're very much making sure it's "leaf node" sorts of tasks, that consume other services but don't provide them.
I think no-code should probably be contextualized in the context of other professions in the business. Would you take a no-accounting solution and hand it off to the programmers? Simplify away the double-entry bookkeeping (too hard for non-accountants, which, I mean, that's not sarcasm, it's really quite close to the truth), simplify all the accounting details, and then let the programmers run the finance department? What would the expected result be? Why would it be any different if you took a no-lawyer system and handed it off to sales to try to run the legal department?
There's a place for such tools nevertheless. Expense reporting software is essentially a "no accounting" accounting tool, for instance. But you keep it carefully fenced in to where it makes sense, you don't go trying to turn your expense reporting tool into the accounting software for the whole firm. I think no code has a valid place in the business but you need to make sure you're not doing the equivalent of claiming it can run accounting for the whole business.
> Step one, take a paragraph of text, any paragraph, and uppercase everything. No catch here, just make it allcaps.
> Step two, find a bunch of friends who don’t know how to program and ask them how they’d do the same thing.
This is so, so true. Even amongst programmers. I've lost count of the number of experienced developers I've seen who go to an online JSON viewer site [0] to parse the server response!
But harder to maintain. Harder to version and see diffs, harder to test....
This is one of my standing questions. In a purportedly capitalist system, why does unfilled demand exist in a market?
The reason that comes to mind is non-capitalist drivers affecting the market. Do we need to address those, or confess that we're less capitalist than the press releases say?
Because people aren't, generally, willing to pay for things.
The things people are willing to pay for, are pretty well covered. The remaining free things are generally the results of passion projects by the creators. This is going to create very different products than a market driven approach.
Capitalists are terrible at investing in basic R&D: long-term returns, hazy benefits, hazy costs. Only the fattest and most outrageously profitable corporations have an appetite for it, and it's always the first place to see cuts in a downturn.
Occasionally an artist, a lunatic, an ideologue, or a combination of the above will look beyond the framework of profit and find some other reason for making an economically suboptimal decision. If they succeed, the state of the art is advanced, paving the way for capitalists to crawl out of their previous local maxima and start making copies and minor iterations.