Hacker Newsnew | past | comments | ask | show | jobs | submit | more BiteCode_dev's commentslogin

Oh yes, the problem are the ads.

Even subtitle ads break your focus from the content, give bad incentives, unfair leverage, etc.

If ads were not here, most junk content in the internet would not exist because people would not pay 20 cents to see it. They pay to see it with ads, because it's a price they don't pay consciously, nor can they assess the consequences clearly.

I'm for the total and complete ban of ads. A content can't exist without it? Ask people to pay. If they don't, it means it didn't have real value. Let it die.

Worse, ads create a huge asymmetry of power in the favor of those who already have it. If you can throw a lot of money to ads, you can gain on the competition. Local small shops can't do that, so ads promotes way more coca cola than organic carrots.

Besides, the people publishing ads have an agenda that almost never align with the customers interest. People say there are ads they want to see, but the reality is that even those ads are not trying to make you more knowledgeable. They try to sell you something.

We have thousands of communities of experts in stuff, testers, consumers, bloggers, than can inform you. You don't need ads to know about something.

Society as a whole would be better without it.

Newspaper would be more objective, streets would be more beautiful, content would be more qualitative.

What about all those youtubers that couldn't exist without ads ?

99.99999% of them are crap. The youtube frontpage is a trash can.

A minority is good, but in the new adsless society, some of them would survive in a different way. Some would not, but the benefits are more important. Just like the US didn't keep thralls because "think of the economy".

Finally, the ads lead to websites to promote engagement at all cost, which fuels fake news, outrages, and tribalism on social medias. Ads are a burden to the human species.

And I say that... as a person who gets a lot of revenue from ads.


> Because let’s say it, everybody loves YAML. YAML is everywhere.

Nope. Nope, nope, nope.

I know a lot of people, including myself, who hates YAML with a passion.

First, they hate the format itself. It's very easy to introduce hard-to-find typos. Plus it has multiple versions, no way to tell which one you use, and depending of the parser that ends up eating the file, you may get weird results. It's way worse then just the "Norway problem". Typically, a bad monday morning could look like this:

    >>> import yaml
    >>> yaml.safe_load(''' 
        port_mappings: 3333:33
        alternative_port_mapping: 3333:33,
        countries: [FR, US, UK, NO, IT] 
        1 : 1,0
        2: 01
        3: 1.0
        4: 1O
        5: 0b1
        6: 0x1
        7: 0i1
        8: hey,
        8.0: oh,
        version: [3.1, "3.1", 3.10, "3.10"]
    ''')

Which may turn into this:

    {
        'port_mappings': 200013,
        'alternative_port_mapping': '3333:33,',
        'countries': ['FR', 'US', 'UK', False, 'IT'],
        1: '1,0',
        2: 1,
        3: 1.0,
        4: '1O',
        5: 1,
        6: 1,
        7: '0i1',
        8: 'oh,',
        'version': [3.1, '3.1', 3.1, '3.10']
    }
It's a terrible, terrible format, that has too much variability, and way too many foot guns. Especially since typo-writing humans are supposed to edit those with their little clumsy hands.

But worse, YAML is mostly declarative, so no complex system can be described in it. Here we come to the second reason people may hate it: it's usually turned into an even worse DSL.

A very limited, badly designed, half documented and tested DSL with almost no tooling to write or debug the stuff. And each project has a different DSL, of course.

Take Ansible. If your playbook is more than 10 lines, it becomes a pain to write because you are basically using a programming language embedded into a markup language. You have no print() or breakpoint to dive into the mess it does. It has to reinvent ways to pass values around since there are no functions with references to parameters nor return values.

Mind you, this DSL calls Python under the hood, so they could have just exposed a declarative, idempotent Python API, but no. The entire world was required to recreate syntax highlighting, snippets, go-to-definition and so on for it. Which will never be good compared to the infra for real languages.

There are few reasons to decide to use YAML, apart from "this is the only rich format supported out of the box by this system that has comments". Which I totally get, but still.

If one can, use JSON, TOML or XML depending of the case, if we need only values.

And if we need more than values, let's either define a clean, restricted API with a full blown programming language, or, if the use case requires it, use CUELang (https://cuelang.org/).

CUELang is cleaner than YAML on all points, even for just data. It can provide a schema, can validate the data with that schema. It can embed logic. It can import and export from YAML and JSON so you stay compatible with the entire devops world.

