Hacker News Reader

Isn't this the problem with all no-code / low-code platforms ?

Code is merely the leanest human-readable representation for loss-less specification of requirements.

We're seeing this same pattern with 'K8s YAMLs' and 'prompt engineering'. There is an entire industry that's re-inventing new DSLs which inevitably converge to a scripting language as requirements get more complex.

Instead of reinventing the abstraction, I'd like to see no-code UX patterns that losslessly map onto the underlying abstraction. That way you can use the UX pattern until it gets too tedious, and occasionally dip in-and-out of the code-view in a non-jarring manner.

Graph UI for manipulating git trees (gitgraph) is a great example. Orchestration UI views (Airflow / Langraph) are another example that's getting there. At a higher level of abstraction, Notion (CRDT UIs) do a good job of representing collaboration-locks using blocks. At the highest view, I'm a big fan of how Gather-town represents remote collaboration.

I'd like to see more of this.

From my viewpoint the benefit of low-code is that the average business application is a matter of people filling out forms. If you want to radically lower development time you have to solve all the problems

https://worrydream.com/refs/Brooks_1986_-_No_Silver_Bullet.p...

For instance, a 2025 no code platform is likely to have "one click" deployment of a cloud application. That's great if you can accept that but if you require "on prem" this is either disqualifying or requires you to build an environment on prem that can host whatever it is they generate, which could be more trouble than building an application the old fashioned way in an environment you already know how to run.

A conventional analysis is that you should be able to generate a CRUD application out of a schema: you need a little bit more than something that looks at a SQL schema and creates a form to INSERT, UPDATE or DELETE, but that's a start.

One problem is that people write schemas that suck despite there being a body of "commonsense knowledge" about how to the world works. I had a year when I fixed a tremendous number of broken applications and one insight I got out of that was that whether it was a student who went from being an applicant to being enrolled to being an alumni or a pallet that would live in a logistics network and then enter a "reverse logistics" network and be inspected and possibly repaired to be returned to the logistics network the same data model of an object going through a number of states with state transitions was general and much better than the 15+ date columns that were added haphazardly to those columns.

Another example that kept turning up was that the ticket "1 phone number for a customer is not enough, support 2 phone numbers" is inevitably followed by "2 phone numbers is not enough, support 3 phone numbers" -- it saves time to work the proof by induction up front and just support N phone numbers up front. But talk that way and people think you're a lunatic like Doug Lenat.

Deployment, code generation from schemas, and schema generation from meta-schemas are part of the solution but if you can't solve 100% now getting that last bit is ultra-hard mode because all the essential complexity hidden by the framework is suddenly in your face.

> Another example that kept turning up was that the ticket "1 phone number for a customer is not enough, support 2 phone numbers" is inevitably followed by "2 phone numbers is not enough, support 3 phone numbers"

Zero. One. Infinity.

https://en.m.wikipedia.org/wiki/Zero_one_infinity_rule

YAGNI, handle a singular case, and once you have multiple treat it like a list.

In the case of the phone number or email it is just so frickin' predictable what will happen.

Adding multiple non-list fields is seductive because going to the list is a "structural instability" that requires using different coding techniques.

Right now I really like https://www.react-hook-form.com/ for forms that have list values. Back in the day there were a set of techniques that seem forgotten (like how the Egyptians built the pyramids) that some developers knew and others didn't.

It isn't hard at all to make a no-JS form where you had an "add" button next to a list of values. When you click on that button the POST data contains everything in the form as well as the key/value pair for that particular button (and not other buttons) so the back end can tell which button was pressed and redraw the form with another field. Delete can be handled the same way. If your form is not junked up with 50MB of trackers and ads and metadata for every social platform it is really fast, it was really fast even on dialup.

With a handful of helper functions and a "router" that can display different forms depending on what you enter you can make powerful no-JS forms but that knowledge didn't quite reach 100% penetration before Angular came along, but developers who came on after that never learned it.

I must say, React Hook Form offers a good way for React to interact with forms. There are many things to dislike in that ecosystem but that lib is excellent.

Change management, designing schemas for being amenable to change management, having systems that can migrate data with an understanding of what historical context in which that data got into the system (was it imported from a source with a nuance that was fine before you changed the form, but now makes less sense with the updated meaning and positioning of the field?)... all of this is what makes software hard, whether low-code or high-code!

One of the ironic things, to bring it back to Figma, is that giving designers and stakeholders Figma in all its glory becomes a justification for having engineers on the project, because you can't realize those exciting design visions with just Airtable and the like. Those engineers aren't useful because they can write code; they're useful because they'll (hopefully!) think through those change management and schema design considerations, building something that will be maintainable in the future. It's a good thing to have a design tool that incentivizes a level of foresight before launching a product that's meant to be best-in-class.

