Hacker News Reader

Comment by GuB-42 | Hacker News Reader

> installed desktop web apps are really starting to look and feel like native apps

I think we are having the opposite problem: native apps are really starting to look and feel like web apps, and in many cases, they are.

The problem: the web has a terrible UI toolkit for desktop apps. It has clickable links and basic forms, that's all. It was made for documents, not apps. If you want better than that, you have to rewrite it all by yourself, or more likely, import a framework that does it for you. Traditional Windows apps all use system provided common controls, because they are good, and therefore they have a consistent look and feel, even through OS updates. It is even user customizable. Now it is not uncommon to see 10 different styles in a single screen, Windows since 8 is not even consistent with itself, and it is becoming worse every version. And it is not just aesthetics, there are serious usability concerns here, and system-wide customization is gone.

View on HN

> Traditional Windows apps all use system provided common controls, because they are good, and therefore they have a consistent look and feel, even through OS updates.

This hasn’t been consistent since at least Vista and the release of WPF, which does totally custom control rendering. Circa 2006.

I think web is taking over on Windows because any of 10 or 15 different design systems can get you to a better app than the native (whatever that means) toolkits in much less time. It is easier to get a decent color picker in a web app than a WPF, WinForms, UWP, WinUI, or Win32 app (assuming you have a reasonably high expectation for UI/UX, as I do).

Even Office and Visual Studio (not Code) are using web technologies to render substantial parts of the UI.

> I think web is taking over on Windows because any of 10 or 15 different design systems can get you to a better app than the native (whatever that means) toolkits in much less time. It is easier to get a decent color picker in a web app than a WPF, WinForms, UWP, WinUI, or Win32 app (assuming you have a reasonably high expectation for UI/UX, as I do).

I'll grant you that it's probably easier and cheaper to get a workable "color picker in a web app," but I don't grant that going that route will get you a "better app than the native."

The reason why the web stuff is taking over is because it's cheaper while providing minimally-viable functionality, full stop. It's not actually good in any other way.

IMHO, the trend here is similar to the one consumer printers took.

The word “cheaper” here is doing a lot of work.

Yes, it’s cheaper, meaning that it allows you to ship more stuff faster. You could make the argument that this results in lower quality, but this isn’t always the case. (For example, VS Code feels great!)

Still, I’d often rather have twice the features at 80% the quality, instead of an extremely high quality product that doesn’t have the features I need.

Cheapness leads to abundance leads to innovation.

VSCode is adequate, not great. The bar for responsive and minimal application is so bad these days thanks to web apps.

You can make fast web apps and you can make slow native apps. Check out VSCode's older brother and be amazed by how unresponsive and glitchy is.

The move to WPF in 2010 killed VS. Even today on today's computers it isn't as responsive as VS2008 was.

VSCode replace Sublime, Visual Studio(full) and IntelliJ IDEs for so many developers. It has all the features >90% of developers and it is faster than VS and IntelliJ IDEs

And it doesn't support window and monitor layouts that were possible and useful in Visual Studio 2003, or probably earlier.

Agree. VS Code is simply not comparable to a full blown IDE. It's a text editor with some integrated language tooling.

Of course it is comparable. They are not quite the same thing, sure, but for many people they are definitely comparable and more often than not, VSCode is the better option. It may not support some things, but the same can be said about the “full blown IDE”.

bold statement, as you claim that VS Code would fit the majority better than say $IDE from JetBrains.