And it's not Turing complete, but has useful constructs to repeat, branch and reuse code.


> Nope. Nope, nope, nope.

Maybe it's just me, but I read this as a joke. As much as we dislike YAML it's not really something we have the luxury of ignoring, especially in the infrastructure field.


Cluelang is a DSL which I already considered and that I like very much. It wasn't high enough in my priorities.

I struggled to use the HCL.

The DSL used by updatecli is not fixed in stone. It's just the interface exposed. The reality nowadays, is that YAML remains the most used DSL.


To add on top this. I started by supporting other DSL such as Json. Then I realized it was adding burden on me in terms of documentation since people would ask me for different examples.


Use a jsonschema, and validate your configs. You can have similar problems with most other formats, and the best way to make sure your configs are going to do what you expect, is to validate them.


Another yaml problem is that it can have both .yaml and .yml extensions and some tools choose to support only one


updatecli supports both


Like anything new, people had a hard time with it at the beginning.

I remember that I got a home assignment in an interview for a PHP job. The person evaluating my code said I should not have used UTF8, which causes "compatibility problems". At the time, I didn't know better, and I answered that no, it was explicitly created to solve compatibility problems, and that they just didn't understand how to deal with encoding properly.

Needing-less to say, I didn't get the job :)

Same with Python 2 code. So many people, when migrating to Python 3, suddenly though python 3 encoding management was broken, since it was raising so many UnicodeDecodingError.

Only much later people realize the huge number of programs that couldn't deal with non ASCII characters in file paths, html attributes or user names, because they just implicitly assume ASCII. "My code used to work fine", they said. But it worked fine on their machine, set to an english locale, tested only using ascii plain text files on their ascii named directories with their ascii last name.


That's in general a problem with dynamic languages with weak type systems. How "Your code runs without crashing" is really really != "your code works". How do people even manage production python! A bug could be lurking anywhere, undetected until it's actually run. Whereas in a compiled language with a strong type system, "your code compiles" is much closer to "your code is correct".


I don't think a type system can help you with decoding a file with the wrong charset.


A type system can refuse to turn a `bytes` into a `utf8str` until it's been appropriately parsed.

(It doesn't even need to be a very good or strongly-enforced type system - Go makes it dangerously easy to convert between `[]byte` and `string` by other-type-system standards, and yet everything works pretty well. It's enough to hitch your thinking and make you realize you need another step.)


How does the type system knows the bytes are utf8 and not CP850?


The same way you can parse a string into an integer and it knows you got an either[integer, err].


So it doesn't, and it's not about the type system. Any decode operation in python 3 raise an exception or return string.

It's about the runtime error handling making it mandatory to deal with the error and won't let you panic at run time for this specific error.


I'm sorry you don't see exceptions as part of a type system yet.


The compiler can raise a warning about bad characters. It can't detect all problems, but it certainly can help with some.

It's not the type system, but many dynamic languages are interpreted instead of compiled.


Those bad characters are fed into the program long long after the compiler has done its job.


Not necessarily? I'm talking about constant string literals in source code which can be validated at compile time.


But this is not a matter of UTF-8 in the code, rather a matter of UTF-8 in the input or output. How does compiling a program ensure that it is robust on a range of inputs?


> How does compiling a program ensure that it is robust on a range of inputs?

This is quite literally the job of a type system: to impose a semantic interpretation on sequences of "raw bits" and let you specify legal (and only legal) operations in terms of the semantic interpretation rather than the bits.


There are a number of mitigations, so those kind of bugs are quite rare. In our large code base, about 98% of bugs we find are of the "we need to handle another case" variety. Pyflakes quickly finds typos which eliminates most of the rest.


This is the difference between people who embrace static typing and everyone else. A static type lover hears that 98% of your bugs are of the "we need to handle another case" variety and says, "well, that means you could have gotten rid of 98% of your bugs with better typing".


No, what I mean is that an additional key comes in (with the json or similar hash) and we now need to do some thing with it, or something different than we thought we were supposed to with it. Typing is not going to fix it because the full cases were unknown at development time.


> "your code compiles" is much closer to "your code is correct".

That is so far from the truth.


How is it anything but the truth? The express purpose of static analysis, like a type system, is to catch bugs before running your code. That pretty clearly means that code that successfully compiles is closer to being correct than code that doesn't.