>> an object going through a number of states with state transitions was general and much better than the 15+ date columns

It amazes me that anyone would write a schema with a dozen date columns, but I've seen such things. Once you're dealing with a large database of something like that, it's tempting to just add one more column rather than pitch why you should refactor the whole thing.

I try to keep my schemas relational as possible. Actions and immutable records should obviously be stored in separate tables from the objects they reference. However, this does make the UX form design / CRUD process less amenable to simple solutions where forms are just generated right out of a schema.

Your phone number example highlights this. In general of course you want to store contacts in a separate table from customers. But that means you're probably going to need a separate contacts sub-form within your customer form, rather than just inline phone fields. Then form will need to be required or inlined for any new customer before the main customer form can be saved. Stuff like that.

Over the last 15 years or so I've built and refined my own form generator, really a DSL for designing forms that fit this type of thing. In its more basic use cases, each form lives as a row in a database, with each form_item linked to it in a separate table. The form runs a pre-fab query that expects N inputs that it binds to :variables (usually in WHERE or HAVING clauses) and then renders a pre-populated visual form with various input types like dropdowns, checkboxes, calendars, etc (based on those form_items, which can all be styled, required/not required, required based on other answers, etc). Each form_item has its own standard validation or custom validation function on both the client and server side. The form knows which table it wants to write to and which bound variable is the id field it's going to target for update. Sending it a blank id field renders the form with nothing populated and then does an insert instead of an update when it's submitted. It's very slim, about 500 LOC of Typescript and 700 LOC of PHP, including most standard kinds of validations on both ends. I've always toyed with the idea of releasing it it for people to use, but here's the rub: If you want to do anything involving writing to more than one table, you need to write a custom final function for those additional insert/updates.

So, it's a lovely system, but someone coming to it naively would run the risk of designing schemas that were not expressive enough, to try to keep the CRUD system happy. And I think this is just an inevitable problem with all low-code solutions: They don't handle multi-dimensional data the way you want a clean schema to handle it. (And neither do users).

I've made automated form editors, companies I've worked for have done it. They had data nesting, with no custom functions for handling it. For example I've made a fully customisable menu editor where you could add sections, sub sections, prices to items, prices to sub items, prices for picking 2 out of X items in the menu. All sorts of crazy (optional) nesting. All saved in different tables. Took me like 2 weeks. I felt very clever at the time. Frontend was all in jQuery too!