I don't know how you came to that conclusion but I'd guess that you mostly work on small projects? (where I'd say smallish is < 100K LOC)

Stuff I'd miss in VS Code coming from JetBrains Rider:

- Docking of panels to top, bottom, left, right

- built-in database explorer (with table designer, script runner, ...)

- built-in unit test explorer

- built-in memory/perf profiler (not talking about a simple text interface!)

- nice config options of project settings (in either text with completion or the UI)

- NuGet package explorer UI

- integrated IL viewer

- great git blame / annotation view

... could continue for a while

tngranados said "many people" and did not say anything at all about the "majority" of people.

Judging from the fact that many people choose VS Code over JetBrains IDEs, despite being aware of JetBrains existence as an option, seems to be prima facie evidence that it is in fact the better choice for those folks.

It offers about 5 to 10 percent of all functionality of an IDE like IDEA. Much like devs on emacs and vim, most devs on VS Code have literally no idea what an IDE offers [1].

The things that worked in VS Code's favor:

- free. "All software must be free as in beer" is still a prevailing thought in IT, and people are loathe to pay for anything, even if that anything is extremely useful and very difficult to realise and support. On top of that IDEA still has a reputation of being expensive

- reasonably fast

- plugin system is decent and much easier to get into than IDEA, to keep IDEA as an example

- LSP is an overmarketed hype, but it worked in VSCode's immense favor. While it only covers a tiny sliver of things needed for a fully featured IDE, it covers enough of the important features, and is easy enough to implement. This way even languages that never had anything decent beyond broken syntax highlights in emacs and vim now enjoy at the very least an autocomplete

[1] Code refactoring alone is dozens of pages in IDEA docs https://www.jetbrains.com/help/idea/refactoring-source-code....

Have you tried Lapce? It's way snappier than VSCode.

It's great and the best desktop app I've ever used.

I'm sorry for you if it's the best that you have ever experienced. It is very subpar and slow.

It's the best electron app I've ever used. It's so much faster than anything else I've seen use electron.

That's quite the back-handed compliment though, isn't it?

Not really, I’d say VS Code is the only electron app that can stand up to native apps. It’s not the best, but it’s pretty good.

Now, for electron, it’s certainly not a compliment. From electron apps I’ve used, only VS Code is great, Discord is good, and everything else is just really, really bad. It’s apparently extremely hard to use electron and have something close to decent performance.

Right, sorry, I meant back-handed for Electron. I have used VS Code a bit for a class, but am usually an Emacs user.

Hah, nah. Electron gets no compliment at all, backhanded or otherwise. When almost no one can create an app on it that doesn't suck, there are deep issues.

We're taking about a trillion dollar company who can afford all of the talent and has very limited time pressure. I would prefer they do it correctly.

This misses the point. A trillion dollars goes a lot further when the software is cheaper.

But VSCode isn't cheaper. They had to pour millions of dollars and countless man hours into it. And none of those translated into any meaningful improvements of the platform.

It isn't cheap wrt hardware requirements either. My 2.5 year old work laptop becomes unbelievably sluggish if I have to keep multiple Electron apps open.

Innovation? More like W95 (or even ME) compared to NT, and don't even start to compare ME against BSD/Solaris/Linux or Mac OS X.

VS Code isn’t a web app. The first release was and since then most of it has been rewritten to be a native app.

Are you sure?

https://code.visualstudio.com/docs/editor/vscode-web

I think I agree with you, but I need a clear definition of "cheaper."

To me, "cheaper" means that companies are putting fewer resources into Windows-specific app development. That's not unexpected, given large portions of their user base are using MacOS, Android, or iOS. Why would I hire 8 developers to make 4 apps, when I could hire 6 developers to make make 3 or even 2 apps? Oh, as an added bonus, now my app can also be loaded straight from a browser, no installation necessary? And I don't have nagging complaints from small-market-share users (Linux and BSD) complaining that my app doesn't work on their machines? Seems like a no-brainer.

From a business perspective, if the end product is good enough that the customers don't complain, what reason is there to not* use web technologies?

Don't get me wrong, I hate that half the software I use today is just a glorified Chrome tab. I hate how I need 16GB of RAM to do my job.

> I think I agree with you, but I need a clear definition of "cheaper."

I think the best definition of MS products in regard with quality and usability is "cheaper" as in "he is cheap". (i.e. only using the lowest quality crap available)

Lazarus will target MacOS, Windows, Linux and all the BSD's creating binaries for all of them from a single source.

Also the deployment makes much more sense in the web. Users are always in the latest version of the software with no install / update shenanigans. This has other implications as well. The application may change internal formats since it doesn't have to worry about older instances of itself etc.

And if you build an updater in your app like chrome / firefox then it needs to be disabled for Linux distributions that have their own package manager.

> It is easier to get a decent color picker in a web app than a WPF, WinForms, UWP, WinUI, or Win32 app (assuming you have a reasonably high expectation for UI/UX, as I do).

What is a decent color picker? Everybody's idea about that is different so basically no 2 websites use the same color picker. In fact, this paper [1] found that the kind of picker (RGB vs HSV, etc...) doesn't really matter, but that better feedback made the difference. So will we get instant feedback from our color pickers now (for example text immediately turning into the color selected)? No, because designers design how they think it should look and feel, not based on how people actually interact with applications.

[1] https://www.researchgate.net/publication/220183526_Model_and...

This one looks pretty solid. There are loads of them. The demos I’ve seen all showcase live feedback.

https://superguigui.github.io/simple-color-picker/

Compare to the best I can find for WPF: https://github.com/dsafa/wpf-color-picker - no live feedback, dialog only, no documented support for modern .NET. There are some commercial controls available from syncfusion and the like if you want to pay for such things.

Compare to color dialog in WinForms: https://github.com/Kinnara/ModernWpf/issues/72

WinUI has a decent color picker, but there are other trade offs going with WinUI that make it inferior to the web environment (e.g. broken rendering of SVG/paths).

> This hasn’t been consistent since at least Vista

Yes, I believe the Windows UI (at least until 10 since I haven't tested 11 deeply) is becoming increasingly inconsistent because of the many UI frameworks out there. And, while I understand that each app's developer is free to choose whatever framework UI they feel is right for them, I find it hard to understand why Microsoft is not sticking with a consistent framework for all of its apps, it went even far by using Electron for its Teams app! However, the thing that I might never get is: Why is Windows itself (and its system apps, i.e Calculator, Notepad) isn't sticking to a single framework? Yesterday, at night, I turned "Dark Mode" on and was surprised to see that "Task Manager" keeps its Light theme. It's weird how Notepad++ has a "Dark" theme while Task Manager has not!

To "gratifies one's intellectual curiosity", check https://youtu.be/hn5QjtpjW_U

The latest Windows 11 update just switched the task manager to the new UI style with support for dark theme.

I didn't think it's a good video. If Microsoft s latest apps don't have a consistent design, they have spent more money on designing each of them separately. Each of those hover effects and custom title bars needed to be coded separately. That undermines the idea that MS "hasn't prioritised spending on design because it won't help their enterprise customers" and shows it's just an organisational problem.

> This hasn’t been consistent since at least Vista and the release of WPF, which does totally custom control rendering. Circa 2006.

Ignoring 3rd party apps, to me the windows UI died with XP where the consistency stopped being somewhat pushed on the base OS/UX itself.

Strictly speaking nobody cares what APIs are being used or if there are multiple of them as long as they convey a consistent UX. If a consistent UX is pushed on a system level, even custom apps will try to stick to it (see macos).

But the sad truth is that on windows there is no longer one. W10 can show you dialogs from the windows 3.1 style up to a WPA, and you'll likely encounter a mixture all the time because there's no consistency.

I sometimes watch retro hw channels and looking at windows from 3 to 2k reminds me the stark difference.

Office is using web technologies because they don't want to rewrite their code for Office 365, so native users get the Web stuff on a Web widget instead of a proper native UI.

Which is kind of tragic, given how Office was the testing ground for many Windows UI components.

What are you even talking about the only non native app in the office package is teams…

https://www.office.com/

https://learn.microsoft.com/en-us/javascript/api/office-ui-f...

????? Nobody is saying that there aren’t webviews in office I am saying that your statement that most of the desktop office ui is now non native is false and misleading. After reading your other comments in the thread it seems like more of a personal vendetta than factual statements. lmao

Nope, you're the one interpreting that way, I only mentioned that they are adopting Web stuff as means to reduce code duplication between Web and desktop, via Webviews exactly.

So unless you're on the Office team and want to tell us anything, please do lmao.

Who cares if it just works? Who cars if it's made in Flash or in COBOL when it just works? What's sad about this? It just works right?

That's the problem: it does not work. I don't care if the programm is written in assembly or in rust as long as it functions properly. But when the blinking cursor stops blinking, when the scrollbar or window border is so thin that i cannot select it with a mouse, when the title bar is so cluttered with buttons that any click brings up a menu instead of being able to double click or click and hold, then _it matters_.

I stop here in order to not throw profanity at MS engineers.

This is evidenced by the layers of settings UIs in modern windows from old school systems properties dialog to newfangled display settings, and in between. It is horrible. They just bundle these UIs atop one another there is no overall usability oversight.

> Even Office and Visual Studio (not Code) are using web technologies to render substantial parts of the UI.

Any more details on what web technologies are being used in Visual Studio and what parts of the UI are done with web?

The Diagnostic Tools window is implemented as a web view, probably since its introduction in… VS2017?. I’m not aware of any other GUI parts implemented using web technologies.

Node.js processes are invisible backend stuff.

This is what I was thinking of. Kind of a telling statement of Microsoft’s perception of WPF when they turn to WebView2 to render newer parts of the UI in their WPF app (which was never ported to WinRT, UWP, or WinUI). They didn’t even use XAML islands for the newer parts, they just jumped straight to web.

You just have to peek into what is running as child process from VS, as node.exe instances.

Mostly related to Web stuff, Blazor or VSCode plugins that they are "porting" into VS.

> The problem: the web has a terrible UI toolkit for desktop apps. It has clickable links and basic forms, that's all

I think you're not giving credit to the best part about the web: CSS.

I've been programming GUIs with Java AWT, Swing, and Qt for years. Nothing comes close to CSS when it comes to defining layouts.

I also spent quite some time building desktop and mobile apps (5, maybe 6 years) and also more than 10 years of building web apps and don’t really share this sentiment.

My feeling is exactly opposite. CSS is messy and hacky way to build layouts (the famous “how to center a div”, etc.) while with UI toolkits it tends to be much more straightforward and standardized.

(Edit: fixed a typo)

When is the last time you used CSS? "How to center a div" has not been an issue with CSS for many, many years. Flexbox and now CSS Grid have overwhelming adoption and most layouts can be achieved with a few lines of CSS.

> When is the last time you used CSS? "How to center a div" has not been an issue with CSS for many, many years. Flexbox and now CSS Grid have overwhelming adoption and most layouts can be achieved with a few lines of CSS.

The html-apps-as-a-local-app (like electron-based stuff) became popular prior to "how to centre a div" was answered.

IOW, they became popular in spite of having shitty layouts specifications.

Flexbox predates electron let alone electron being popular.

Firefox is not a good example of good (G)UI. It was at the beginning until they started copying Chrome.

Before flex and grid CSS had most complex, least friendly and (probably) least powerful layout definition system compared to everything I knew. Creating unecessary elements just to trigger primitive CSS mechanisms was commonplace as was having >3 methods to do some primitive layout task (like centering) depending on where that task was needed. Tables were popular so long because you could do 80% of what CSS could do while knowing <10% of what was needed to do layout without them.

After flex and grid it is just most complex and least friendly. You still need to know all the gotchas if you work with legacy projects or with imported components, but at least there are some sane ways to do basic layout tasks.

For me still nothing beats Adobe Flex when it comes to layout. Without much experience I could easily create UI that looked and behaved good without any resizing problems (although as I remember mobile phones were never supported).

Adobe Flex is one of those things that while I really enjoyed it, Adobe just isn't a good steward of projects/products like it. I do wonder what it would be like if some other large tech company either invented, or took it over.

Flex could be used on mobile through Adobe AIR, but it was slow, and felt all kinds of wrong. This was one of the downsides to Flex, too, in my experience.

I don't know I tried to understand CSS many times but never managed to get it: I'm a backend developer nowadays.

Deep understanding of css can take years. But understanding boxmodel, flexbox and grid won't take long and is enough for must use cases.

Swing Layout managers, XAML styles and control templates, QML.

You can use CSS with JavaFX.

What are these common controls?

Looking at this list: https://learn.microsoft.com/en-us/windows/win32/controls/ind...

Animation -> video tag

Button -> button tag

Combobox -> select tag

Date picker -> input type=date

Time picker -> input type=time

Edit -> input type=text or textarea

Scroll bar -> Not needed, automatic

Hot Key -> WAT?

IP Address Control -> Is this really so common it needs a custom box? does it handle IPV6?

List Box -> Not sure but making a list you can scroll through is trivial in HTML. you set a height of the container and mark it as overflow: auto. Done.

Pager -> seems irrelevant on a browser

Progress Bar -> progress tag

Property Sheet -> N/A

Rich Edit -> This was never good on Windows and it's also not good in HTML. In both cases if you want something that actually has a good UX you have to roll your own or find a library

Rebar -> Flexbox/Grid

Static Control -> most of HTML and far more easier to style

SysLink -> anchor tag

Tab -> trivial to implement in HTML but ok, maybe should be standardized?

Task Dialog -> dialog tag

Track Bar -> input type=range

Tree View -> You can do this with nested detail tags. Not sure it's any more work (in fact I suspect less) than a tree view in C++

Up/Down Control -> input type="number"

It seems all there are far more flexible.

I don't really know which apps you're referring to but I feel like most of the windows apps I use are not using those default controls or if they are they've added heavy customization

I'd see the one control missing most is menus

It means that you've never really developed an actual app. And that you haven't ever thought about all the controls and layouts (with their complex interactions) even in the apps you use daily.

No. Menu isn't "the one control". Menu is one of multitude of controls. Go ahead and try and implement a treeview correctly with nested details (including all the necessary keyboard interactions). Meanwhile treeviews have been a part of native UI kits since... the 80s perhaps?

Oh, and since listviews are so "easy" in HTML, can I finally properly animate adding elements to one or removing elements? With height:auto? And without needing to redraw and re-layout the entire page? Right...

Dialog tag? Does it keep keyboard focus inside the dialog, or do you have to write non-trivial amounts of JS to have this required accessibility feature?

And so on and so forth.

And those are just the most trivial things native UIs solved half a century ago.

> And those are just the most trivial things native UIs solved half a century ago.

My favourite: A window with 1 (only one) input field which is not focused by default. Why ? Why do i have to click and type instead of only typing ?

>List Box -> Not sure but making a list you can scroll through is trivial in HTML. you set a height of the container and mark it as overflow: auto. Done.

As long as your list doesn't contain elements that are too complex, or has too many elements. Otherwise, you enter the world of lists with recycled items, and while Win32 and pretty much every other toolkit has it by default, and oh boy does the web suck at that.

Recently I needed to work with low-level Windows API and default controls. The experience was horrible.

Windows GUI API after 30 years still does not provide any kind of a layout manager forcing to position everything manually on size changes.

A trivial-sounding task like background image beneath controls required days of tries and many lines of code that looked like Voodoo practice than any rational programming.

Then the code uses a custom title-bar that was necessary to update to support Windows 11 snap layout menu. It turned out in the initial release of Windows 11 it was impossible to get that and rounded corners around the application window. Windows relied on undocumented heuristics to infer the desired behavior and if their guess was wrong, one is out of luck. At least Microsoft added API to fix that in a later Windows 11 update.

So it is not surprising that many applications just gave up on that and use WebUI. At least that works much more reliably and in the worst case one can look at the source code.

I think you're not being very fair when it comes to web apps; I think they're a much lower barrier to entry in these days than native applications, especially if you want to target developers who will demand Windows, MacOS and Linux apps from day 0. There are no good cross-platform alternatives out there, with as big a pool of developers or as big an ecosystem.

I mean webapps suck, cross-platform mobile apps suck, and native apps on both desktop and mobile are vastly superior and I will die on that hill. But I understand the tradeoff.

> I think they're a much lower barrier to entry in these days than native applications, especially if you want to target developers who will demand Windows, MacOS and Linux apps from day 0.

Let's be honest, we had multiplatform apps well before desktop-web apps. We are in this situation because GAFAMs pushed very hard the paradigm of always connected web applications (because they had no control over applications running solely on your computer). And since they won this ideological battle, there is not any more investment on multiplatform toolkits.

I really think that all of this is due to political reasons and it have never been about the superiority of the web technologies.

HTML+CSS started as basically a desktop publishing technology, but that's not the case anymore. There's fantastic support nowadays for building app experiences, from the perspective of layout and interactivity. Fair point on system-wide customization, although I really don't miss it. Maybe it's the experience of the web, but it no longer seems weird to me that apps have different design paradigms. But realistically, desktop hasn't had unified design since Java applications started becoming popular 20 years ago.

> There's fantastic support nowadays for building app experiences, from the perspective of layout and interactivity.

As long as you, you know, do no complex layouts or interactivity.

It's still a system for displaying static text documents, and no amount of lipstick can change that without re-doing the entire thing.

If you think it's not the case, animate adding a height:auto element to a list without the browser needing to re-layout and redraw the entire page

Reply on news.ycombinator.com