I mean, correct as in logically correct and that's just a different matter than being grammatically correct.


The parser assures your code is grammatically correct; the type system assures your code is semantically consistent, which is usually a much stronger guarantee, and by most practical measures will be closer - often much closer, and for total functions on total types, sometimes all the way - to "logically correct".


Python 3 encoding management was broken, because it tried to impose Unicode semantics on things that were actually byte streams. For anyone actually correctly handling encodings in Python 2 it was awful because suddenly the language runtime was hiding half the data you needed.


Nowadays, passing bytes to any os function returns bytes objects, not unicode. You'll get string if you pass string objects though, and they will be using utf8 surrogate escaping.


And nowadays, lots of people left the Python ecosystem completely because the 3 upgrade was broken and raising so many UnicodeDecodingErrors for so long. I'm glad it's fixed but it cost too much.

(And it had nothing to do with UTF-8. Actually, it's at least partially caused by the CPython developers avoiding UTF-8 for poor reasons.)


I'd argue that the people correctly handling encodings in Python 2 were vastly outnumbered by the people that weren't, but were getting away with it because the code didn't outright crash. Now in Python 3 it crashes, which is a pain in the short term but better in the long run.


I don't really think it's better - certainly it was not better until many years after release when they started admitting their big mistakes.

But even today, codepoint indexing is too easy and doesn't crash so lots of code is still subtly wrong. Memory usage of a string grows 3x if you add a single emoji. Most libraries are still agnostic about whether they take bytes or str so you still get exceptions thrown with no easy solution. (The growing popularity of type hints is fixing this, but that's not really related to Python 3.)


My Slack name at work is "Τĥιs ñåmè įß ą váĺîδ POSIX paτĥ". My hope is that it serves as an amusing reminder to consider things like spaces and non-ASCII characters.


One of my friends is these days a colleague, with an utterly ordinary English name but his identity management data is full of spurious accents to check APIs do the Right Thing™.

I was delighted recently to stumble on a history of modern women course HIST1158 named Liberté Egalité Beyoncé and I immediately thought two things: 1. Why are our Computer Science courses given unimaginative names? and 2. What a useful test input, I bet some of our systems don't work correctly for this input even though an acute accent is hardly a bleeding edge feature.

I haven't been able to interest any Computer Science professors in fun names for their courses, but I was able in my test environment to name a COMP series course "Untitled Course Name" with a description explaining that "It is a lovely day in the village and there are only two hard problems in Computer Science".


>only two hard problems in Computer Science".

You mean cache invalidation and naming things? :)


And off-by-one errors.


2 just means that the counter overflowed.


Much too trivial. Not even an RTL marker? How about some of the more exotic blank steps? There are some interesting combining characters too!


yapf is configurable, and that's why it never won.


What's wrong with configurable? Too much opportunity to bikeshed?

I figured yapf was not "new" which is why black won.

Starting about 5-6 years ago there was a push in the Python community to replace solved problems with new ones in what appears to me as chasing the JavaScript community.

Instead of consolidating on existing tools that worked well but had some rough edges to smooth out, numerous projects came about to reinvent the wheel.


There is no "best format". It's a matter of opinion.

Taste is something we cannot objectively agree, and in fact, people will end up arguing even about this very statement, offering what they think is an objective measure.

Bikesheding, yes. Hours lost in meeting, chat debates, documentation to write, linting configuration. To be redone for each project, team, etc. Worse even in FOSS where everybody will come in a ticket and complain. And after while, you do it again, because the debate is never settle even in the same team or project.

There is not way to take a team of 3 people, choose a style, and make it so that they are all 100% happy with it.

Black took the road of gofmt: you can't chose. And it won because of that: it saved people time and energy.

People realize the cost was not worth the satisfaction, which you are unlikely to get anyway. Let's just move on to what matters, it's good enough. Pareto.


> Bikesheding, yes. Hours lost in meeting, chat debates, documentation to write, linting configuration

Sounds like a team problem, I've been on plenty of teams that use clang-format for c/c++ and there have never been any issues like this. Team players know that (almost all) arguing over formatting is not a good use of time. (edit: in case not clear, clang-format is extremely configurable. Set a default config and live with it forever, that's how those teams work.)

> Black took the road of gofmt: you can't chose. And it won because of that: it saved people time and energy.

