Now that's a fine language for a server. It combines the type safety of Ruby, the memory safety of C, and the terseness of Java.
(I'm joking, mostly... Actually I was a big fan of Obj-C for desktop apps. Fond memories of times when I didn't have to care about servers and ever-changing web frameworks.)
And amusing to myself how many people actually remember or know what WebObjects was!
The same with everything called "XSan" and "Mac OS X Server". I don't know what any of it was, but the box art was always so cool.
a lot of people learned to code on the web via viewsource - now we are obfuscating the code
To elaborate on your comment, if you just ship sourcemaps in production, that means you can ship minified code and track down what _actual_ source that you _aren't_ shipping to users is getting called, is in stack traces, etc.
I'm not aware of a point of sourcemaps otherwise.
Here's the original post by the author of the repo himself: https://old.reddit.com/r/webdev/comments/1onnzlj/app_store_w...
The pattern itself is a little bit different, has some conceptual overhead, but it's also fairly clean and scaleable.
I’ve been staring at Apple source code (the stuff they let The Great Unwashed see), for almost forty years.
It’s always been very polished, well-structured, well-documented, succinct, and beautifully written.
It’s been an inspiration for my own work. I have always striven to emulate them.
That’s why it’s so shocking for me to encounter the terrible quality of the Connect backend. It’s quite painful, and disappointing.
Often though, Javascript is hard to read not because it's been obfuscated, but because its been transpiled and/or minified for smaller network payloads.
I can understand why some don't want to ship their sourcemaps to prod, but also it really doesn't matter all that much.
Let's be honest, when a company makes a website they want you to see the website not the code. Of course front-end code is less private in nature but still, showing it could expose some vulnerabilities.
This issue is very wide-spread.
I wonder how much difference LLMs today have on being able to turn minified JS into something easily readable? JSNice already worked pretty well and I guess that was comparatively naive. You won't really stop anyone motivated to reverse-engineer it by not providing source maps, but you'll definitely stop at least some curious people from understanding how websites work. Your frontend also doesn't suddenly turn "open source" just because you shared the original source via source maps, that part sounds kind of FUD.
Was it, HTML, CSS & Javascript?
And the "leak" is fun for me because you can see how they write their components haha
Svelte files look like HTML+TS files. You aren’t learning some abstraction to HTML, you are just using HTML. But it adds the modern bits you need: reactivity, loops, components, routing, etc. Nothing react doesn’t have, but the devex is great.
Other benefits:
- your app is compiled. You don’t ship the framework to clients, they just get a minimal compiled app.
- The rendering modes are pretty great. Any page can be server side rendered, or client side, with per page flags. You also can easily setup SSR for the first page, and CSR for later pages - both the fastest option. It will even pre-fetch the next page when you hover a link, making most nav instant.
Same goes for most modern frameworks (Solid, Vue, Preact) and even old ones experiencing a renaissance like Angular.
However, they recently added runtime reactivity to be more flexible, so it seems to me they are becoming VueJS.
(note it won't work on apps.apple.com because apple has removed these sourcemaps)
[0]: https://gjs.guide/
I worry that every year we keep increasing our processing requirements and bloat without good reason for it.
Why should every Windows release require a faster and faster CPU, and more and more RAM?
The recommended amount of memory for Windows 95 was 8 megabytes, and for Windows 11 it is 8 gigabytes. Why is this not horrifying?
My small Linux system with openbox GUI barely cracks 100MB memory usage in 2025.
What makes a browser so much more inefficient vs. other UI frameworks? Is it really the browser's fault or the website's you're visiting?
Almost every single interaction and change requires the browser to recalculate the layout of the entire page and to redraw it. It's basically Microsoft Word, with nearly the same behaviors.
And there are no proper ways to prevent that behaviour. No lower and low level control over rendering. Awkward workarounds and hacks that browsers employ to try and minimize re-layouting and redrawing. Great rejoicing when introducing yet more hacks for basic things: https://developer.chrome.com/docs/css-ui/animate-to-height-a... etc.
And how is that different from a UI framework?
> Almost every single interaction and change requires the browser to recalculate the layout of the entire page and to redraw it.
What UI frameworks don't do this?
In none of them text is primary and all other incidental?
> What UI frameworks don't do this?
In which UI framework actions like "set focus on an element" triggers a full page re-layout?
Also, in which UI framework there's even a discussion of "try to not trigger re-paint/re-flow"?
And yes, I know about immediate mode UI where the entire layout is re-calculated every frame. But then they can usually render thousands of elements at 60fps.
This is a pretty outdated way of thinking. If we were only speaking about (old) HTML then maybe. But these days HTML and CSS are basically inseparable and go far beyond "text is primary".
> In which UI framework actions like "set focus on an element" triggers a full page re-layout?
I don't see why a browser would need to re-layout for just a focus change. Unless, of course, the CSS changes require a re-layout after the focus has changed (`:focus` selector).
Every UI framework can run into performance issues with layout and/or painting if they're complex enough (or poorly made). There is fundamentally very few differences between HTML+CSS and other UI frameworks.
That "inseparable" is building on top of a bunch of legacy cruft, hacks and workarounds for a system that is stilm barely suitable to layout some simple text.
Just because CSS is there it doesn't make the browser a UI framework.
> I don't see why a browser would need to re-layout for just a focus change.
Indeed. No one does. And yet you'd be surprised: https://gist.github.com/paulirish/5d52fb081b3570c81e3a (note: unfortunately there's no up-to-date list as some of these issues are fixed in all or some engines, and a bunch of other gotchas are introduced).
> There is fundamentally very few differences between HTML+CSS and other UI frameworks.
Lol. There's almost no other UI framework that struggles with as many trivial performance issues as HTML + CSS [1]. No other UI framework has so many gotchas and issues with even the simplest layouts and animations. No other UI framework has warnings of "you have 800 nodes, it's too big, and will cause issues". No other UI framework has so few ways of telling the framework "delay painting" or "I will take over painting" or "do these paints in batches" or...
Etc. etc.
[1] A good article that dives into just the animation side of things https://motion.dev/blog/web-animation-performance-tier-list
Here's a deeper dive. It's about animations, but it explains issues in a nice way that "even ChatGPT" can understand: https://motion.dev/blog/web-animation-performance-tier-list
The fact that each app carries their own copy of the browser engine.
Teams, Chrome, Steam - that's at least three Chromium engine embeds that all take up hundreds of megabytes each. Not to mention Steam is in the background and has no windows visible, and yet it has the Chromium helper processes gobbling up RAM. WTF is this shit.
Life used to be easier in the Windows 98 days with OCX, you just dragged a webview in the VB6 application designer and that was it, and IIRC it was even possible to embed Firefox in the same way for a while...
This has nothing to do with the browser itself. Ideally everything would use the same browser instead of shipping their own. On Windows it's already possible with WebView2 but developers need to choose to go that route. Teams should already be using it.
I don't know. But does it? It doesn't seem like you verified that yourself - you're comparing stated recommended specs of Windows to actual usage of Linux.
And there’s the whole inspector in web browser, meaning that the layout is not done once and forget. There’s various sub components still present for whatever features. Great in the browser, not great for standalone apps.
A choice of tech stack can never be enough to prove anything. It only establishes a lower bound on resource usage, but there is never and upper bound as long as while() and malloc() are available.
(Except maybe the "Home"/"For Me" pages which are just "discovery page" extensions of the store and the Apple Music service that's built on top of it)
The macOS one descends from iTunes and the iOS one descends from the original iPhone which sure as hell wasn't a webview.
There's also some parts of System Settings that were always web views, which I always found surprising for a company trying to make the case for native apps.
Curious if it was done intentionally or simply due to hurrying.
Have you tried visiting the site on a worse machine?
They try to create a _perception_ of a quick answer while adding overhead and distracting people.
What I truly hate are animated skeleton boxes or element level spinners. Why are you trying to hold my attention on something that's not even loaded yet? We all understand the UI paradigm and implicitly understand network delay, you don't need "comfort animations" to keep me happy. I'd rather use the time to look at any of the other tabs or applications across my screens. Then the flash of content actually means something.
Worse still, applications like microsoft outlook on the web, use the skeleton boxes with comfort animations. What they don't do is pre layout their icons. And different icons will appear in different contexts. I often get the case where I aim for one icon, something will load in, create a new icon, and push my intended target out of the click.
Skeleton loaders are a bad kludge over an initially ignored problem.
The loading state is indistinguishable from the page crashing. Did the JavaScript fail, or is the connection just slow?
> animated skeleton boxes or element level spinners
Good news! Browsers have low motion settings. Any programmer worth their salt will respect this and the skeletons won't be animated.
> Then the flash of content actually means something.
On the contrary, if the content is loaded in multiple parts (in my own application, I split the loading into multiple requests: one is cacheable across multiple pages, one is cheap, one is expensive), you either need to not render anything until everything is loaded (bad: the user can't interact with the parts that loaded first), or the page jumps around as content loads in. Skeletons fix this. UI elements in the middle don't end up being 0px tall and moving the stuff below them around nearly as much. How annoying is it to nearly click on something and the page jumps violently and you mis-click?
It honestly sounds like you just don't like lazy programming. That's very fair. Skeletons done right just mean the page is the correct layout while they're partially loaded. Without that, the content is literally unusable (you can't read it interact with things that are jumping all over the place).
Personally I prefer to wait than having multiple flashes of content but I do agree no approach is perfect.
Skeletons lie by making an impression that the data is just about ready. So there's this failure mode where data is NOT ready because of a slow app/network, and I end up staring at a fake. Even worse, sometimes skeletons also break scrolling, so you end up even more frustrated because your controls don't work.
2. You show a spinner, which is functionally equivalent to a spinner
3. You wait until the content is loaded and the page feels completely broken, because nothing is happening until it's loaded.
> sometimes skeletons also break scrolling, so you end up even more frustrated because your controls don't work.
This is just lazy programming. The skeleton should be the minimum height of the content it will be replaced by.
A blank page does not try to keep grabbing my attention.
Skeletons also have a toxic effect on web developers by letting them get sloppier.