> What's really frustrating about all this is how passive and helpless the current generation of web developers seem to be in all this. It's as if they've all been lulled into complacency by convenience. They seem afraid to carve out their own ambitious paths, and lack serious gusto for engineering. If there isn't a "friendly" bot spewing encouraging messages with plenty of emoji at every turn, they won't engage.
> As someone who took a classical engineering education, which included not just a broad scientific and mathematical basis, but crucially also the necessary engineering ethos, this is just alien to me. Call me cynical all you want, but it matches my experience. Coming after the generation that birthed Git and BitTorrent, and which killed IE with Firefox and Konqueror/WebKit, it just seems ridiculous.
> Fuck, most zoomers don't even know how to dance. I don't mean that they are bad at dancing, I mean they literally won't try, and just stand around awkwardly.
> Just know: nobody else is going to do it for you. So what are you waiting for?
It seems like ranting about how the older generations were better, and conversely the younger generation is decadent, is as old as history itself. Anybody know why this is the case? Is it that our overall character has really been heading downhill for all of history? Or is it something else, like how we generally remember the best of the past but mostly notice the worst or merely average in the present?
I didn't read the article, but just based on the passages you have quoted and based on my recent experience, I will have to agree with the author.
I recently learned that GitHub has a discussions page which is separate from the issues pages. To pass the time and to give back to the community I try to help people and answer their questions.
It's a bit concerning to me that when I point some people to the right direction by making suggestions, linking to the docs, or linking to a relevant stackoverflow answer, they are unable to formulate an answer for their problem. Sometimes I literally have to create a reproduction repository so that they can see how the answer I gave can solve their problem.
I am not concluding anything here. But this has been my experience so far when engaging the community of an open source frontend framework.
> I recently learned that GitHub has a discussions page which is separate from the issues pages.
The people who are good won't be using that.
When I was a student working on my thesis I realised I was too advanced to ask questions on stackoverflow and I would not be receiving useful help there. My issues were too uncommon and specific, because the simple ones that stackoverflow is good at solving were not blocking me.
I guess something similar happens there, with the extra thing that very few people know and use discussion pages.
This isn't a new phenomenon. This strategy is proven to work largely because of people like you who put in time and effort to answer those types of questions with quality information. Stack Overflow was literally built on this very premise.
On the one hand I hate help vampires who appear to show no effort and just want "gimme da codez!"
On the other hand, it's impossible to remember what it was like to not know something. So often, just giving hints isn't enough. When I used to spend too much time answering S.O. questions I tried to, as often as possible, include a working snippet. One, to prove the solution worked, but two, so the questioner could start with working code.
Starting with working code is the number 1 thing for me because then I can start adding to it until it breaks and can always go back to working.
Maybe, but in some (many) cases you’d be better off spending the time developing your general knowledge of whatever it is you are working on to the point of solving your problem. This will not only solve your problem but also make you a better engineer. This is especially true with complex/dense material (e.g. kubernetes) where a lot of the learning is generally applicable.
Mostly likely it's neither, and the problems we notice is due to a very biased sample.
We don't see the many thousands who solve problems quietly, and even when we see them we tend to make note only of the most unskilled ones.
Compounding this with the fact that all over the world more people are motivated to learn and work in IT we are simply bound to see more extreme outliers.
If I had a candidate that did things like that for fun I'd hire them before getting their name.
Dev work has gotten too abstract and covered in bullshit.
Not that 6502 assembler is useful in 2022, but computers were a focused study that would result in productive capacity. For whatever reason that's been diffused and our attention is spent less fruitfully.
It's an hourglass where the width is accessibility and the height is abstraction. In the center is the sweet spot. Basic was near there. Pascal probably was. Ruby, PHP and Python are capable of being there...
As an example outside of computers, think about highly abstract art, highly abstract philosophy or poetry.
It comes across as obdurate and diffusive, aloof and needlessly distanced from materiality.
Now in programming you see the same thing. Abstract language that seems to exist in pure vapor. Factory, interface, provider, service, oh and a provider service and a service provider which are not the same things of course.
All these things mean very specific things that change depending on whose lips are moving - they're defined in code somewhere - they do something deterministic - there is a real materialist function here that's being obscured by confusing language. We've entered the age of Jurgen Habermas style programming.
It's fine if you want that, but don't pretend it's successfully easier to understand when poorly, vaguely, and also precisely defined.
The computer is a picky, unrelenting, uncompromising bratty jerk. Because of this programming concepts are best when they're nailed the fuck down and not dancing around in some abstract freeform jazz space pretending that it's more accessible that way.
All it does is create confusion and the emotion of confidence replacing the reality of competence. The computer is still going to be a bastard and we'll have to deal with it eventually.
Was about to upvote then you said 6502 asm isn't useful in 2022... If anything, learning 6502 asm is instructive because it isn't very abstract but forces you to turn abstract thinking to explicit instructions.
6502 is so bare bones, that programming it even over things like x86 is instructive, it really forces you (or it does for me) to think hard about doing things, even mundanely "easy" things that people who only program C say are fast and low level.
But anyway, it's not "useful" for actual everyday work, it's more of a nice challenge that keeps your mind sharp.
And for my c64, ah I need time to solder stuff so it can connect to another machine, much less the internet ;) one of these days...
Because it's often true, although it's more cyclical than downhill. You have an open emerging technology and people start out self-reliant and have to learn from the ground up out of necessity, and over time things become so tower of babel like that new people can't or don't need to understand it anymore. Then it gets so bad that someone tears it down and you're back to the starting point
"Hard times create strong [developers]. Strong [developers] create good times. Good times create weak [developers]. And, weak [developers] create hard times."...?
It’s because older generations inevitably devalue an evolving culture they can no longer comprehend as a defense mechanism to avoid admitting they can’t keep up. Anyone who seriously makes this argument that the Kids These Days are lazy/bad/worse than their own generation is either delusional or just lazy.
(As an elder cusper due to being terminally online for 15 years) 2020s pop culture so far is miles better than what we had in the early 2010s and IMO the 20 year olds are far more tolerable than they were when I was 20.
All the complaints about them are still valid IMO but even then I see it as less of a problem than the pathologies of previous generations.
Including the complaint from the OP about how zoomers are passive? If it's true (which I'm not convinced of), it seems like a fatal flaw, unless you're saying that inaction is preferable to some of the pathologies of previous generations (presumably including mine; I was born in 1980).
Ah, makes sense. But then, the OP also said zoomers don't know how to dance. But, as an admittedly curmudgeonly early forty-something, I wonder if that's at least partly because so much of current pop music is garbage. Then again, I guess most of any generation's pop music has always been crap; we only remember the classics from the past.
Back to technology, though, I worry about what computing will be like for Generation Alpha (born after 2010 according to Wikipedia), including my nieces and nephew. Perhaps I didn't help matters by buying them Amazon Fire tablets when they were little, though my siblings and in-laws certainly appreciated it. I feel like intervening to get them started on some kind of more open computing platform, but I fear I might sabotage the development of a new, better computing culture if I try too hard to replicate what things were like for me growing up with an Apple II and early PCs. Edit: And no, I don't feel qualified to become a father myself so I can avoid meddling with others' kids. So I guess I'll just stay on the sidelines, watch, and try to keep my opinions to myself.
It is as old as history itself. What you're witnessing is a result of what I call the problem of knowledge.
Realize that, everything that is learned, any knowledge gained, and new technology invented, will eventually be lost and forgotten - as the people who gained said knowledge or invented said technology will eventually die, and the next generation is born ignorant. Yes, we as a species try to pass our knowledge to the next generation, via teaching, books, or what have you, but it's a never ending problem that can't ever be resolved.
Think about it, If I were to invent - say a new programming language tomorrow, the entire world would be ignorant of its existence, let alone know how it even works. Now I could go on to teach others that my new programming language exists and how it works, but this takes time, and people don't have infinite time to learn things. So as time goes on, and we learn and invent more and more things as a species, the next generation has a greater amount to learn than previous generations. Eventually there comes a point where there's too much knowledge to learn, that even if you spent your entire lifetime trying to learn what your ancestors had recorded, you would die before having learned everything. So knowledge inevitably does get lost between generations, and thus, history tends to repeat itself, and the next generation seems decadent for not knowing what you came to know.
Computer technology is just a perfect microcosm demonstrating this problem, as new things get created all the damn time (often to be just reinventions of old things). Heck, even most old programmers I know say they struggle to keep up to date on things.
And it is as old as history itself, as this is what Ecclesiastes 1:9-11 is essentially talking about. Heck, look at most ancient civilizations, and how little we can comprehend what we still have of their writings.
When reading through the comments here, I really feel like the article was misunderstood. My summary of the article is:
Point 1: React solved all the right things, but its current trajectory, does not prioritize developing the fundamental tooling we need. React does not allow us to build a new Figma (consistent undo/redo in collaborative settings, immediate low-latency mutation of app state to reflect user changes and building fundamentals to SaaS interoperability)
Point 2: People are overwhelmed by the work, and too timid to target the fundamental architecture we need to solve these things. We're just going with the flow.
He is leading https://usegpu.live/ to build the fundamentals right, an encourage people to either:
- help out there, if it fits your use case, or
- start working on targeting these fundamentals, where most needed for your own use cases, don't just go with the flow.
On building the next Figma, my first reaction was that Figma should probably have been a compiled GUI application in a ideal world.
Figma is a work tool where a designers are supposed to spend a decent amount of time, and when working on a specific project there is little navigation or moving to other pages. It being in the browser is a technical artifact to help the business model, but inherently there would be nothing lost if it was a local application synching data and changes with a central server.
If time had to be spent making react closer to desktop apps, can’t that time be spent instead on making desktop apps as sandboxed, OS compatible, easy to download and execute as web pages ?
This is something Apple doesn’t care much about, but react core devs also don’t care about desktop likeness, so it seems a to me to be a suitable alternative solution.
The big take away from software eating the world and everything is in the cloud now, is that making things that can scale down and up wins over specialists' specialized custom hyper optimized tools.
was Word 3.1 better than TeX or Quark Xpress or whatever? No, but it allowed people to do stuff quickly. To get things done. It was bad at scaling up, though.
Then online/cloud tools enlarged the pool even more. And finally it was possible to compete with the curse of the default, the shit forced on the world by OS vendors, corporate office suites.
Figma-like tools are the endpoint that can serve 99% of possible users. Both professionals and clueless casuals (and they don't even need to download and setup anything).
It being in the web means I can work on any computer without having to install anything, embed a Figma in a doc or wiki, and it’s super easy to write plugins (html/css/js).
The thing to me is...you are already dowloading the whole figma's client code base and running it in your browser. If it was a PWA it would even stay there.
Your point on installation is accurate in our current ecosystem, and I wonder how we could change that so "installing" isn't a hurdle. That's clearly not a simple problem to solve, but making the web "native" probably isn't either.
Installing is a backwards step compared to accessing a URL and loading a cached resource. It’s nostalgia. What you want is guaranteed “cache”. i.e. the resources are guaranteed to stick around and not get evicted randomly, but can still be evicted if the application is updated and that resource expires.
I'm looking at mike_hearn's response in the thread, and it's going in a good direction I think (https://hydraulic.software), albeit platform owners would need to do a lot more to help that kind of approach to succeed.
Looking at the current situation from a high level view, we already have URLs for applications (you'll need to declare a unique identifier for your bundle), and Apple and Google are already toying with the idea of immediately executable apps with App Clips and Instant Apps, so it feels like we're actually pretty close from that alternate reality where "installing" can be seamless to the user.
(+ iOS also handles removing unused apps from the device, so that part should also be ok)
"can’t that time be spent instead on making desktop apps as sandboxed, OS compatible, easy to download and execute as web pages"
It can! This is (sort of) the vision of my current company [1]. Its founding belief is that web tech is reaching end of life and it's time for our industry to start looking at what comes next. The long term goal is to create a new competitor to the web, but not all at once. Instead we're doing it via incremental iteration on current desktop development. Starting with better distribution tools we want to work up to sandboxed, streamed, cached, crawl-able, embeddable app/document hybrids just like the web has but with very different architectures that benefit from what we've learned from 30 years of the web.
The starting point is to make it as easy for people writing desktop software to distribute their work cross-platform as it is for people making static websites. The resulting UX is that of a normal desktop app as far as the user is concerned but from the developers perspective they just grab the tool we've made and run "conveyor make site". Out pops a set of files you can upload to any static HTTP server, which are fully signed, notarized and self updating for every desktop OS. It can do this because all the packaging and signing code is implemented by the tool itself, so there are no native dependencies and it can thus be very convenient to use.
For people who like the React model an interesting way to use this is to write an app using Jetpack Compose [2] for Desktop [3]. You get a fully functional/reactive UI toolkit but without needing a mishmash of HTML/CSS/JS - it's all just Kotlin. Your Android code can be shared directly with the desktop version (with layouts for larger screens of course), and you can then go ahead and start integrating with native OS capabilities as you see fit by directly invoking their APIs. For "mobile first" companies that develop a web version primarily for desktop users, this can eliminate the need to build a web app entirely (or you can use a minimal one for search engines). Next week we'll be releasing an update that improves support for Compose Desktop apps, in fact.
There's more work to do on making distribution trivial for everyone, and of course you can use Conveyor with Electron apps if you want to - the goal here is to be layered so the lower levels are usable by everyone including web developers, and the platform gets incrementally more opinionated as you go up the layers. Once the core product has matured further we'll be exploring an experimental architecture in which RDBMS' fully replace the web server, and what advantages you get from doing so.
> React does not allow us to build a new Figma (consistent undo/redo in collaborative settings, immediate low-latency mutation of app state to reflect user changes and building fundamentals to SaaS interoperability)
If I wanted to write the next Figma, the first thing I’d reach for is Phoenix Liveview + Channels with Vaxine/AntidoteDB or some other eventually consistent CRDT store for collaborative editing and host it on fly.io - I’d forgo the ‘front end’ completely
Not to dismiss your argument/stack preference, but forgoing the front end for a graphic design tool might prove difficult. EDIT: But yes, CRDT-backed stores are definitely the way to go for a requirement like this.
> but forgoing the front end for a graphic design tool might prove difficult
How so?
Offline support? Collaborative tools don't really have a good offline story by nature.
Ping times? If you use fly.io you're going to have great availability and low latency. It's like a CDN for live apps.
I'm not biased against a 'client-side front end', it's just that a collaborative tool that is 'always online' might as well use a 'live app' style where the server drives the DOM. It solves all the problems that the OP raised in the quote, and it's less about where React should go next, because client-side front end literally can't solve those problems due to their nature.
This article is kind of sad. In part because it comes from its author, who usually writes interesting stuff. But this one is ranty -and no, it doesn't make me angry. It's ranty and also fluffy, light in content, scarce in any arguments or conclusions other than "youth these days! they don't even try!". I'm not young and I still find this article poor.
After going through the first two thirds of the article with mostly uninteresting "I'm old; I know better" detours, the author seems to sort of relate React to "reactive", and goes on yet another detour on unrelated architecture. So, we're now reaching the end of the article and the only conclusion we get is... hey, stuff is hard, you need to do the work, you can't avoid putting in effort. And... that's it. That's all there is to the article. Eh.
I agree with this guy.
I can see that his tone unfortunately irks many to take offense and post.
I am sad that microsoft has
so dropped the ball on UI,
that even MS' own teams use web
tech to build apps nowadays.
I particularly lament that scroll bars have become a lost art.
We have gone from scroll bars
working perfectly in windows 3.1,
to .. whatever passes for a scrollbar these days.
Often they are even hidden, so you have no idea how big the document is,or where you are in it. But it sure does look minimal and slick, until you have to actually use the thing.
Many established keyboard shortcuts are going missing,but that is OK, since modern people dont like keyboards.
My favorite is when installing current windows 10, when you select language and country. You get a list that displays .. 4 items at a time, from hundreds of choices.
Unlike earlier versions, you can no longer press a key to jump to a letter. You must page through the whole list.
Sorry if I made more millenials cry.
I thought windows had bad UX until I tried macOS. Maybe my taste is different than others but I found macOS UX to be really confusing. I particularly disliked the iconset. Interestingly this is not true for iOS and iPadOS, those are magnificent.
I'd say macOS actually is a lot more polished than Windows, but I agree with you that it is damn confusing. Try "closing" an app for example and you'll find that half the time it will not have closed properly, or maybe it did, who knows? It depends on the app. If it's vanilla you can bet it will have to be closed with CMD+Q
And I agree it’s different from all the other operating systems, once I understood why it made sense.
For example, I can copy an image to my clipboard, and open Preview. No window opens, but the top menu bar shows that Preview is open. From there I can choose the “new from clipboard” entry. It’s just a different model of interaction.
I think the convention is for apps where you can open multiple instances of it (document editors, web browsers, etc), closing window won't quit the app.
Exactly. In the scenario of closing all open documents and then creating a new one, it prevents the awkwardness of having to keep that last document open to keep the menubar available so you can select File > New and then close the last document. It also means you don’t have to invoke your app launcher again after closing all documents since the app is still open.
Conventions being different than what one is used to (in this case, Win9X) isn’t necessarily bad. Additionally, this particular convention has been on macOS for most of its existence, which means there’s longtime Mac users who find the Win9X way just as awkward.
Agree with it being weird but intuitive != commonly known. Just because windows does it a certain way doesn't mean it is intuitive. It's just widely known and assumed. If GNU developed to be the worldwide market leader then we'd all find the CDE drag and drop applet system 'intuitive'
Did you ever try macOS (OS X) circa 2006–2014? It was really, really good and then they ruined it for the sake of having a (kind of) unified design language with iOS.
Old Mac OS X was great. I hated the mouse and the iMacs were a little too 'cute' for a work tool, but wow they could run the doors off a Math Blaster CD.
As someone who mostly uses iOS and occasionally Android, I’ve had difficulty integrating the Android back button into my usage. Because its behavior within apps is defined by devs, I feel like I never have a grip on what to expect when using it (sometimes it’ll close a sheet, sometimes it won’t, etc) and adding inter-app navigation muddles that further. Every time I try I end up enabling the iOS style gesture bar at the bottom.
Convention is to keep it in the top left. All the stock apps will use more or less the same navigation dock up top for back and other functions. Often apps will be rejected for not providing this kind of functionality predictability. This was the hardest thing for me to learn moving from Android to ios as well, but the smoothness of ios trumps all the hardship in my opinion.
> But it sure does look minimal and slick, until you have to actually use the thing.
Modern UI """design""" in a nutshell. So-called designers (1) optimise for "looking good on a screenshot / promo screen", rather than for usability and aesthetics for the user, and (2) do so according to their own subjective tastes, instead of evidence-based approaches. These are to me the two major sources of the atrocious design of much of modern software.
Given the way UWP and now WinUI 3.0 teams have managed the product, with many not even having an understanding of the capabilities and VS tooling from the frameworks they are supposed to replace, I am starting to think the internal code name for the team is something like Team Titanic.
Recently scrolling through a list of countries to choose 'United Kingdom' I eventually found it under 'G'. The nearest I can figure, it was previously for 'Great Britain' and was never re-sorted? (Never mind that nobody in the UK has called it Great Britain since maybe mid 20th century!)
People still say Great Britain all the time (it refers to something slightly different than the UK though [1]). It's what the Olympic team is called, for example.
Ahhhhhh I hate this, it happens so many time when you're using a translated software: they proper translate the label, but do not order stuff again. In German, Germany is Deutschland but still comes after France
The ISO 3166 code is GB (the uk. TLD being a grandfathered exception), they might have sorted by that. There would be more cases of “wrong” order in the list, though most of them would be more subtle than that.
- you first need to lay out the scrollable content normally, without a scrollbar
- then you need to detect whether it spills over, and whether a scrollbar is needed
- if so, you need to lay out all the content again, in a slightly smaller area
- if the content ever shrinks, you need to detect this too
- and if the content only _just_ fits, then it is possible that without a scrollbar, it doesn't need a scrollbar, but if there is a scrollbar, it needs to be scrollable. Chicken and egg.
This is actually pretty nasty to get right. Now factor in layout models like flex box, which also require part of the content to have a "pre layout" pass done in order to estimate "natural size", and it can get quite gnarly. And if you want to mix vertical and horizontal layouts... oof.
I got an equivalent of HTML/CSS box+flex working in Use.GPU but it took plenty of iteration.
I think the lesson here is that UI is always more complicated than you think. There are countless little tricks and mechanisms that you would only ever notice it if they didn't work. When they do, it is so "obviously" right you literally can't tell.
(As an aside, whoda thunk that a generation raised on participation trophies would be easily triggered???)
Yes, scrollbars are not completely trivial, but what you describe used to be a solved problem on desktop UIs, and the reason for making scrollbars invisible were purely aesthetic.
This article is weird linking together many unrelated strands of thought.
Like linking reactive programming to “reactive” UIs, when really they mean UIs that are forgiving to their users instead of breaking down.
Or how by coding on the web we’ve lost the immediacy of a UI that runs on our desktop, and the primitives (like undo/redo stacks) that make desktop user interfaces friendlier, at least without having to build them ourselves.
And that new UI frameworks show up claiming to solve the problems that React creates with complexity, by forgoing the functionality that React provides that they pretend is unimportant by hiding behind toy examples.
There’s actually not much in this article that doesn’t resonate with a jaded millenial like myself who knows their computer history, but could have been expressed more cohesively.
As someone who has admittedly worked on approximately 0 user-facing programs, it seems like there are not many revolutionary ideas when it comes UI.
I have some dream of a sort of user-interface system that exposes controls and data more directly to the user, independent of the author's stylistic choices. Sort of like semantic HTML with style-sheets that are configured on a per-user basis. It would be analogous to the unix shell in the sense that it would allow small programs to easily inter-operate, like plan9's pumbing or something. Instead of having a big monolithic program like kdenlive or blender, you would have a number of modifiable general-use programs that can be re-arranged to fit many use-cases in an extensible way.
But instead of that it just seems like every toolkit or library wants to be highly specialized and complex, and provide for a very specific use-case rather than making the most general-possible user interface that is universal. Programmers should not be concerned with the appearance of their UIs like window decorations or the layout of buttons or text fields, for the same reason they should not be concerned with the minutia of optimizing assembly-code. It leads to a non-portable design. That should be left up to the system.
It's a nice idea, but if it were easy it would have been done by now. I think a lot of the problem is that UI tends to be very specific, and often giving one component what it needs to work well imposes requirements on other components.
In order for a UI to work well and be comprehensible, there has to be a sensible hierarchy over the entire layout. If you don't achieve that, the whole might be less than the sum of its parts.
But I think React is actually probably the closest thing to what you are describing. It does a pretty good job of encapsulating UI components into fairly small chunks which can be styled externally to fit into a larger layout.
I also agree it would make sense to break things like Blender into smaller applications. But actually I think that would have more to do with having a standardized interoperable model layer, with a clear interface, so different applications could modify the same data with a different UI layer.
> I have some dream of a sort of user-interface system that exposes controls and data more directly to the user, independent of the author's stylistic choices.
It will never happen.
Companies want to "brand" their UI to use it as a marketing tool. Usability and integration be damned.
Tk, and especially Themed Tk (Ttk) mostly fit this. It even has 3 geometry managers.
I've ported some code from Tk to run on the web (including working correctly in Lynx, as much as possible) [0], and the problem is still impedance mismatch. It's worse when running it on a phone, because you want a fundamentally different UI than you can easily describe. For example, Toplevels (aka windows) don't make any sense on Android or on the Web, but work well on the desktop.
> But instead of that it just seems like every toolkit or library wants to be highly specialized and complex, and provide for a very specific use-case rather than making the most general-possible user interface that is universal.
Blender, and 3d modeling in general, is a very specific use case which probably couldn’t just have some UI code thrown up over a library and be expected to work. Not like displaying some text and an image or two to rant about “those damn kids”, there’s real math behind being able to transform mouse movements into 3d space. Expecting to display a 3d environment in whatever front end UI code you want so it can have a pretty wrapper is very unrealistic.
I’m having a hard time even imagining how this would be possible without a large team working behind the scenes to do all the heavy lifting to make this even remotely possible. Wasted time IMHO as having a specialized tools for specialized domains is just how these things work.
I understand Haiku (née BeOS) has UI concept at the OS level, which should probably simplify many things.
For UI, you also need to extend programming languages to add so "nested structure with logic" as first class (which is the real value of jsx, and could, I suppose, be trivially done in lisp ?)
I would love to have a Rust + Nested trees syntax + native UI lib that look decent on all system.
But it's never going to happen for now obvious reason, so, never mind.
desktop environments (from Windows to iOS, including OSX, macOS, KDE, Gnome and everything in between) sort of already do this. they provide services and they provide apps/programs that require those services.
what they don't provide is interchangeability of programs from different environments. probably the closest thing is the freedesktop.org semi-standards, but there's not much compatibiltiy or interoperability between KDE and Gnome stack. (KDE's Plasma needs all the usual K-things and Gnome's thing needs, well, I don't know what it needs, but it does almost nothing but needs a bunch of things to do that :D Xfce sort of piggybacks on Gnome, but also uses a lot of their own shit, but at least Xfce is great.)
To me this idea sounds a little bit like how Java Swing works. At least it seems similar to the pluggable LookAndFeel?
I think it was a great idea but it seems like it never got any traction. Or maybe more like Java never got popular on desktop.
I've thought the same thing. A tech that lets you consume data from web sites but visualize it in any way you want. Despite the naysayers in other replies I think it is possible
in the early days of web2, everyone high on RSS feeds and dreaming about pubsubhubbub ... when a google maps embed was just a few seconds and half a line of code, when OAuth1a and JSONP were all the rage, well, back then 3rd party was not a swearword and it did not automatically meant ad-fucking-track-tech.
back then it was seen as the great, bold, and messy cross-linking organically-grown future.
it was called "semantic web", every day people were announcing how simple it is to encode more and more machine-readable stuff less-and-less intrusively into your HTML or xml+atom.
then facebook became the web, twitter became the truth and one day the dream got mugged, beaten up and left to bleed out in a back alley on July 1 in 2013.
everyone got mad and posted about it on their phone using an app from a nice boring, proactively curated walled garden.
>OpenDoc is a defunct multi-platform software componentry framework standard created by Apple in the 1990s for compound documents, intended as an alternative to Microsoft's proprietary Object Linking and Embedding (OLE).[1] It is one of Apple's earliest experiments with open standards and collaborative development methods with other companies. OpenDoc development was transferred to the non-profit Component Integration Laboratories, Inc. (CI Labs), owned by a growing team of major corporate backers and effectively starting an industry consortium. In 1992, the historic AIM alliance launched between Apple, IBM, and Motorola—with OpenDoc as a foundation. With the return of Steve Jobs to Apple, OpenDoc was discontinued in March 1997.
[...]
>After three years of development on OpenDoc itself, the first OpenDoc-based product release was Apple's CyberDog web browser in May 1996. The second was on August 1, 1996, of IBM's two packages of OpenDoc components for OS/2, available on the Club OpenDoc website for a 30 day free trial: the Person Pak is "components aimed at organizing names, addresses, and other personal information", for use with personal information management (PIM) applications, at $229; and the Table Pak "to store rows and columns in a database file" at $269. IBM then anticipated the release of 50 more components by the end of 1996.[7]
>Steve Jobs handling a tough question at the 1997 Worldwide Developer Conference. He had just returned to Apple as an advisor and was guiding sweeping change at the company. The full video is here - [original video taken down by Apple - new link: https://www.youtube.com/watch?v=GnO7D5UaDig ] - this interactions is at 50:25.
I highly recommend taking the time to watch the entire WWDC 1997 video -- it is historically profound.
Steve Jobs walked on stage and announced he wanted to take questions from the audience, right after his return to Apple from NeXT and the sweeping changes he made.
Some of the best most difficult questions really made him stop and think before speaking, and he delivered frank fascinating answers.
We all know what happened next, but it's amazing to hear how deeply and confidently he thought about it before it happened.
>Apple's Worldwide Developers Conference (WWDC) in the San Jose Convention Center (May 13-16) was the first show after the purchase of NeXT, and focused on the efforts to use OpenStep as the foundation of the next Mac OS. The plan at that time was to introduce a new system then known as Rhapsody, which would consist of a version of OpenStep modified with a more Mac-like look and feel, the Yellow Box, along with a Blue Box that allowed existing Mac applications to run under OS emulation.
>The show focused primarily on the work in progress, including a short history of the development efforts since the two development teams had been merged on February 4. Several new additions to the system were also demonstrated, including tabbed and outline views, and a new object-based graphics layer (NSBezier). Source: wikipedia.org
Check out the stylish 8 bit error diffusion dithered gradients and cheesy 90's drum loop in this delightfully retro but content-free "Apple OpenDoc Technology Intro" -- the take-away point is that Apple and IBM and Oracle were really pushing OpenDoc and making a lot of promises about supporting it for a while:
>Video clip from the original Apple OpenDoc: A Crucial breakthrough! CD
This one has a much funkier intro, and has more substantial down-to-earth information about OpenDoc. He's got HyperCard and AppleScript in their original boxes on the shelf behind him, so he knows what he's talking about:
>OpenDoc: A New Standard for Compound Documents, a lecture by Kurt Piersol. The video was recorded in March 1994.
>From University Video Communications' catalog:
>"OpenDoc represents a new standard method of building editors which support assembly and editing of compound documents on many computing platforms. Kurt Piersol discusses the need for compound document systems, their requirements, and OpenDoc's industrial and technical approach."
The article started really strong and I believe the point about React and knock-off frameworks not evolving to really solve challenges modern web applications face is good and worth exploring.
Then it took an awkward and very long detour into gushing over Apple design.
And it "circled back" to a rant that seemed to trivialize things like collaborative editing and undo/redo like they were generically solved problems in the past. No, collaborative editing was not a solved problem 20 years ago. It's an evolving space with recent advancements in the CRDT space from Yjs and Automerge really opening things up.
Started really good but I was hoping it would have ended up with an analysis of the gap between where React (and browsers in general) are currently and where it ought to be; with some ideas around how to cross the gap.
> This article is weird linking together many unrelated strands of thought.
You know, this isn't the first time I've thought as much about Acko's writing :\ Often there isn't a coherent thesis, but a bunch of interesting related thoughts that don't add up to anything specific.
I thought this was the most insightful part, though it would be the second most if the author did more than allude to conflict-free replicated data types.
Whenever you build a tiny language for the purpose of templating, it's worth asking yourself if it's really worth it to have to reinvent variables, loops, branches, scoping, expressions, and functions... Poorly.
> Many competing frameworks acted like this wasn't so, and stuck to the old practice of using templates. They missed the obvious lesson here: every templating language inevitably turns into a very poor programming language over time. It will grow to add conditionals, loops, scopes, macros, and other things that are much nicer in actual code. A templating language is mainly an inner platform effect. It targets a weird imagined archetype of someone who isn't allergic to code, but somehow isn't smart enough to work in a genuine programming language. In my experience, this archetype doesn't actually exist. Designers don't want to code at all, while coders want native expressiveness. It's just that simple.
I always thought the point of the template language was more to enforce the boundary of presentation and code. and thus any template language that grows too powerful is a bad template language, because it's no longer doing the one job it has. So I think a template language should have loops, (non mutable) variables and basic conditions, that's it. So if there's something you can't do in your template that you want to do, the solution then isn't to write some sort of hideous thing in a bespoke templating language, but to add another variable/loop/whatever to the template.
Of course this requires coordination and the larger the organization, the more this is going to slow things down. I also don't think this separation is as important on frontend javascript code, since the lines get blurry there anyway.
If a template needs loops or even conditionals, it is already too complex for my taste as it leads to wrong design patterns blurring presentation/code boundary. Something that just allows to access variables and call functions will keep the boundary while allowing a non-programmer or even the end-user to edit it.
disagree, because the alternative is having a million tiny templates, which is annoying and cumbersome. sometimes you just want a condition to check if a user has an avatar, or if there are replies to a post, or whatever else. same with loop, if something is specific to a template, there's no reason for repeating content to not be a loop (I don't think a template system should allow custom loops though, only looping over predefined content).
I prefer having one big template for a view, when doing SSR. Some layout components will have to be their own template if they repeat on different pages, depending on the template engine you can either pull other templates in directly (in which case using loops is also valid here IMO), or have a variable with a HTML blob generated from another template.
I don't really think either of those things count as code, because there's only logic that is relevant to how things are displayed. It's just, if the user has an avatar, show an image tag, otherwise, show a placeholder image/nothing. repeat this HTML once for each comment shown. That's not code in any meaningful way. I mean technically all of it is code, but you know what I mean.
If one wants a view for the whole page, then using a programming language with a good support for embedding strings will be a better solution as it avoids the need to learn one more language.
DSLs have their place. arguably we have too few of them. we always use a general language. which is good, because it's general, sometimes great at a few things, but usually very awkwardly at most of the things.
Alan Kay (and his teammates during the STEPS project at VPRI) spent years and years thinking/experimenting with this, here's the final report from 2016: https://news.ycombinator.com/item?id=11686325
"The big breakthrough is making it easy to create new DSLs for any situation."
a simple template language is composed in its entirety of like 3 separate pieces of syntax, it should be something you can learn in 5 minutes. Like I said in my original post, the point of it is to limit what you can do, so that templates stay templates, and code stays code. If there's a learning curve to your template language, you've already lost.
The template system is somewhat like the type system in that it provides you guarantees. The templates cannot mutate any data or pull anything in that you didn't provide to it. You can be 100% sure that no one did a cute little temporary hack modifying the data inside the template somewhere, pulled in some external data real quick on a friday afternoon or did anything else that doesn't belong in the template. That's the advantage over just using a regular programming language.
Logic-less template is ok despite some having loop because semantically, users also want to list things, add a thing to a list. I wouldn't add `if/else` but switch-case (this simulates category in user space, not complex condition). "Local variable" shouldn't be exposed to users. Collection name is ok. I think Shopify's Liquid is good, they just can't figure out decent UX on top of it.
A logic-less template is easily done, by exposing a few methods to the programmer providing the data. I remember Android XMLs to be logic-less and while it refers to concrete classes, something like this could easily be adapted to generate text. A designer wouldn’t need conditionals or loops because he could mark something as a container, the goes on to design the content (for loop, each cell). Desktop and Mobile had this for ages.
I’d be more than happy if a more powerful version of figma existed (capable of handling UI states). Then the designer would then hand the design files annotated with IDs to me, and then I could go on to implement logic. If we agree on some sort of contract for the UI, he can go play to his heart’s content with the Look and Feel.
I have this idea in mind, how do think about 1 AST <-> 3 different UIs? Content editor, Developer, Designer. Each expose different things but shared AST. Because I think 1 UI with mixed bag contracts is not going to do it.
Yes, JSX (and React) is interesting in this way: it's not a (full) template language. Instead, it's a convenient way to write component fragments that include HTML/XML expressions and further components. Each component top-level is still JavaScript statements.
There's also an escape hatch to include arbitrary JS expressions inside your JSX expressions, although perhaps we should use it only to include variables and not more complex JS expressions.
In the end, templates are not important, components are. JSX provides just what's necessary to make it convenient to define components in JS.
This post ultimately seems to spend a long time complaining about other people not putting in the effort to fix the problems of React... while the author doesn't offer any solutions or even ideas for solutions.
Also, the author makes repeated digs at React 18's concurrent mode work while at the same time complaining about the kind of stuff concurrent mode is supposed to fix (for example, React updates not happening fast enough to keep up with mouse dragging).
That's a pretty inexperienced take, out of context. People should absolutely learn from elders, even if they feel the elders are wrong. Which is pretty much, every young person who has ever existed. There are often nuggets of wisdom buried inside resistance to change.
I often wonder how much further along we'd be as a society if we didn't spend the first couple decades thinking we know everything. Myself included.
"Wisdom" of elders should stand on its own by being well reasoned.
If someone needs to say "listen to your elders" then they aren't able to articulate their argument well enough to stand without it.
(I've been programming much longer than the 32 years claimed by the article author. No one should listen to me because I'm old, except in the case where I'm talking about specific incidents I witnessed that younger people didn't.)
> except in the case where I'm talking about specific incidents I witnessed that younger people didn't
All in interpretation. I implicitly assume 'listen to your elders' is about experience, not age. Perhaps others read that differently.
I don't think anyone is arguing a young PHD should do what an old chimney sweep tells him just because he's older. Unless of course said advice applies to PHD somehow.
No, teaching react is the opposite. When one is invested in the hammer all they see is nails type of analogy at play here. I personally dont do UI stuff and don’t know who is responsible for what I notice as a utter mess in UI, across the board not only on the web.
> the kind of stuff concurrent mode is supposed to fix (for example, React updates not happening fast enough to keep up with mouse dragging).
How does concurrent mode help with mouse dragging? I went reading through the React docs on this and they only really talk about data fetching patterns. I'm not sure I understand how it would apply to mouse events.
Doesn’t it help with having only high priority ui updates on the main ui thread with everything else happening in the background? To get low latency ui updates that’s exactly what you want: move everything except the low latency work to different threads.
The author of this article also wrote the for me mind blowing things like MathBox2 [0], the Pixel Factory [1] and many more. The often mentioned clone of React in the article, described in "The GPU Banana Stand" [2] is something that wasn't heavily discussed here as I think the concepts are just very advanced. I mention this as I believe this is what the author is concerned about and what some might haven't experienced. Using React for "advanced" things were it just doesn't cut it and one has to go back to manual DOM manipulation, or having to dig very deep to understand how one can build UIs were the elements update 60 times per second. React works great for things were this is not a concern, but if the standard has these innate restrictions, what applications will the future hold if all people know is React?
Though not a fan of some rants and the bashing on Zoomers, give them a chance to build the next iteration of the common tools, the oldest Zoomer is 25 at the moment.
Exactly, I was a bit undecided back in the day thinking React and Angular might be similarly valuable, and I don't remember if there was even Vue yet or not (I believe not yet). Angular had just split, and I had to help contracting for a company using Angular 1, and OH BOY the page was horizontal and most of the programming statements happened within those nightmarish ng-if, ng-repeat, ng-{please-kill-me-know}. I believe there were parts up to 350-400 columns wide.
That's exactly when I learned that same realization, and decided never to use (if I can avoid it) a programming environment that defines its own templating language.
I just wanted to wire up shit, make pages, send requests & receive responses ... and not spend days trying to pick the right router, form, state and whatever library for my view layer, and look for TS definitions for them, so I stayed on Angular2+ ^^
> Crucially, none of the React alternatives solve this
FFS. The context is the web, nobody solves graphic problem like gaming for you, or need to. At this point it doesn't matter because HTML/DOM stuff is not going to suffice what you are talking about either.
I honestly think after reading 50% of the article is all about bragging knowing history. I'm not old but I was there too. WIN32, MFC, QT, 8086 assembly whatever. I got a god damn computer engineering degree too but doesn't make me smarter, having better vision, knowing solution better than random ppl on the internet.
I'm not sure what's the point of React here nor "Saving React". Why it needs to be saved in which sense.
I do agree with you, but to play devil's advocate: This article is currently #9 trending on the front page. I've meanwhile seen similar critiques of React written in a different style, and seen them not get a vote or comment. Perhaps those rants do serve a purpose?
>I'm not sure what's the point of React here nor "Saving React". Why it needs to be saved in which sense.
I read it as “svelte et al gain traction due to inferior younglings, therefore react is a sinking ship, let’s not let it sink because the tooling I use is the adequate choice (despite having to be saved)”
Yeah. The first paragraph is that point, but the follow up paragraphs are more of general sense of building UI.
The other frameworks or libs lately move towards non virtual dom and reactivity. Solid, Preact, Svelte, Vue, Lit are superior engineering wise. But React is about the whole economy (unbelievable VCs put 100+ millions on that), so more libs more stuff created, rich ecosystem, poor engineering.
> FFS. The context is the web, nobody solves graphic problem like gaming for you, or need to…
I don’t think you understood the article.
The point he was making is that a good user interface is hard to build and is “app like”, with all the weird edge cases.
…and that, for better or worse:
1) react is the best at doing that.
2) react is (frustratingly) not making itself better at it, and is instead prioritising weird stuff like server side rendering, that is pretty niche in terms of value.
3) react competition is basically just “still the same shit web ui” but easier to build and with nicer tooling.
So, I mean, yeah it’s a rant.
…but hey, I think you’re failing if you walk away from it going “wtf was that?”.
He’s right.
Making “app like” websites is pretty hard; it’s very hard with some frameworks.
Apps are better, in almost every way.
That sucks.
No one except react was really even fighting that battle, and they seem to have lost interest.
That kind of sucks too.
Does react suck? Maybe.
…but, tldr; if you’re gonna take a big dump on react from a grey height, at least do so from a position of thoughtfulness.
“No, I’m happy with building a web ui, I don’t need slick user interactions or an interface design rather than just a form”
Cool. That’s fine. The MVP will be quick to build.
Not everyone needs to be figma.
…but pick the tool for the job; and some of the new frameworks are very finely crafted tools for a very specific job; and that job is building a generic web ui.
It's either DOM or Canvas as foundation we have right now in browser. Not seeing economy around WebGL that much. He talks about GPU multiple times. And these aren't thing related to React at all. React is not "the best at doing that", so I disagree here .. thoughtfulness is that it's repetitive thing to say on HN, people disagree with virtualDOM for a long while, Signal (reactivity) isn't new idea either. More thoughtful thing to say is get "DOM part" and "Template Instantiation" to work so that we have an efficient update mech basis to rely on.
I wanted to build browser app without DOM too, but this is what we have! People will complain about accessibility and all default behaviour goodness that will be thrown away.
I care, we have to start with the right basis which is not React's.
You mean like download qt and make an app that compiles on everything and integrates much better than a webpage while also being much faster and smaller?
If you don't care about what your potential users want, that's fine, but I don't see why you would be partaking in an argument that's mostly about trying to reach more users.
He does not mention gaming once though. The web quickly got to the point where UIs are possible, but lately there's seemingly little or no progress in making app-quality UI possible let alone easy.
In this sense, we might be in a situation where the floodgates are about to open, but who and what is able to make it happen?
> I honestly think after reading 50% of the article is all about bragging knowing history.
This is why I can't read most tech articles these days. Won't get to the point without a long detour into the background of the problem; as someone in my forties, it's hard to justify the expense.
I kinda get him having to drag these historical UI to draw some points but ended up having no critical points for current context and title. I guess it's info for "Get in Zoomer" part but failed to demonstrate "We're Saving React". If a zoomer read that, what should they do, what's the point to get start here, and should they save React or start something new?
(As a zoomer,) I know that React is designed as the way it is because it's limited by the DOM model for all rendering and user interaction, whereas for native apps you have much more freedom in terms of design space of GUI toolkits (from a completely retained model like Qt to highly immediate ones like IMGUI).
The disappointment of the article is that he talks about how the Mac OS X apps were the pinnacle of desktop applications, but he never talks about how people have achieved this. Did the Cocoa API made some special design decisions (as opposed to MFC or Qt) that enabled devs to make more reactive apps?
You know it well (DOM, Retained | Immediate). There's nothing to do with saving react here. Talking about browser app specially, I'd keep eye on standard like Template Instantiation and the coming up Symbol as Map's key. It's closed to the recent "Signal (reactivity)" trend. A way to update part of tree more efficiently without re-render-the-whole-thing. As long as we still use DOM, it's not going to be more revolutionary than this.
The only possible Revolution I see is not using the DOM. JS + WASM is fast enough, the DOM is not fast enough, or good enough, enough here meaning enough for creating highly dynamic 60FPS experiences. Main issue with leaving it behind is A11Y though.
> A templating language ... targets a weird imagined archetype of someone who isn't allergic to code, but somehow isn't smart enough to work in a genuine programming language. In my experience, this archetype doesn't actually exist.
In my day job, I write "sequences" to command a spacecraft, in a neutered "sequencing language" with conditionals but no looping. Several people on our team who are great at writing sequences for the spacecraft feel they "can't code" and don't learn other languages. I had assumed the deal with templating languages was similar and this type of people were the target users.
Creating ways for people to interact and control a computer by writing but who don’t need to know about deploying to production, scaling databases, managing memory resources, etc, seems like a good division of labor.
There are two forces at work here when this division of labor disappears: 1.) increasing complexity in the tool designed for non-computer engineers and 2.) the subtleties of a class of worker who don’t want to do literal manual labor like typing in SQL.
At many firms it seems as if there is a layer of operations that is only capable of interacting with a CRUD UI, constricted either by ability or tooling.
That is, there is a pressure from management to split a firm in two: those that code and those that do not. This means that even something as simple as making updates to a CRUD interface is entwined with the the rest of the engineering practices.
Case in point: computer engineers writing SQL at the behest of some other entity at a firm who is not capable or allowed or even encouraged to learn or understand SQL.
> Creating ways for people to interact and control a computer by writing but who don’t need to know about deploying to production, scaling databases, managing memory resources, etc, seems like a good division of labor.
I guess it depends on the domain and the lines along which you want to divide your project along. If someone can write back end code but doesn't really know that much about databases, you might end up with an application that does hundreds of database queries just to display one application view or prepare a REST query response.
If someone counts as a full stack developer but ends up producing a singleton app that cannot scale to more than one instance (e.g. stores important data in application memory, even things like user sessions), then you also probably have a bit of a problem on your hands.
If someone counts as a DevOps engineer but doesn't think too much about security, you might end up with a database instance that's publicly available, increasing the attack surface of your system a whole lot.
You can have a division of technical and non-technical folks, you can have a division between the different types of technical folks, but you absolutely do need at least someone who can wear all of the different hats (e.g. partake in a particular role) out there, in addition to them being present at the correct time to bring up things that are actually (or should be) blockers, which would otherwise get overlooked and would result in a horrendous implementation.
> The very notion of "back-end" is a fallacy: it implies that one can produce a useful, working system, without ever having to talk to end-users.
This is a small part of the rant, but he is fundamentally mistaken about what backends are. The real life equivalents are not bridges, but kitchens or back-offices: a place where you make the sausage so that the customer can have a delightful experience without the gory business part in sight.
It’s not disconnected from end-users, quite he opposite, as it’s suppose to realize the core value of the product.
I don’t agree with a lot of other parts of the rant either, but the global message of “react needs to evolve in a different direction” is I think interesting.
Funny how reactive seems recent for people, while dataflow / dag based visuals are old in the movie/cgi industry :)
It always pains me to remember a p2 cpu could do realtime nurbs procedural animation (very complex) and yet we still have manual state machines for simpler tasks like documents / filesystems etc
This article is right that there's a lot to gain in terms of ergonomics by finding leaner ways. I also think the web stack and dev culture is ready to respond well to this idea.
>A templating language is mainly an inner platform effect. It targets a weird imagined archetype of someone who isn't allergic to code, but somehow isn't smart enough to work in a genuine programming language. In
Strange sentiment. Isn't React templating as well? Besides one of the most famous use of templates is macros (in C as well as other languages). Would people who generate code be allergic to coding?
Nope! You can make React apps with just a plain ol' JS file (and doing so is frankly instructive). Most folk add in JSX for extra syntactic sugar tho, so the confusion with templating is understandable.
I think the point is that React is a true programming language with syntactic sugar to make it look templates, vs templates that bolt on some language.
React is just JS as any other app using JS with templating. I really fail to see the benefit with the React approach. If anything it makes it more difficult to have a 100% match between design and the end product.
How much React have you written? Because React is just JavaScript, you can take traditional programming patterns and apply them to your UI, for example higher-order components. You can't do this with templating.
Hm, can you describe what do you mean by "can't do this with templating"?
Do you mean that since React/JSX kind of a superset of JS you can do higher order stuff in it, whereas in a simple templating language like Jinja2 you can't?
Isn't that a false equivalence? I mean I regularly use patterns similar to HOCs in Angular. It's easy to wrap components[0] and it's just as possible to project components into other components programmatically[1] with complete dynamism.
[0] depending on the use case there are different preferred ways: directives, which have access to the wrapped component and its template, and can interact with it in many ways, or you can do it from raw TS ( https://github.com/abumuawiyah/ng-ivy/blob/master/src/app/ap... see the withTheme and withStyles functions )
I wrote this on my phone. Hopefully it makes sense.
No templating language is going to beat a general purpose programming language as far as features go.
There’s no technical limitation of templated languages that would bar them from having the same functionality as a general purpose language. Whoever is designing the templated language is probably not going to design something as powerful as a general purpose language.
Angular built a specific set of keywords to include higher order components. React did no such thing — they exist for free because it’s all just JS. You could imagine that there are other patterns that exist in JS that you can’t express in Angular because it doesn’t have all of the flexibility of JS.
From your example you showed that you used TS to create your component, essentially using an escape hatch from Angulars templating language to do what you want. You don’t have to escape from React, because you’re already in JS.
I haven’t used Angular in a while, but I have been using Vue recently. The difference is huge. I can’t (easily) put a Vue component in a stack. I have to learn Vues syntax that will have zero transfer when I go to another framework, whereas React is just JavaScript (JSX does change some HTML attributes, but it is generally 1:1).
To close, I don’t think React is required to be productive or write good UI. I just really like it because there’s no magic going on. It’s just syntactic sugar over JS.
Hm. I find this kind of inconsistent, as you already have HTML in your JS, so it's not just JS. HTML is the templating. JSX is a super lightweight layer on HTML with its own weird rules.
I don't like Angular's default verbosity of separating the template from the logic, nor it's hijacking of the simple double quotes, but I disliked fighting with JSX and too too large files in React. Plus in my experience React projects grow their own verbosity too (in my last NextJS project every component had at least 2 files, one for wiring up the state and one for lowlevel view things, and it was awfully unclear what goes where). Plus the stringly typed state store :(
I don't think it's true that a general purpose language will be always better than a templating language. For one thing the template gets interpreted, there's already a context, it can be safer and more efficient. I mean JSX is great because it allows easy interpolation, in plain JS you would have to do backticks and ${} and the IDE/editor/linter would need to guess (or you would need to annotate the string like in Markdown) about the syntax and semantics of what you want to emit.
Of course making the jump from the host language to the target language too onerous leads to inefficient engineering, boundaries placed at convenient instead of optimal places, etc.
And it's very good that JSX allows stepping back to JS easily. Angular templates allow that too, but it's just not as fluid (probably because the syntax is just meh).
There are specific keywords to do things in template-land and there are non-template ways, that are more general and more messy. Because DSLs can be more effective for the things they were designed to express. The simple React HOC composition is similarly simple in Angular too, <ng-content /> and that's it. What's less appealing is that it happens in template land, and for some reason the wrapping in pure JS feels more powerful (to me too, don't get me wrong), but the actual hierarchy of components is defined in template - in JSX - in React too. It just feels closer to JS. (Rightfully so.)
> I find this kind of inconsistent, as you already have HTML in your JS, so it's not just JS.
You don’t write HTML in React. You write JSX that gets compiled down to function calls which at runtime becomes HTML. JSX is a nicer syntax to make function calls look like HTML. I know this sounds pedantic, but this is the exact thing that differentiates React from others.
People who use it from ClojureScript, for one. Due to the nicer Clojure syntax you don't need a templating language, just a data convention (hiccup in this case).
For those of us who hope JS will slowly become just a compile target, a downside of of JSX is that it's tooling is JS specific, and the syntax is tailored to JS. So it's great that React isn't married to JSX.
I wrote a GUI framework that uses React API directly.
It's more proof of concept than useable, the idea is that we don't actually have to write layouts, we can just describe the layout with code or a template language and let the computer work it out.
Yeah strangely it compiles to functions but they way they compose is not the way we compose function. Practically it's a template, compose via component mechanism. If it's a language it should be like Elm where attributes and children are also List and have return type, can be programed in function style.
If this was a rant on boomers, it would be seen as ageist. Let's not blame all the new stuff on the new generation, it's not like a hoard of zoomersTM wrote react right after graduation.
I don’t blame it on the new generation at all and the boomer zoomer dichotomy bothers me quite a bit. I just want us all to steer away from this disaster in the making.
Nevertheless, when it appeared on the scene, it was wild: you're going to put the HTML and CSS in the JavaScript? Are you mad?
I still think plain old CSS - separate from any JS or HTML or JS that generates HTML - is the way to go.
Just so much easier and less brittle. I get that CSS being too hard for binary tree inverting geniuses to learn is now widely accepted folk wisdom, but it's really not true.
I strongly dislike having all the css for the site in one place because the dependencies are opaque and it’s hard to apply local reasoning. For some CSS that’s what you want, but for a lot of use cases you want very specific rules coupled to very specific DOM. When I have that kind of relationship I want to control the blast radius and not let it leak out to the rest of the app. I also want co-location with the thing that’s making the relevant DOM.
I also do think CSS is hard to learn because of how vast it is with the decades of shit piled on. There’s no clear way to do a lot of things, and if I have a solution, there’s always this doubt that I’m holding it wrong and fucking over future me.
People that know CSS tend to hate things like tailwind and css-in-js because it’s an absolute abuse of the core design principles of “correct” CSS. But these things succeed for not 100% bad reasons.
If I had to venture to guess based on how their APIs work, it's probably events. There's a system called "NotificationCenter" which can be observed to receive system events within Apple API's which is quite old.
Cocoa also lets you two-way bind a state object with the view as long as the state object (whether it's a controller or a model or a view model) implements key-value coding; notably, the blessed data framework (Core Data) is KVC-compliant, so apps that use Core Data sort of get all this for free. Core Data also has fairly good support for undo/redo. That being said, Core Data is a fairly idiosyncratic relational data layer. It's sort of a double-edged sword: it's easy to do 90% of what you want, and the last 10% will involve some deep dives into Apple's documentation. But it's been a long time since I've written an app on OS X -- someone will have to correct my errors.
I've long thought that the inverse of what the OP suggests, bringing reactive UI programming techniques to Cocoa, would be much more interesting. Making native apps just as easy and as fun to build as web apps would be great! ReactiveCocoa/ReactiveSwift are promising, but the underlying, mutation-heavy Apple APIs still peek through. SwiftUI also seems promising, but still relatively immature to the, gosh, decades-old OS X platform.
>But this is the same company that seamlessly transitioned its entire stack from PowerPC, to x86, to x64, and eventually ARM, with most users remaining blissfully unaware this ever took place.
Also from 6502 to 65C03 to 65C816 to 68k to PowerPC... But Apple ][ users were painfully aware of the 68k transition. ;)
Having been through it, it was as seamless as one can imagine. Remember that 99%+ of Mac users have no idea what this means from a technical POV, or understand the amount of magic that allows most Intel software to "just work" on Apple Silicon devices.
The only noticeable seam before the ARM transition was the terribly long and dreadful time between the PowerPC and the ARM when they were using hot ugly inefficient power hungry SpeedStep hobbled x86 and x64 processors jam packed into way too thin a case and hot glued next to swelling batteries without proper ventilation or cooling.
> Now, before you close this tab thinking "ugh, not another tech rant", let me first remind you that a post is not a rant simply because it makes you angry. Next, let me point out that I've been writing code for 32 years
Ha, I was wondering if I'm the only one allergic to that attitude. For me it was one sentence later at "You should listen to your elders" where I decided this piece won't be much of a value and head over to the comments which never fail to have some interesting insights without forcing me to read extended history and ramblings.
“The orange site” is some weird euphemism twitter users use when complaining about HN. It’s also a great search term to chuck in to twitter for some entertainment.
because the name is harmless, uninteresting and unambiguous, but if anyone asks "what's that orange site" they can explain that it's bad because it's libertarian/capitalist/idealist/optimist/progressive/every-account-is-elon-musk-himself.
and this helps them to maintain their nice oversimplification too.
That was my guess as well (re lobste.rs), so I went there for the first time, but while the favicon is red the site itself doesn't have a prominent color at all, so I've no idea.
Perhaps it's not a reference to the site's design, but that lobsters are red and that lobste.rs is, as I believe I saw [someone] once put it on twitter, "for people who need a second orange site in their lives?"
(I removed the name because I can't find the tweet & don't want to risk putting words in their mouth.)
I come here to read interesting content about a variety of topics - even things that I spend very little time thinking about. I trust the community's ability to curate interesting content. Even if you think my trust is misplaced, I derive enjoyment from the articles and the ensuing content.
I go to lobste.rs for software development content exclusively. There seems to be a bit more of an intentional focus on that kind of content there.
The fundamental flaw of this article is that React as far as I know never claimed to solve all these issues. React mainly handles state and rendering. It is also a common crticism of React. The opposite is a common crticism of Angular. Maybe the article should have been about Angular.
The more I think about it, the more this plea to push web frameworks in the direction of desktop apps feels misguided.
I know Chrome OS is really seen as the way forward for many many people, but what if they are just betting on the trend to last, when it is just the usual cycle of “applets” vs local applications ?
The same way Java was pushed in the browser, to then cement its role in desktop apps (or the Flash -> Air progression), wouldn’t javascript heavy work sites at some point move to a native JS hooked into the system and opening the door to system wide drag and drop, undo etc.
Except for the non-dancing zoomers catching stray bullets at the end, this is a really great rant. He’s absolutely right that React won for very good reasons, reasons that new frameworks don’t seem to understand by making old mistakes (templates and directives, looking hard at you). But the rant goes deeper in its accusation that React (and the web) has forgotten the past as well. React (and the web in general) isn’t a great solution for data that is 1) real-time, 2) multi-user, and 3) contextually undo-able.
He’s not wrong, but I wonder what kind of applications he’s working on that require all three of those characteristics simultaneously. If you only need 2 out of his 3 data requirements, then React + Apollo can handle it just fine in experienced hands.
For apps that truly do need all 3 capabilities, the problem isn’t React per-se. The problem is that such apps are just complex by their very nature — even by reducing accidental complexity to zero, you are still stuck with a huge amount of essential complexity. That’s just the nature of the beast.
Although I have long since moved on from Clojure since Rich Hickey made it clear Clojure was not about me but about him and his consulting business, you really need a powerful language like Clojure to do something as tricky as the author wants poor little JS to do. Someone one described JS as a cute dog with three legs — you feel for it, and take care of it, but you know it really isn’t capable of too much. A hard problem needs a powerful tool, and nothing written in JS (kinda-typed or not) is going to get the job done.
No, it won't. Web is an ever changing platform, with a lot of churn.
The most long lived framework currently is emberjs. But it is not the hottest, so you won't find it discussed much. The most "future proof" framework is "React" which is the one mentioned in Original article.
It goes without saying but React is the cause of a lot of churn in js ecosystem, particularly due to its "no-battery included" approach.
## what about other popular frameworks?
Other popular frameworks are angular and Vue.
Angular has gone through such a major shift between angular 1 and angular 2, that angular 2 should have been renamed.
That being said Angular2+ is also going through a paradigm shift (albeit in right direction this time)
The other popular framework is Vue. Vue's templates have has gone through minor changes. And it has gone through a major change (vue 2 to vue3) recently. It is unlikely that another such large rewrite will happen for next 3-4 years. But after that, who knows?
The only option here is to refresh your skills regularly every 2-3 years
What shift is Angular 2+ undergoing? In my experience it’s been remarkably stable since the first couple of releases. I’ve often wished they were more willing to support newer paradigms (functional components, observable inputs, etc.).
i think the back button behavior is intentional - at least on mobile.
if someone sends you a link to a piece of content on FB and then you use the back button it sends you to your feed, and now they have a much greater chance of trapping the dear user in their algoverse.
Did not get the point about back- end. But does people remember how FB used to work? After going to the start-page and some clicks it had sent 1000+ requests. This was back when you could expect max 5 connectios per domain. The site was slow. The Android app was basically just a spinner.
I don’t understand arguments like this. PHP is fortunate enough to run on a real operating system with real APIs. React is running in the browser which is quite possibly the worst place to make anything stable. It will never be as stable.
I also remember something, and you forgot to mention it: other frameworks were honestly saying that they took some ideas from React (or improved their solutions being inspired by React’s ideas).
I don't think it was a good idea to use such a hostile style of writing - it is ok for web frameworks to evolve. It is more than ok to share ideas. Every time I see that some new framework took some idea of React (or Ember, or Angular, or PHP) - I see the “credits”, the authors are not trying to hide it.
Some people are criticizing some frameworks - it is ok, no need to start holy wars because of that. Valid criticism will help, pointless toxicity will just shade away.
Most likely an immense existing app with some gigantic library of React components... I still work on a React app with class-based components so complicated that nobody wants to touch. Like, componentDidUpdate() is hundreds of lines of spaghetti code kicking off even more setStates. Even some of the newer hooks-based components are a maze of side-effects... effects kicking off other effects, triggering a memo, triggering another memo. It's a mess, and management does not have 'tech debt' in their vocabulary.
>So what exactly did we lose? It's quite simple: by moving software into the cloud and turning them into web-based SaaS offerings, many of the basic affordances that used to be standard have gotten watered down or removed entirely. Here are some examples:
>Menus let you cross over empty space and other menu items, instead of strictly enforcing hover rectangles.
I know the guy, Frank Leahy, who implemented that feature invented by Bruce "Tog" Tognazzini.
When he was at Apple, he rewrote the Menu Manager for Mac SE and Mac II.
We were working together on a project at Current TV, and reminiscing about how great the original Apple Human Interface guidelines were, and how Apple had totally lost their original devotion to excellent user interface design, and I mentioned how the original edition of the Apple HIG book I had actually illustrated, documented, and justified that subtle feature.
Frank proudly told me he was the one who implemented it for the Menu Manager, and that he was touched that somebody actually noticed and appreciated it as much as I did.
>The comments are actually great -- even Tog weighs in! It also mentions Frank Lehey, who rewrote the Menu Manager for Mac SE and Mac II.
>Jake Smith • 5 years ago This was first implemented by Apple's HID team back in the 80s, specifically Bruce Tognazzini, I believe.
>Bruce "Tog" Tognazzini Jake Smith • 5 years ago Yes, I did invent it back in 1986 and it is firmly in the public domain. From what I remember, it was Jim Batson who worked out the math and coded it for the Mac OS. The OS X team later failed to copy the algorithm, so I am happy to see that amazon has resurrected it.
>Josh Davenport Jake Smith • 5 years ago I think it was yes. It looks like it was originally implemented by NeXT and then removed by Apple when they bought NeXT. Tog himself talks about what happened here: https://www.asktog.com/columns/022DesignedToGiveFitts.html in the answer to question 6 - "When I specified the Mac hierarchical menu algorthm in the mid-'80s, I called for a buffer zone shaped like a <, so that users could make an increasingly-greater error as they neared the hierarchical without fear of jumping to an unwanted menu...........Sadly, the NeXT folks, when coming to Apple, copied Windows, rather than the Mac"
>markr_7 • 5 years ago Can't comment on the HID team, Bruce, or possibly the many times it was even implemented at Apple, but as a young developer at Apple in the 80s, I remember stopping by Frank Leahy's office as he was tweaking his code to get menus to "work right." I've often recalled the experience because of the time he was spending to get it right, and how the behavior wasn't simple once you started really trying to meet a users expectations. If I remember right it wasn't just the direction, but also time and therefore velocity. For example, you wouldn't want to stick with the wrong menu if the user wasn't really moving with purpose in the direction of the sub-menu.
>Many competing frameworks acted like this wasn't so, and stuck to the old practice of using templates. They missed the obvious lesson here: every templating language inevitably turns into a very poor programming language over time. It will grow to add conditionals, loops, scopes, macros, and other things that are much nicer in actual code. A templating language is mainly an inner platform effect. It targets a weird imagined archetype of someone who isn't allergic to code, but somehow isn't smart enough to work in a genuine programming language. In my experience, this archetype doesn't actually exist. Designers don't want to code at all, while coders want native expressiveness. It's just that simple.
This is exactly what I was getting at when I wrote this recent post about Smarty (in response to the following parent comment proposing building a crippled scripting system for designers), to which somebody insightfully commented "Someone doesn’t like Smarty…"
parent> Even in game development, it often turns out to be a huge mess that coders have to go and sort out after the fact, it's almost inevitable if it's general purpose enough. If you do decide to build a scripting system for designers, I would recommend being very conservative with features and thinking twice before adding any new feature.
>Just hire competent and trustworthy designers, instead of purposefully crippling the tools you spend so much time developing. The best designers can also code, and if you design a system that discourages instead of encourages designers from coding, you're wasting the potential of those precious coder/designers, and wasting the opportunity to train your best designers to code too.
>It's not as if Rock Star can't find anybody qualified who wants to work for them, or any designers who are willing to learn to code in a powerful visual scripting language.
>This attitude causes disasters like PHP's "Smarty" templating language.
>PHP was already a templating language, but somebody got it in their head that there should be an iron-clad separation between designers and programmers, and that PHP gave designers too much power and confused them, and that their incompetent untrustworthy designers who refused to learn anything about programming deserved something even "simpler" than PHP, so they came up with Smarty.
>Then over time the realized that their designers were powerless, so their programmers would have to learn TWO languages so they could wade into the Smarty templates to make them actually work with all the extra code they had to write because Smarty was so crippled, so they nickle-and-dimed more and more incoherent programming language elements into Smarty, making it EVEN HARDER to use and more complicated and less consistent than PHP, yet nowhere near as powerful.
DonHopkins on Aug 19, 2019 | parent | context | favorite | on: YAML: Probably not so great after all
One of the most ridiculous examples of this was the Smarty templating language for PHP.
Somebody got the silly idea in their head of implementing a templating language in PHP, even though PHP is ALREADY a templating language. So they took out all the useful features of PHP, then stuck a few of them back in with even goofier inconsistent hard-to-learn syntax, in a way that required a code generation step, and made templates absolutely impossible to debug.
So in the end your template programmers need to know something just as difficult as PHP itself, yet even more esoteric and less well documented, and it doesn't even end up saving PHP programmers any time, either.
>Most people would argue, that Smarty is a good solution for templating. I really can’t see any valid reasons, that that is so. Specially since “Templating” and “Language” should never be in the same statement. Let alone one word after another. People are telling me, that Smarty is “better for designers, since they don’t need to learn PHP!”. Wait. What? You’re not learning one programming language, but you’re learning some other? What’s the point in that, anyway? Do us all a favour, and just think the next time you issue that statement, okay?
>I think the Broken Windows theory applies here. PHP is such a load of crap, right down to the standard library, that it creates a culture where it's acceptable to write horrible code. The bugs and security holes are so common, it doesn't seem so important to keep everything in order and audited. Fixes get applied wholesale, with monstrosities like magic quotes. It's like a shoot-first-ask-questions-later policing policy -- sure some apps get messed up, but maybe you catch a few attacks in the process. It's what happened when the language designers gave up. Maybe with PHP 5 they are trying to clean up the neighborhood, but that doesn't change the fact when you program in PHP you are programming in a dump.
DSLs have their place. Twig for example is/was a nice templating lib for PHP. (Smarty is of course completely cursed.)
There's value in separating the presentation layer from the other parts. There are nice things in Twig that are not in PHP. (Pipes, for-else, etc.)
Of course PHP was (is?) far from a general purpose language, but a templating lib allows PHP core devs to focus less on "templating".
And it's just reality that fixing/improving/iterating/evolving a library is much easier than the host language. Updating a lib version is easier than updating language version. Similarly it's a real constraint that not every company/team/engineer will be able to "just hire competent designers".
React is also suffering from this. (Due to its popularity, hence it's the victim of its own success. Or looking at the big picture it's the normal part of the hype cycle.) The article mentions that every React repo/project is different and full of their own conventions. (And implies that they are broken too.) Oh, who would have guessed? After all it's just a view layer and people will put a myriad things on top of whatever the current "create react app" spits out.
really? a site where most posts get 0 comments? I would have assumed reddit (/r/programming) which has a large overlap with what is discussed here (the scary orange site)
I've been doing front end since the late 90s and I disagree with many points here.
One thing I do agree is the rant at the end about zoomers. We see stuff like tailwind popping up which really reflects the zoomer ethos of not wanting to learn fundamental stuff like CSS. "It's so easy to get started! Why would I learn anything else?"
I think gen Xers and late boomers will be the most tech developped generations because we had to use computers that were hard to use.
On the contrary, Tailwind necessitates learning CSS. I don't see how someone can write "flex flex-col gap-2 mx-2 px-4 py-2 text-gray-600" without understanding flex, margins, paddings, and seeing how children inherit certain properties. Tailwind doesn't replace CSS; it just moves properties out of a stylesheet and into a component template. That said, if someone is trying to learn Tailwind before learning CSS they're going to have a hard time (I doubt they will succeed at all).
People that learned CSS before tailwind was a thing tend to hate the concept. But clearly it has to have some value right? Why is it so popular?
I argue that it solves a clear design deficit in CSS. You cannot have tight coupling with CSS and a lot of the time you want tight coupling. In-line styles are insufficient, so we have tailwind. It’s an API to css that lets you tightly couple your styles. The re-usability of those styles is accomplished by composition of components or composition of atoms via @apply.
> But clearly it has to have some value right? Why is it so popular?
Popularity doesn't mean much. I mean, look at React.
And Tailwind isn't that popular. From Twitter you might get the impression everyone is using it, but if you look at the State of CSS you'll see is not even close to something like Bootstrap or SASS.
> As someone who took a classical engineering education, which included not just a broad scientific and mathematical basis, but crucially also the necessary engineering ethos, this is just alien to me. Call me cynical all you want, but it matches my experience. Coming after the generation that birthed Git and BitTorrent, and which killed IE with Firefox and Konqueror/WebKit, it just seems ridiculous.
> Fuck, most zoomers don't even know how to dance. I don't mean that they are bad at dancing, I mean they literally won't try, and just stand around awkwardly.
> Just know: nobody else is going to do it for you. So what are you waiting for?
It seems like ranting about how the older generations were better, and conversely the younger generation is decadent, is as old as history itself. Anybody know why this is the case? Is it that our overall character has really been heading downhill for all of history? Or is it something else, like how we generally remember the best of the past but mostly notice the worst or merely average in the present?