I don't see how this follows, if a team was dysfunctional enough to be wasting hours and hours of time before, I can't imagine why that wouldn't continue. It just shifts from "let's change this flag in yapf" to "let's switch to yapf because black looks ugly and gives us no options".


> Sounds like a team problem,

You had a good team. I had a great mum. Some people have great doctors.

> It just shifts from "let's change this flag in yapf" to "let's switch to yapf because black looks ugly and gives us no options".

If the practice doesn't match the theory, I'd rather trust the practice.


Well if it helps your team out then that's great, I just wouldn't expect that to generalize well. But who knows, people are weird, maybe more would give up fighting about style because of a tool change than I expect.


I don't have one team, I'm a freelancer, I meet 2 teams each month. I have a large sample to generalize from.


All problems are team problems. It's OK to use technical solutions to get around them.


> Too much opportunity to bikeshed?

Yes, and also too hard to set up. It's extremely dumb, but I'm much more likely to use something I can't configure, because if I can configure it, I'm going to want to, and it'll take forever to make all those choices.


I've never had to configure yapf, even though I could...

"yapf -i --style=pep8" works great.


Very interesting, especially the method order part. I dislike the order you chose, and yet, I would be tempted to use it on my projects anyway, because being congruent is so important to me.


This is about how I initially felt with black. I didn't like some of the things it did, but I was happy to have a standardized opinionated formatter so I went with it. Was definitely the right decision.


A standard no one likes is often better than no standard at all.


It’s an unfortunate compromise with code formatters. As someone who takes code formatting really serious and puts a lot of manual thought into code formatting, code formatters almost always make my code worse, in my opinion, or at best unchanged outside of small errors like double spaces, etc. But it creates a standard that it loves everyone’s code towards, which is good., and also obviously alleviates the chore of manually formatting.

I just wish sometimes they were more configurable. For example, the Elixir formatter is quite opinionated on things but is generally not configurable.


I often wish they were _less_ configurable. Even Black's handful of config options are too many... Each one is a chance to pick a whole new color for the bikeshed.


That makes sense, but it's a problem when the formatter makes a rather opinionated choice and doesn't allow one to configure it. The primary example I'm thinking of in Elixir is comments for pipelines.

For example, if I use the pipe example on Elixir's landing page and add comments to it (obviously a contrived example):

    "Elixir"              # string to get frequencies for
    |> String.graphemes() # Get all graphemes (i.e., character units)
    |> Enum.frequencies() # Get the number of occurrences of each grapheme
This gets formatted by the Elixir formatter to:

    # string to get frequencies for
    "Elixir"
    # Get all graphemes (i.e., character units)
    |> String.graphemes()
    # Get the number of occurrences of each grapheme
    |> Enum.frequencies()
This is a rather strongly opinionated format stance, and as far as I know, it's not configurable.


Since I'm dreading the coming of a cashless society, I'm really rooting for the German to push back against it as long as they can so that I can keep using notes and coins in euros.


I really hope wayland doesn't become to x11 what IPV6 is to ipv4.

Because after so many years, a lot of the ecosystem hasn't moved, or is even not compatible with it. Good multi display support is missing, and some games don't render well.

I want it to succeed, and the project has been progressing non-stop, but it does show how much time and energy such an endeavor takes. I was expecting to be able to use it for years and years.

See also: BTRFS


I don’t think Wayland will fail. I’ve been running it for about a year now (since Fedora 34). It’s been mostly smooth sailing, and a big quality of life improvement, with only a few drawbacks. (Screensharing does not work for all windows, such as my terminal.)


Could you explain the benefits of switching to Wayland that you experienced?


- Top quality high and mixed resolution support.

- Tear free rendering and capturing.

- (Small) improved performance.

- Games are much better behaved. I can reliably window, maximize and full-screen them. They also never mess with the display resolution.

- Seems to have less windows (especially hover tool tips) just hanging around. I guess the compositor can close these at the right time under Wayland.

- Proper secure screen locking. (I think GNOME + GDM can do something safe on X but most display managers + lock screens can't cooperate well enough to manage this.)

Honestly it is nothing major (except the mixed dpi stuff) but a nice step up. And if the X devs say that X is unmaintainable and this is going to lead to many improvements and be able to be maintained for the next age of displays on Linux I'm happy to make the switch now that it is the default and I am not aware of any problems for my workflow.


Thanks, I get all the arguments from the developers and that it should be better in principle in the long run. But I need screen sharing, screen shots, and of course xsnow ;-)


