Comment by rackforms | Hacker News Reader

Comment by rackforms | Hacker News Reader

Id like to propose an alternative to the alternative posed in the article:

Years ago I was tasked with building dozens of basic web forms. Immediately recognizing the inherit silliness of this task (boring, error prone etc), I built a form creation tool, which all these years later lives on as RackForms.

Over the years the feature set grew organically to accommodate an ever growing set of demands. Yes we still build forms, but we also call into web services, display data, and so on.

Point being, RackForms and any number of other form builders are the blindingly obvious choice for this task -- it would be down right silly to code forms by hand in this era.

And yet that's what we do with the web as a whole.

Once again Microsoft seems to have had the right idea in the good old Web Forms days. Instead of coding app's you'd simply drag and drop components and add wiring code to do what you needed.

Sure it was never that easy, but it's really hard to see how it couldn't have been better given more time.

Fast forward to today and as much as I adore say, VS Code, it's really nothing more than a hyper-powerful text editor. It has none of that tolling to allow for drag and drop development, Id propose that;s the real solution to this issue - Better Tooling.

That's great if you're building an internal tool, and in fact we use the Django Admin site for this, there exist low-code/no-code tools like Retool for things like this, it's a great type of solution.

Where this breaks down is anything customer facing, like Hey (the product Hotwire was built for), Basecamp, or things like Thread the product I work on. These products aren't forms, or CMSs, and trying to fit them into those sorts of solutions results in a bad or counter-intuitive user experience, even if somewhere deep down these are essentially "CRUD" applications.

I understand your point here, but I think we're a couple of innovations away from dramatically reducing the cost of UI development.

The state of the art for web and mobile app development is a delicate stack of tools that require a lot of expertise to wield. However, if you pay attention, most the complexity of modern UI development is accidental, not fundamental.

Figma already has "auto-layout", which is essentially flexbox. Imagine a world where your designer just builds your whole app with in Figma with flexbox-like constraints, then they hand off to your developer who just writes a couple of snippets code to wire it up to a database and makes sure the elements are configured to be SEO friendly.

IMO developers dramatically underestimate the power of GUI tools to usurp their role because we think in terms of such low level tools.

Oh yeah that is absolutely a direction I can see this going. But that's enabling completely custom UI/UX and behaviours per screen. It's the form-builder style generic tools that I think have limited uses in consumer software.

+1, It's very rare I run into people on the internet that seem to understand this. We're all obsessed with getting our delicate stacks of tools to work together that we fail to realize we're building at entirely the wrong abstraction level.

The solution to slow SPAs is higher level frameworks and tools that compile away the slow runtime. Svelte is a step in the right direction. We have many more to go.

Honestly, I believe the role SPA front-end developer is overvalued at the moment, not because the job is easy, but because the tools are so poor. Once we see platforms that properly balance ease of use with expressiveness and composability, I believe there will be huge opportunity for development agencies to undercut the market.

I've never seen anyone actually say MS got it RIGHT with webforms.

Webforms was their attempt to bring the VB6 workflow onto the web and it was a terrible idea specifically because the web is not desktop.

I get your point, but as far as I'm concerned any rationale that ends with the conclusion that MS got it right with webforms needs to be seriously reconsidered.

I'm gonna say it, then: it was pretty good tech. It worked similar to Turbolinks/Hotwire, you could make reusable components like React, it had much better benchmarks than interpreted languages at the time, and it worked very well with or without Javascript active on the browser. The WYSIWYG was nice but it would be alright without it.

What killed it was lack of community best practices. It NEEDED Custom Components and separation of concerns (using something like MVVM) for it to work well. But without a community around it (and with Microsoft's lack of interest), most people ended up writing spaghetti code.

MVC on the other hand had a large community around it developing best practices. MVC code could also be a clusterfuck if you wanted to: you could put all your logic in the view for example. The reason it didn't happen was because there was widespread education around the MVC paradigm. WebForms didn't have this.

Also it didn't integrate too well with jQuery, which was the new hotness. Today most people are smart enough not to use jQuery to mutate a DOM tree generated by a React component, but back then jQuery was the new kid on the block and people blamed the problems on WebForm, rather on the fact they were mixing two incompatible paradigms.

You're confusing webforms with the asp.net framework.

The framework itself was mostly good tech, as long as you didn't use webforms.

Probably the biggest flaw in the framework was not having a way to capture all unhandled exceptions (Application_Error does not catch unhandled asmx exceptions).

... and WebForms.

No, I'm not confusing anything. What I'm talking about is exactly WebForms. Please don't distort my words.

WebForms was good, as long as you didn't try to use it in way it wasn't intended, like doing direct DOM manipulation on top of the UpdatePanel, trying to access private state, refusing to use components or not using separation of concerns. Those are the same things that would also make React apps shitty, but the reason React works is because in React we just don't do it.

WebForms was good, but it needed the same amount of good engineering that a modern React app needs to be good, period. Unfortunately lots of programmers using it back in the day didn't have this knowledge because of lack of good documentation and good practices.

You said the following:

> it had much better benchmarks than interpreted languages at the time

That seems an odd statement for someone not confusing WebForms with the tech stack.

You can build applications in asp.net framework without the use of WebForms (and you could do so before MVC existed). THAT tech stack was pretty reasonable. It was WebForms specifically that was the problem.

But it did have better benchmarks. Whether it was the merit of the language, interpreter, rest of the stack or anything else is immaterial. I'm just demonstrating that it didn't have performance problems. The reason I preemptively mentioned performance not being an issue is because you are not putting forth any arguments for why you dislike it.

While we're here, cherry-picking one sentence of a post and putting it out of context to try to invalidate all my other opinions is not arguing in good faith. You seem to be trying to prove that I'm "ignorant" or something, but you're the only one displaying any ignorance here, since you're not putting forth any argument, but rather just parroting that something is crap and trying to "win an argument" using fallacies. There is nothing to be learned from your posts at all, no different perspective, no justification of your opinion, no insights into why you dislike it. You're just doubling down on a preconception that you have no justification for.

I made myself clear in my initial response:

> Webforms was their attempt to bring the VB6 workflow onto the web and it was a terrible idea specifically because the web is not desktop.

As for performance, viewstate was a huge performance issue. That's a large part about what I meant when I said they tried to bring the VB6 workflow onto the web. In order to get there, they had to create the viewstate mechanisms, which created a different set of problems.

They wanted developers to be able to dragNdrop and then double click and write a small bit of code to do a thing, just like in VB6. Only, in order to actually get that to work, they had to come up with things that were actively harmful in a website (and it got worse when they tried to shoehorn ajax into it).

> There is nothing to be learned from your posts at all, no different perspective, no justification of your opinion, no insights into why you dislike it. You're just doubling down on a preconception that you have no justification for.

this is just an HN dog whistle. You could have asked.

Reply on news.ycombinator.com