They all saved to relational databases with multiple tables. One form editor (which wasn't mine), allowed you to add new columns (this was in the on-prem days and back then they avoided future collisions by prefixing the custom columns with ex_).

The problems you listed above are solveable. You don't need custom functions, you need clever property naming. Most ORMs have to solve them too.

So nested data is not actually a problem for lo-code solutions, it's a solvable/solved problem.

And I STILL regularly leave that sort of data denormalized. I write multiple date columns (e.g. created, lastUpdated, etc.). I still write mobile + work numbers as columns for plenty of apps.

Why? It's simple YAGNI. For many apps it's quicker and easier to denormalize the data and keeps the code much, much simpler.

Plenty of apps that I've seen that have been going 15+ years haven't normalized that data and it's fine.

The problem comes when no-one refactors and keeps adding them.

But it's extra work and it's "dangerous" work, potentially data destroying if you get it wrong.

You get no thanks, as other devs will moan it's more complicated to use, and if you slip up you might get fired.

So most devs take the easier and safer option and just add a new column.

> Code is merely the leanest human-readable representation for loss-less specification of requirements.

Hum... That's assuming you have a perfect development stack that hides all non-essential complexity.

And well, I have news for you, that's a low-code platform. A generic stack that hides every problem but solves every requirement just can't exist.

While code may no be the leanest human-readable representation, scripting languages are a quite deep local minimum. There is a difference between hiding complexity and blocking you off from complexity. Scripting languages work because when you encounter a problem your library / framework can't fix, there is at least a basic procedural Turing complete language to fall back on.

> I'd like to see no-code UX patterns that losslessly map onto the underlying abstraction. That way you can use the UX pattern until it gets too tedious, and occasionally dip in-and-out of the code-view in a non-jarring manner.

What are you describing sounds a lot like Saleforce and other CRM systems. Often the code implementation get hidden away when it's not something native in the no-code solution. Then "magic" happens and you don't quite know why until you dig into the code again.

>Code is merely the leanest human-readable representation for loss-less specification of requirements.

I think you might have meant "loss-less specification of the current design." requirements are aspirational, and signifies the intent, code is the loss-less version of how the system will actually behave.

No, I meant requirements.

Stated otherwise: "Sufficiently advanced requirements are indistinguishable from code".

Abstracted requirements define outcomes. Fine-grained requirements define code.

I respectfully disagree.

The customer has given a requirement that states the variable <y> has to be calculated as y= x +1.

However, the code that exists has been implemented such that <y> is calculated as y= x - 1.

y=x-1 is how the current system behaves. However it conflicts with the actual requirement, which is y=x+1.

Regardless of whether or not the code is correct, it's still defining the behavior of the system.

If the customer would like to describe the ideal behavior of the system, the only way is to translate it into code.

As a dev that does a lot of his own design, I’ve never really understood the need to build a full fidelity reproduction of the layout systems a design is targeting. The limitations and considerations involved are deeply internalized and for the most part, I know exactly where designs tend to break and how to account for them. The layout system is effectively running in my head the entire time I’m mocking things up.

So while it’s nice to have tools to help with menial bits like correct spacing, getting every little behavior right in the mockup feels a lot like unnecessary busywork.

Naturally things are a bit different in a team setting, because it can’t be assumed that everybody involved has this level of knowledge/experience, but well… maybe it’s not crazy to expect designers to carry this set of skills, and it’s perhaps not a good thing for parties outside of design and engineering to be able to easily poke and prod at designs directly. Having the design team as a required intermediary helps sanity check changes.

I had my UX designer girlfriend read “CSS: The Definitive Guide” and it changed the way she looked at her job. She taught me Figma and it changed the way I look at my job, and hers.

Learn as much as you can. Specialization is for insects.

What did you learn about Figma that changed how you think about your work?

I advocate for learning as much as possible as well. It comes naturally with being self-taught. That said I think it’s also worth zooming out and giving things a look through a critical eye to ensure that the things we’re learning are necessary and worthwhile.

There are still a number of “old school” UI designers out there who’ve resisted trends and have staunchly stuck to a more traditional workflow, where they start out with a rough mockup made in e.g. Photoshop and then iterate the design alongside an engineer. It would be interesting to be in the room amidst a discussion between one of these traditionalists and a “new age” Figma-type UI designer.

> I’ve never really understood the need to build a full fidelity reproduction of the layout systems a design is targeting.

Well, you wrote why right before:

> As a dev that does a lot of his own design

You understand the whole, so you don't need lossy abstractions to connect the ends. When roles are specialized and people only understand part of the context in which they're working, they need ways to communicate about the whole thing.

Tools like Figma fill those sort of gaps, that tend to occur in organizations with dozens/hundreds of employees, with the need to quickly onboard frequent new hires, etc.

Yep.

Back in the 1990s there was a huge influx of people into web design who knew how to design for print at a "retail" level (design an ad or a poster) as opposed to a "wholesale" level (create a design system for a magazine) and as a dev I would frequently receive a PSD from a designer and figure out how to abuse the primitive HTML was had then to make something that looked like that.

Today Figma has replaced PSD but the same pathologies remain. A new version of iOS comes out and the armchair quarterbacks want to go over the appearance pixel by pixel but they're not really interested in UX design in the sense of designing a sequence of interactions to attain a goal.

As a dev, what I want from designers is design systems, guidance on what everything is supposed to look like that I can implement whatever I need to implement and have it look like a designer was involved. I blame the tools though less than I blame the designers who are just not inclined to think systematically. CSS was definitely designed to create design systems (css classes used in a disciplined way reflective of semantics) but tools like bootstrap, tailwind, Emotion, and the MUI theming system all represent regressions away from that ideal but I don't think those tools make bad designers, it's the other way around.

This! It is bad enough that most designers think they are UX experts too (few of them are), but trying to micromanage devs so that every screen would be "pixel perfect" really takes the cake. Especially when the provided designs (that should be followed religiously) are missing core functionality and the whole flows. Just give me the guidelines please, and please please be consistent with them!

Well, I'm sure they have their own set of gripes about the developers too. ;-)

> If you need a free form design tool to sketch, use one. There are hundreds of them.

Before Figma, the norm of design tool was Photoshop, not the other "hundreds of them."

So go back in time, if you had been Figma founder developing a tool that appeals to most designers, it should've looked more like Photoshop than like CSS/HTML.

Fireworks also existed the whole time which had a lot of Figma's features but bizarrely was completely ignored by 95% of designers.

I used Fireworks a lot, and what amazed me at Sketch when I found it, is that they figured out every single thing that bothered me in Fireworks and did it right. At that period, Figma was mostly copying all the tiny clever innovations done by Sketch.

There is the sketch app , which is older and more of a direct competitor to Figma. Figma won because of being web based/ multi platform among other advantages.

Exactly this. Thank you.

We need a Blender-like design tool specifically for product design. Using HTML/CSS for rendering so it covers most web needs and that usually more than encompasses native app-layout emulation. Open source, technical, and not expected to be picked up in a day or fully understood top-to-bottom by everyone.

The reason Figma is putting us into a design box is because it doesn't have all the CSS features that actually let you create incredible experiences.

as much as folks hate electron, I think if Figma was electron, it would at least have the entire chromium web engine to work with

Figma on desktop is an Electron app I believe. Figma chose to build a custom webGL rendering engine for their design canvas, so the core issue is that technical decision early on (probably allowed for some better performance and multiplayer back then). Figma is stuck with wanting to control their rendering and allow for non-product stuff like Figjam or the new Draw tools, but it will inherently hold them back from providing a really good design/dev handoff and always will hold designers back because it doesn't use CSS web rendering.

I’m actively working on an alternative right now. It’s a tool for designing in the browser, using HTML and CSS. Everything is parametric by design, including tokens.

Eventually I’ll have a working end-to-end prototype together, but not yet unfortunately.

Yeah we need that... and more HTML it is, the better.

That would be awesome, Looking forward to it.

Thanks, I can’t wait to showcase it on here. It’s frustrating because I can only work on it on nights and weekends, and my 15 month old daughter doesn’t make that any easier.

I’m incredibly pumped for it, though. It’s almost entirely keyboard driven, kinda like Vim. I’m building this rich set of mnemonic commands to build/design UI components. It’s like Vim + Storybook + WebFlow.

I haven't used it myself yet, from what I've heard, Penpot is closer to filling that gap? https://penpot.app

And it's free and open source.

"the problem is that it’s too designer-y for engineers"

Exactly! Numerous times I have wanted to start a new personal project however got stuck in figma designing process. Had no other chance except writing in pure html/css - the only things that still "work" for me unlike those stupid frameworks.

I think the authors point, is that, designers are incorrectly choosing the wrong tool.

In my experience in FAANG, designers use Figma for everything. Like literally everything.

So when you say, they should use a sketch tool when they need free form, they don’t

So one of my teams was struggling with Figma to work with users. Then someone had the bright idea to just prompt an LLM to generate code for the mock UI and made it happen in 2 days. Far better user experience.

I'm late to reply, but check out Plasmic. We often get the complaint that we're too engineer-y instead of designer-y, so it might work for you.

> If there’s something better than Figma out there, please, let me know.

HTML+CSS works very nice for these mock-ups. Tried Figma and Sketch for a small project, never again.

I have totally opposite experience working on large ds at uber

Would you elaborate?

Yeah...

Just do pictures on the design phase and then code.

There’s a lot that goes into creating the pictures. Consistent spacing, colors that change depending on platform, breakpoints, containers, and on and on and on.

There’s no reason that a tool can’t model a design system and make producing consistent designs that use it trivial.

I think the problem with Figma is that it tries to appeal to visual designers, UX designers, and programmers. Good for business, bad for users.

Don't create every possible picture. Create a representative set.

Draw each screen at least once. If you have dark mode, you don't have to fully redraw each screen in dark mode, just enough to show how dark mode should look. If it has to work on desktop, you probably do have a completely different desktop version of each screen (from the default mobile) so draw that - but don't redraw every detail of a widget that's identical to mobile.

Testing every combination should be for the testing stage. It's good if you can foresee clashes (like the desktop version of this widget looks bad on this page in dark mode) in the design stage but it's not really an excuse to prolong the design so long that it lasts until you would have been finished with testing anyway.

Having a computer generate all the combinations for you in the design stage isn't that great unless you can pay individual attention to them - there's no point producing artefacts that nobody looks at.

I don't think you got the point. Instead of "pictures" we need a design system - defined sizes, paddings, margins, grids, font-sizes, colors, breakpoints, variants, components, behaviors, transitions, etc. and it should be consistent across the app. How many times have I worked with a design that didn't respect these consistently from page to page...

Instead of pictures or a design system, what you need is a way for users to do stuff with your app. Pictures help with this more than a design system does. More important than every margin being the same across the app, is being able to do stuff with the app. The consistent margins can come later, once the app does useful stuff.

Are you saying thread product is laggy or your development process? If it's the latter, you sure youdont just need to update your computer?

No. It's just not implemented in a way that would let it support a large design system, even on a 16-core machine with 128GB of RAM.