Screen sharing and screenshots have been working perfectly for me (in fact screenshots are actually better with multi-monitors than X because they don't mess up the off-screen space). No comment about xsnow ;)

I think screenshots work out-of the box for most compositors and screenshot tools but depending on your distro you may need to configure xdg-desktop-portal for screen recording. On my distro (NixOS) this seems to work on GNOME with no additional config.

For NixOS configuring GNOME which uses Wayland by default (if your GPU supports it) is just:

    services.xserver = {
      enable = true;
      displayManager.gdm.enable = true;
      desktopManager.gnome.enable = true;
    };
I'm not aware of any major issues with this and in my experience provides a better experience than using X.


Mostly what the other commenter said. Smooth scrolling / no tearing, no weird visual glitches (like the big black rings around all windows when changing resolution or logging out), etc.


Yeah, I've been on Wayland and Sway for almost two years now. Screen sharing with Zoom was hit or miss for a while but is now relatively reliable (at least as much as Zoom is reliable). I can't really quantify anything, but it definitely feels like better performance and reliability than I used to get with Xorg (on a dual 4K monitor setup).


> but it does show how much time and energy such an endeavor takes.

The reason it takes so much time is not that is requires a lot of "energy" or that the problem in general is particular hard to solve. Wayland is fundamentally flawed at the concept level and the only way for it to get to a usable state is to turn it essentially into another X. Combine this with general stubbornness of all involved parties and the extreme hesitancy to standardize essential things you get a recipe for disaster.


What is flawed?

The difficulty arise from the complexity of the problems to solve.

In a x11 world, the assumption is that everything that a user runs is fully trusted, any software has access all the inputs, all the audio, everything that is displayed without any restriction. This wasn't a problem 30 years ago, but is quite a blocker for modern approach to security with granular permissions.

The architecture of x11 itself does not fit a modern graphical stack, some problem cannot be solved properly like monitors with different framerates, fractional scaling etc...

Wayland is just one part of the big efforts that are ongoing to address those issues. This impact the whole desktop ecosystem, it's a massive effort.

Wayland will replace X though indeed (coupled with other things) that's the intent.


> The difficulty arise from the complexity of the problems to solve.

What problems are those exactly? It's my impression that Wayland (the protocol) just creates problems without solving any.

> Wayland is just one part of the big efforts that are ongoing

Yes. The anti-user anti-general-purpose-computing anti-freedom efforts. Trying to create a world where device owners may use their devices only for a set of approved actions such as browsing Instagram and Tiktok. When someone speaks against it, they are attacked with FUD, and "security" is called upon. Does that remind you of anything?

Some relevant past comments:

https://news.ycombinator.com/item?id=26753902

https://news.ycombinator.com/item?id=26758783

https://news.ycombinator.com/item?id=24886074

https://news.ycombinator.com/item?id=26758945


None of those comments have an actual example. I still have no idea what you complain about, there's really not much difference between using gnome on wayland and gnome on X11 or Sway and I3. In the wayland counterparts though some of the security problems at the core of x11 have been addressed, and input and display just works better. There's no-one forcing you to do anything or forbiding you to do anything.


> there's really not much difference between using gnome on wayland and gnome on X11

Yes, looking just at big DEs there's not much difference. Consider, however, the problems Wayland causes for the ecosystem. Take screen grabbing programs or input event interceptors like xdotool. There's simply no way to implement one of those strictly on Wayland. Each Wayland compositor must be targeted separately instead.

This is discussed in some of the threads I linked to, BTW.


I get your confusion, there is one screenshot API that abstract the compositor but it lies in xdg-desktop: https://github.com/flatpak/xdg-desktop-portal/blob/master/da...

The portal for xdg-desktop takes care of the implementation and is the responsibility of the compositor.

It's already used by Flameshot for example.

There is several xdottool equivalent as well: https://github.com/atx/wtype https://github.com/ReimuNotMoe/ydotool

This one is specific to wlroot based compositor: https://git.sr.ht/~brocellous/wlrctl


Fragmentation galore, pretty sure you're actually reinforcing my point with these examples. Can one rely upon any of these hacks, extensions and third-party APIs working for all systems with a Wayland compositor? Some of these are compositor specific, and some are implemented independently of Wayland, but then of course depend on other stuff that's not universal.

The current ydotool goes in another direction, it tries to be independent of Wayland, but this also means it doesn't know your keyboard layout, making it less useful. It also requires a privileged daemon running on my system, something I wouldn't give to such an obscure project.

These problems don't even exist for X11 users because implementing such functionality is easy because it's supported by X.


That's just bad faith now, your definition of fragmentation does not match the dictionary one.


1. I say "There's simply no way to implement one of those strictly on Wayland.".

2. You respond by giving a bunch of examples that align with my statement, but you don't seem to realize this.

3. I clarify.

4. Suddenly I don't operate in good faith?!

What's worse, your replies attack straw versions of my comments: https://en.wikipedia.org/wiki/Straw_man

> a form of argument and an informal fallacy of having the impression of refuting an argument, whereas the real subject of the argument was not addressed or refuted, but instead replaced with a false one


Xdotool is just one of many tools for automation on x11, it's not part of xorg. There's also Xautomation, AutoKey and others. What's the difference? There is absolutly none. Where is there more fragmentation?

I'm not refuting anything you still haven't brought any argument at all :D


I’ve seen it so many times.. what is flawed with Wayland? Do you even have sufficient knowledge on the topic to have a fact-based opinion on it? Because 1) wayland is made by the very people who maintained X for decades, 2) it is a deliberately small-core protocol which is extensible - which allows future growth. That small core is quite easy and elegant, it can hardly be flawed, unless you have something concrete to say about that. It is pretty much “display this buffer of type X” and that’s it.


