Is Mesop and Web Components the cure to Front-end fatigue? | Hacker News Reader

Is Mesop and Web Components the cure to Front-end fatigue?

google.github.io

12 pointswillchen12 comments

Web components are a nice idea if you squint hard enough, but architecturally they're inadequate for solving the problems modern frameworks and libraries address — that's why you see them used nearly nowhere. I think needless to say that the answer to tooling fatigue is not more new tooling. As someone who's spent way more time working on frontend applications, libraries and tooling than is good for anyone's hairline, I would say the main thing we really need is time. There is clearly a best practices converging across the tooling landscape, best ways to solve common problems etc, but we're not quite there yet. But I can see it in the distance if I squint.

Any particular parts that you feel are inadequate with web components? Web components aren't a panacea but they have definitely come a long way in the past decade.

> but architecturally they're inadequate for solving the problems modern frameworks and libraries address

Such as?

Do you think these are inherent limitation? Is it possible to get to an "adequate" place with webcomponents alone? Or with web component based frameworks or libraries?

> that's why you see them used nearly nowhere

Little companies you have have heard of using webcomponents extensively: YouTube, many Google properties, GitHub.

Personally I'm hella sad that this industry doesn't make new js frameworks like they used to. It now takes a Microsoft or a Facebook's name recognition for people to pay attention. And where-as before many people tried, devs in the React age see themselves not as capable web makers, but as downstream React craftsmen; we don't recognize in ourselves that we create & shape our development experience, are less trying to find what works for us & more trying to adopt & use existing tools.

I feel similar but different in this summation:

> the main thing we really need is time. There is clearly a best practices converging across the tooling landscape, best ways to solve common problems

We lack the range of experience. Time yes, but more so, there aren't visible enough pokers in the fire. And a lack of a strong blogging culture where every effort gets chatted up & considered by the broader mind. We don't really know what limitations or downsides there are; most folks haven't tried or seen many other tries.

(Shout out to niw-inactive Catalyst web component library, which I hope some day comes back. The action / target system rocks, very similar to CommamdFor/InvikerAction work that's been chunking along. https://github.com/github/catalyst https://github.com/whatwg/html/issues/9625#issuecomment-2115... )

We posted on Show HN https://news.ycombinator.com/item?id=40567327 ~a month ago and got a ton of great feedback.

Since then, we've made a lot of updates to Mesop, including adding support for web components which allows you to write custom JS and wrap existing JS libraries.

We've also fully re-designed our home page at https://google.github.io/mesop - with many more code examples and demo, which hopefully shows how Mesop is different than some of the other Python UI frameworks out there.

As always, appreciate any feedback about the project. Thanks!

You've also pivoted a bit into AI? :) Personally I find that unfortunate because that's not what you actually do (even though many people at Google might use the framework for this) and it's distracting.

Lit and web components are cool, but "front-end fatigue" is no more real than "Python fatigue," since every technology has drawbacks. Yes, I have forgotten the pain of "bundling," as vite, Typescript, and bun are lightyears past grunt, gulp, and webpack. These days, to play with GPU-enabled toys, I am more often struggling with venv and [mini|ana]conda. The long and short of it is that DX continues to evolve across ecosystems.

Mesop's API is... interesting. It seems to replace all REST/CRUD/MVC abstractions with some kind of RPC, which is a perfectly valid way to structure a program. Certainly it saves Python devs from having to learn that corner of the web domain and its pattern language which, hey, may be pasé? Especially in a world of notebooks?

I can imagine this will open up fruitful partnerships with Web Component developers and also give Python devs an entry point into web UI paradigms, so it's certainly a positive for eg GenAI R&D.

That phrase "front-end fatigue" is just sticking in my craw. Where do Python devs get off complaining of "fatigue" over one layer of the stack or another? Data migrations can be just as tricky. God knows infra tooling is more tedious than anything re: node_modules. Must be some kind of selecting bias. Who is understaffing all these Python shops? Is it academia? Are even private AI R&D departments wary of over-investing in ephemeral interfaces? For testing, at least, I suppose they are. Maybe this is related to the reasons why game devs split art and mechanics for as long as possible.

But at the same time, I can't help but feel we're letting Bret Victor down in some way.

Anyway, while I can easily see Mesop elevating demo day, I struggle to believe it will facilitate agile product development which, hey, might not be where the money is at, these days!

Thanks, yeah describing Mesop API as essentially a UI over RPC is a good analogy and is basically what's happening under the hood [1].

I guess one funny thing is that I actually identify as a FE developer more than a Python developer :) I've been doing FE for much longer than Python and agree that there's warts on both sides (and no language/ecosystem is perfect). For me, a lot of the FE fatigue comes from all the inherent challenges with developing client-side applications (e.g. the necessity of bundling/minifying for optimizing performance, transpiling for legacy browsers) so I don't say this to throw stones at the other side but simply to point out my own fatigue having dealt with this complexity for years.

Right now Mesop is definitely more focused on the demo use cases, but we're also trying to push the limits of the kinds of apps you can build in Python so it doesn't have to be something you throwaway when you want to deploy a scalable app.

[1] https://google.github.io/mesop/internal/architecture/#life-o...

> it doesn't have to be something you throwaway when you want to deploy a scalable app.

Yeah, eventually you just hire some FE devs to shine up all the web components in-place, and that should last you until the exit event. ;)

> Mesop's API is... interesting. It seems to replace all REST/CRUD/MVC abstractions with some kind of RPC,

Big shade of Towards a Modern Web Stack vibes, where someone guts everything that makes the web the web & attaches a completely non-web different world inside to move the flesh.

I have to admit, I don't think we have gotten a lot better about rest & operations/mutations & data-stores this decade. I'm far from ready to give up & start stubbing in rpc systems as we feel like it - that sounds deeply anti #rfc8890 -which is the holiest most spiritual tenant of the internet - but I do wish we at.least had worked on & tried to make stitching front & back end together over rest better, more visibly. Like GraphQL, I both want to purge this with fire, but I also appreciate the challenge; the bar should be raising!

And uh... yeah. On that other thing: hammering on a out front end fatigue is some weak-kneed reactionary bullshit, is extremely low road toxic-trash-talk culture shit. The front end has actually uhh gotten good? Do like everyone else & use vite & pick any of the really good ecosystems that've been around for a long time (React, Svelte, Vue, Alpine, maybe Qwik or Solid)

Fatigue problem isn't solved by having more technology, it's about human condition. There is always push/pull between doing new things vs keeping things same.

I'm not too keen on another Google dependency. You gentlefolk have a tendency toward customer screwery and killing the things I rely on. It simplifies Google products right out of my decision making.

The end of my frontend fatigue was to get away from Javascript and it's doctrine of churn.

Reply on news.ycombinator.com