My prediction is that within the next 5 years the following will be true:
Projects will drop Wayland support and go back to X11
There will be a new display protocol that displaces both X11 and Wayland
The new display protocol will be a drop-in replacement (similar to XWayland)
Fragmentation will still be an issue (this one's a freebie)
There's also 5. the protocol will eventually converge to a structure where the compositor is abstracted away from front-facing user functionality, because separation between mechanism (graphics and input pipeline) and policy (window, clipboard, drag'n'drop, input shaping) is kind of the natural outcome of any engineering process at this level. See e.g. wayback (which keeps the old mechanism, not policy layer working), or river (which offers an alternative mechanism, not policy framework).
If you squint a little, that's what's happening within Kwin, too, with its rich scriptable interface, except the separation isn't as clear there because less of it is exported up. I wouldn't be surprised if Mutter did something like that under the hood.
I've had this feeling since Kubernetes came out. I'm over tech. I'm learning a new career and slowly making the transition into art. I know it won't pay the same but the work is so much more fulfilling.
Why does Google think that it is on them to make this trade-off? Do you think they care about scammers at all? (please go watch a dozen ads on YouTube and count how many are for obvious scams before answering)
I really, truly struggle to understand posts like this. I've been daily-driving GNOME + Wayland since about 2018 and I can count the number of problems I've experienced that I can attribute to that setup on one hand. I can appreciate that the specific issue of accessibility tools is more complicated and has a lot of subtle cases I'm likely not hitting, but presumably not all complaints are driven by that demographic. I genuinely want to know how people keep finding problems: would I experience more issues if I weren't using GNOME? Would using a Nvidia GPU help me see them?
The ui lines were all standard text characters, etc. there’s work for the state management for menus, but other than that there is not a whole lot to do in order to display the text
Basically every normal person I know that 's used Linux and isn't trying to run some leet hacker setup with a special tiling wm doesn't even know that Wayland exists.
I think "lucky few who happen to have the hardware and workflows that happen to work" is doing some very presumptuous lifting lol.
the fact you had to define your functions before you could use them was not something I was used to at the time
That was, fwiw, a limitation defined by the language, not by TP3 itself. Pascal was designed to allow for "single pass" compilation, and this was one of the ways Wirth did that. Later on other implementations made the ordering requirement optional or just didn't enforce it, but I believe all other contemporary pascal compilers (at least for 8-bit machines) had the same limitation.
In fact, the entire program had to be in a single file, since TP3 did no linking.
Believe it or not, this was also a pascal limitation, but one that other compilers had already expanded on. UCSD Pascal was the big player here, and it allowed for multi-file projects. TurboPascal started supporting UCSD's method some time after TP3.
Making the eval look natural will be the challenge for attackers, but it's definitely not impossible.
Depends on the maintainer I guess, but like ... if a patch contains eval, I'm rejecting it unless it's literally part of a REPL/compiler or dev-time tooling. There is simply no excuse in a web library.
There is a fundamental conflict between sandboxing everything and the power and convenience we get from open systems. Sure, we can manage permissions at the finest granularity, providing great security guarantees, but then suddenly everything becomes super tedious. I have yet to see any solution that resolves this conflict properly for power users who like control. For example, efforts to sandbox applications in flatpak and snap simply break stuff like drag & drop, file access and so on. At the end of the day, there's just a lot of breakage across the board and it gets really annoying really quickly on the desktop. All of these problems can be fixed given enough time, but I don't have enough time. If I have a system that works, I will not accept a replacement that does not work but gives me higher security. If I want a perfectly secure system that does nothing, I can replace my desktop PC with a cube of wood.
The Rust compiler has a surprisingly comprehensive set of lints for detecting that kind of thing (thanks Manish!), including one that account for how likely is a, for example, Cyrillic e to be in an identifier given the other chars. Mixing and matching between different scripts that don't go together gets flagged. You can deny non-ascii in general but that is opt-in. GitHub already lints against the Trojan source RTL codepoints, that machinery could be extended to all of these cases too.
Wayland being pushed into prime time so quickly? Quick isn't the work i would describe it. Give that it felt quick means that it doesn't matter when it would be pushed problems would be inevitable and people would consider it "too quick"
I am not sure how to find any authoritative statements about motivation
That's fine. For a lot of these things it is always a matter of online archeology to figure things out, and maybe publishing a page with the result of the research for future people asking the same question.
Thank you for the context you provided, that's actually useful in understanding the evolution and points towards an environment when these decisions were made similar yo what I expected.
One way to generalize it is the incremental mean. The overflow-safe mean is the incremental mean of two values.
m[1] = x[1]
m[i] = m[i-1] + (x[i] - m[i-1]) / i
The incremental mean is good for numerical stability, and it’s the best choice for floating point (without the complexity of Kahan summation).
For integer arithmetic you’ll want something else, depending on the number of values and the headroom in the integer type (and therefore the risk of overflow in an intermediate value). If the number of values is a power of two then you can average them pairwise to avoid overflow, but that’s probably rare enough to be irrelevant.
A lot of modern GUIs have worse discoverability! Every other settings menu is deeply nested with absolutely nonsensical categories, that of course, never match between apps.
Meanwhile the terminal shell has consistently available help, and and absolutely blessed levels of smart completion. Hell, most TUIs let you click buttons using the mouse.
There's also 5. the protocol will eventually converge to a structure where the compositor is abstracted away from front-facing user functionality, because separation between mechanism (graphics and input pipeline) and policy (window, clipboard, drag'n'drop, input shaping) is kind of the natural outcome of any engineering process at this level. See e.g. wayback (which keeps the old mechanism, not policy layer working), or river (which offers an alternative mechanism, not policy framework).
If you squint a little, that's what's happening within Kwin, too, with its rich scriptable interface, except the separation isn't as clear there because less of it is exported up. I wouldn't be surprised if Mutter did something like that under the hood.
I've had this feeling since Kubernetes came out. I'm over tech. I'm learning a new career and slowly making the transition into art. I know it won't pay the same but the work is so much more fulfilling.
Why does Google think that it is on them to make this trade-off? Do you think they care about scammers at all? (please go watch a dozen ads on YouTube and count how many are for obvious scams before answering)
Because I'll get fired otherwise
I really, truly struggle to understand posts like this. I've been daily-driving GNOME + Wayland since about 2018 and I can count the number of problems I've experienced that I can attribute to that setup on one hand. I can appreciate that the specific issue of accessibility tools is more complicated and has a lot of subtle cases I'm likely not hitting, but presumably not all complaints are driven by that demographic. I genuinely want to know how people keep finding problems: would I experience more issues if I weren't using GNOME? Would using a Nvidia GPU help me see them?
The ui lines were all standard text characters, etc. there’s work for the state management for menus, but other than that there is not a whole lot to do in order to display the text
Basically every normal person I know that 's used Linux and isn't trying to run some leet hacker setup with a special tiling wm doesn't even know that Wayland exists.
I think "lucky few who happen to have the hardware and workflows that happen to work" is doing some very presumptuous lifting lol.
That was, fwiw, a limitation defined by the language, not by TP3 itself. Pascal was designed to allow for "single pass" compilation, and this was one of the ways Wirth did that. Later on other implementations made the ordering requirement optional or just didn't enforce it, but I believe all other contemporary pascal compilers (at least for 8-bit machines) had the same limitation.
Believe it or not, this was also a pascal limitation, but one that other compilers had already expanded on. UCSD Pascal was the big player here, and it allowed for multi-file projects. TurboPascal started supporting UCSD's method some time after TP3.
Depends on the maintainer I guess, but like ... if a patch contains eval, I'm rejecting it unless it's literally part of a REPL/compiler or dev-time tooling. There is simply no excuse in a web library.
There is a fundamental conflict between sandboxing everything and the power and convenience we get from open systems. Sure, we can manage permissions at the finest granularity, providing great security guarantees, but then suddenly everything becomes super tedious. I have yet to see any solution that resolves this conflict properly for power users who like control. For example, efforts to sandbox applications in flatpak and snap simply break stuff like drag & drop, file access and so on. At the end of the day, there's just a lot of breakage across the board and it gets really annoying really quickly on the desktop. All of these problems can be fixed given enough time, but I don't have enough time. If I have a system that works, I will not accept a replacement that does not work but gives me higher security. If I want a perfectly secure system that does nothing, I can replace my desktop PC with a cube of wood.
The Rust compiler has a surprisingly comprehensive set of lints for detecting that kind of thing (thanks Manish!), including one that account for how likely is a, for example, Cyrillic e to be in an identifier given the other chars. Mixing and matching between different scripts that don't go together gets flagged. You can deny non-ascii in general but that is opt-in. GitHub already lints against the Trojan source RTL codepoints, that machinery could be extended to all of these cases too.
Finally moving off of GitHub Pages, probably to grebedoc.dev or pgs.sh.
Open to other suggestions! (I looked at SourceHut Pages, Codeberg Pages, and NearlyFreeSpeech.net, as well as just running a cheap VPS.)
I thought it was interesting. 🤷♂️
Just out of curiosity, what editor are you referring to?
well, that still is a criticism of Wayland.
Wayland being pushed into prime time so quickly? Quick isn't the work i would describe it. Give that it felt quick means that it doesn't matter when it would be pushed problems would be inevitable and people would consider it "too quick"
That's fine. For a lot of these things it is always a matter of online archeology to figure things out, and maybe publishing a page with the result of the research for future people asking the same question.
Thank you for the context you provided, that's actually useful in understanding the evolution and points towards an environment when these decisions were made similar yo what I expected.
Maybe :-)
One way to generalize it is the incremental mean. The overflow-safe mean is the incremental mean of two values.
The incremental mean is good for numerical stability, and it’s the best choice for floating point (without the complexity of Kahan summation).
For integer arithmetic you’ll want something else, depending on the number of values and the headroom in the integer type (and therefore the risk of overflow in an intermediate value). If the number of values is a power of two then you can average them pairwise to avoid overflow, but that’s probably rare enough to be irrelevant.
A lot of modern GUIs have worse discoverability! Every other settings menu is deeply nested with absolutely nonsensical categories, that of course, never match between apps.
Meanwhile the terminal shell has consistently available help, and and absolutely blessed levels of smart completion. Hell, most TUIs let you click buttons using the mouse.
Given the project owner's... controversy, I'd be very surprised if it ever gets major adoption.