> what is flawed with Wayland?

The protocol doesn't support most essential features, leaving them up to "compositors" to implement mutually incompatibly. Screenshots, accessibility, etc.

Thus Wayland promotes fragmentation and death of the Linux desktop.

On top of not actually solving problems, the protocol manages to be too opinionated, forcing compositing on the user.


You're joking about 'forcing' right? There are so many decisions in modern operating systems that are not easy to change. Are you mad at Linux for 'forcing' you into 'rwx' filesystem security? Or 'forcing' you to use iptables for configuring your firewall?

Other desktop environments shifted to compositing 15 years or longer ago since it performs better on modern GPU's than the old 'damage check and repaint' algorithms. I don't think it's impossible to do that with Wayland, but since nobody tried to build that I think interest is very low.


Most X11 clients that had anything to gain from it also moved to bypassing the legacy X11 drawing primitives about a decade ago.


> Thus Wayland promotes fragmentation and death of the Linux desktop.

First of all, what is dead may never die. Second of all, no, it is false. The core protocol is indeed small (unix philosophy ain’t a good thing now for some reason I guess?), but the extensions are easily queriable and they undergo standardization if they are deemed useful. Would you prefer a single entity giving directions on what has to be included? That would seem pretty antithetical to the whole bazaar style of development.


This is what I don't get. Wayland seems not to have started with solving some of the X11 problems first but on a strong framework, it seems to just be reinventing the wheel and hoping to catch up and fix the problems somewhere along the way. So users just wait for that moment and X11 works 'fine' for the majority in the meantime.


Why do you say that? What even gives you the credentials to make a claim like that?


>What even gives you the credentials to make a claim like that?

This is a fallacy.


wtf? it's absolutely not, when making wild claims about the inner workings of a project in a field where very few people are competent.

If I start making wild claims about cardiology, you'd be correct to ask me for some credentials.


What credentials do I need to state and opinion on how it seems to have evolved? I'm not stating a scientific truth.

And yes, it is the fallacy of credentialism to attempt to use that as a measure of authority to make a statement. I could be a kernel developer of 20 years experience and have been terrible for all of them.


That's right - you're not stating a scientific truth, you're just stating falsehoods. It's pretty much enough to look at how any non-trivial X11 client looks like these days to understand the reason for Wayland's existence. Wayland, while not perfect, offers an incredibly clean and extendable design when compared to X11.

Whether the whole ecosystem is already in place to move regular users over is another matter (I'm developing a Wayland compositor at work and even I am still using X11 on my workstation), although with this kind of project I guess you just need to face the chicken-and-egg problem at some point to actually move things forward.


You just explained exactly what I assumed is going on. Great, Wayland has a bright extensible future, but right now it doesn't solve anything so special that common users (or distro owners) desire moving over, hence the low usage of Wayland.

Not a problem with Wayland, it's just as you say, not there yet.


BTRFS has stabilized outside of niche configurations like RAID5/6. With Wayland common hard- and software combos are still cause for lockups and the like. I can't get it to not crash an various bog standard all-Intel hardware, for no apparent reason. The internet is full of such (recent) reports.


> Good multi display support is missing

I'm using Gnome 40/Fedora 34 with laptop and attached 4K display. Gnome apps works absolutely fine. Some non-gnome apps do not re-scale when moved between displays and that's the only issue that I've found.

Also I run Factorio absolutely fine. No idea about other games, though.


btrfs is a drop-in replacement. Nothing changes for the user when they switch to it. With Wayland many basic features are missing even today. (Yes I know someone will explain here that everything works. Don't make me laugh)


BTRFS is a great solution to the problem of having data be accessible reliably. I've had issues with Wayland, and I've also had issues with X, but I've been using Gnome's Wayland session for 4 years now. More so than actual window manager issues, I've been experiencing issues with my GPU drivers. FOSS software has never been without it's operational issues. I don't understand what's up with this prejudice towards Wayland. You do understand, that it's the X developers themselves that advocated for Wayland (besides designing and developing it), don't you? X originates in the 80s and it's not a design that stands the test of time. Since the late 00s, all of the window managers had already started doing compositing themselves, circumventing all of the nice layers of the X protocol and just copying pixel buffers around, the interface with X itself is blocking, vertical sync is impossible, security is a joke, the code was untenable. I understand that in as heterogenous software ecosystem as desktop Linux, any large fundamental change will be ugly because there is no shared release cycle and there is no platform, so one can't just change everything overnight, but as far as I can tell, Wayland has been usable for quite a while now. Literal years. Unless you're using hardware vendors that are hostile to FOSS.


> X originates in the 80s and it's not a design that stands the test of time.

Actually the fact that X11 can be used today despite the fact that we went through several cycles of vastly changing GPU hardware shows that it absolutely has stood the test of time.


Ncurses apps can also display GUIs for a long time now, but it doesn’t mean that they are actually good solutions.

The X server became a pretty useless middle man between clients and the compositor. And the vastly changed GPU hardware is the reason we should prefer a superior solution - we no longer draw as we did 3 decades ago, so we should cut out the middle man.


> Ncurses apps can also display GUIs

Terminal applications stood the test of time as well. For everything that is not graphical in nature they are indeed good solutions.

> The X server became a pretty useless middle man between clients and the compositor.

X is a middle man but far from useless. Just as Wayland is a middle man as well. And looking at the protocol actual access to GPU memory is more opaque on Wayland than on X11 and as such to me Wayland is a more intrusive middleman.

If you want to "cut out the middle man" you have to use DRM directly.


Please have a look at an X maintainers very own presentation: https://m.youtube.com/watch?v=cQoQE_HDG8g

Wayland is not a middle man as it is the compositor itself as well - it does the minimal amount of work necessary to compose the desktop. X on the other hand just transfers messages between clients and the compositor without doing any actual work (x render functions are almost never used by modern applications)


Many of the points of this talks are invalidated with the introduction of DRI3 others are still valid but Wayland is not a solution. The X server indeed "just transfers messages between clients" but so does a Wayland compositor. How else would a screen capture functionality even work. Also, the fact that GTK/QT applications don't use Xrender (GTK used to but dropped it) can not be blamed on X.


Using xrender would pretty much result in terrible performance, not allowing the extreme parallelism of GPUs. This is the fundamental problem with X, it originates from a time when GPUs were not even a thing. It had a great run, but let it sleep now.

Also, DRI3 doesn’t solve the fundamental security flaw of X - which can only be solved by nesting multiple X servers into each other. At that point we would have a much uglier architecture than we have with wayland.


I am a bit confused. I do not think that hardware accelerated UI was a thing until quite recently and people did not really have issues with its performance. If anything it feels like that accelerated UI drawing is slower on older machines compared to software-rendered UI.


Well, try using any graphical application from inside a vm (those are often software accelerated only).

But the problem is basically: you can either have 1-2-4-8 cores at most writing pixels into a buffer one after another (but due to the complexity of interactive GUIs it will most often be single threaded), so a circle will be displayed as going over an area and coloring each pixel.

Versus specifying some condition and having the GPU run it on every pixel in large batches, almost doing it in one go. Of course for 3 lines, what previous GUI iterations were, you don’t need gpu, but for gradients, media!, and basically a bunch of other things you simply need the GPU’s orders of magnitude more parallelism. Add to the picture that we are using much bigger screen resolutions (full hd has 6x number of pixels compared to 480p, and then we are not even talking about 4k. And 120, 240fps monitors are a thing now) and you can quickly see that 1) drawing is a greatly parallelizable task 2) having it done serialized simply doesn’t scale to today screens.


"try using any graphical application from inside a vm"

This is because said graphical applications are designed to be used with a modern GPU and they use stuff like OpenGL to render their components.

"but for gradients"

Maybe we can go without them. Modern UIs are too heavy, latency-inducing, battery consuming, and can turn your device into a heater easily.

"And 120, 240fps monitors are a thing now"

Re-drawing the window in every frame is a wasteful action that tends not to happen with applications designed for software rendering.


The drawing lib used by chrome is ridiculously performant - the problem is not at lower layers in case of modern UIs. Specific hardware will also be much more efficient than general purpose one, so no, gpus are not the culprit behind any of those.

While you may not like gradients, animations (which absolutely mandate GPUs) for example do give context on what happens because humans are used to physical objects that don’t teleport from one place to another. I wouldn’t consider these needless features either.


Who uses XRender? If nobody is using XRender, is it because everyone is wrong or is it because XRender is not the best solution to the problem it's trying to solve today? And sure, X just transfers messages between clients, and the window manager is just a client, but it feels like X is redundant here - why not have a unified protocol so that the clients can talk to the window manager directly? That way, the window manager can actually delegate different functionality using some kind of an authentication mechanism. X was developed when the principle of least privilege wasn't as prevalent and it shows. I don't want all of my applications to be able to capture all of my screens at all times. Yet with X, there's no way to prevent this.

And, may I ask,why are you so quick to dismiss the core developers of X?


Nothing stopped anyone from building a compositor into an X server if that is what you want to change.


> Literal years. Unless you're using hardware vendors that are hostile to FOSS.

Except new GPU hardware at reasonable prices has been unobtainable for 2 years now, and AMD's new Linux friendly stance was only a couple of years before that. So there's like a 2-3 year window where you could have said "Well, you should have known to buy the FOSS friendly hardware". (Which came with other tradeoffs, AMD had uncompetitive hardware and poor GPGPU support in that time period)


Wayland works on nvidia gpus as well now, so even that is solved now.


It really doesn't. I tried it again just yesterday and they don't support having multiple screens on Wayland, somehow. I want to switch to Wayland, but no, NVIDIA still doesn't work yet


"the code was untenable"

I have seen various comments claiming that the code was very clean.

"Since the late 00s, all of the window managers had already started doing compositing themselves"

Most window managers don't do compositing.

Also, XCB is async.


> Nothing changes for the user when they switch to it.

You must perform regular maintenance on btrfs or it will quite simply break. This is a huge departure from for example ext4, which is (to the end user at least) hassle free.


this is not my experience, btrfs has been just as stable as ext4 and zfs for me. maybe i've just been lucky?


I'm not sure about the "maintenance" part, however, my experience was:

- a few years ago, one system would suddently not boot (due to btrfs); this happened twice

- nowadays, on one system, background scrub doesn't start

This is anecdata of course, but I've never had a good impression overall. I don't see any reason to use btrfs rather than ZFS, considering that Ubuntu and derivatives are starting to add builtin support.


It is a technical certainty AFAICT. If this has not impacted you, it will some day :)

Scripts for actually doing so can be found f.e. here: https://github.com/kdave/btrfsmaintenance


Ext4 is transparent for me, but I can confirm BTRFS to have failed me several times. n = 1 of course.


Good error messages are an underrated.

Python 3.10 is the first release to be exciting to me, since 3.6. Not because of pattern matching. Not because it adds 2 builtins. Because the error messages are so much better. And 3.11 will do even more.

Who said you needed a buzz word to get a nerd attention?


In a movie, it would mutate, escape, then somebody would claim "life finds a way".


Horizontal gene transfer makes mutation unnecessary, and for single cell organisms, natural selection in action.


That's why I have high hopes for the Simula One. I always feel like I could get a bigger screen. Finally, I may be able to nothing but screen.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: