X.Org Server Hit By New Local Privilege Escalation Vulnerability

[ryao]

Yes, all CVEs found are not old, but if you claim that rewrite always contains more bugs than the original, then you need to compare the total number of bugs/CVEs, not just the new ones, but the total number.

My claim is that a rewrite from scratch will contain more bugs than the mature code that it is meant to replace. That implicitly excludes all of the historical bugs because the choice is between a mature codebase that has has many bugs squashed and a new code base that had yet to receive the same treatment.

It's still a bug in the old code, since the new function simply calls into the old code and it's the one who causes the bug.

And both of us are calling that a bug in old code. What is your point?

[mdedetrich]

Pointing out the limitations of Rust is not fallacious in the slightest.

It is when you are quoting someone (me in this case) and that is not what they said. Its a strawman (thats what is the fallacious part) because no one (importantly me, who you again were quoting) was claiming that.

It is an assumption that a rewrite from scratch will not be more buggy than the original. That is one people often lose, no matter the language used.

And I am saying the assumption is invalid because most studies that have done this have used assumptions that do not apply here. Its the same reasoning when proponents of dynamic languages point to studies showing there is no benefit to static languages but fail to realize that almost all of these studies are done in a timeframe that is too short for static languages to show their benefit (this timeframe being typically 6-12 months iirc).

If a rewrite is done in a language that specifically doesn't have a large set of issues the previous language does (which as a mainstream language is really only possible with something like C vs Rust) and that is what we are measuring, we need a study for exactly that and not some somewhat related studies from the past.

[ryao]

No, I say that sometimes you can discover bug in the old code because you push some limit. And such bugs occur only in some cases.
Imagine that you have object with registerListener method and it can do some nasty things if you add too many listeners. You add a new listener from time to time. Everything works perfectly fine and then one day you add another new listener and boom – you have bug that affects only new versions, but it's actually been introduced long time ago.

This is not statistically significant.

[ryao]

It is when you are quoting someone (me in this case) and that is not what they said. Its a strawman (thats what is the fallacious part) because no one (importantly me, who you again were quoting) was claiming that.

I have seen statistics in favor of Rust that state that memory issues in C/C++ code are about 2/3 of all issues or about 70%. I correctly stated that Rust would not eliminate all memory issues to cover myself from someone saying that I was wrong in assuming that all of the memory issues would be magically fixed by Rust, before I went on to reason about what would happen if all of them really were. This is the opposite of a fallacy and it was clarifying the assumption that I was about to make in my actual argument against your remarks. That being that even if 70% of bugs were eliminated by doing a rewrite from scratch, it would not be enough to justify replacing mature code, because the mere act of writing it from scratch would produce a more buggy result even after the 70% reduction. Of course, you will not get the full 70% reduction for reasons already stated, but that should be obvious. There is no straw man here.

[AlanTuring69]

I think I actually got dumber reading a lot of these comments somehow suggesting a mature codebase vs a newer codebase is any comparison. You honestly have no idea what you're talking about and Xorg has been mismanaged for so many decades that it's beyond help such that the only solution is a new project.

[ryao]

I think I actually got dumber reading a lot of these comments somehow suggesting a mature codebase vs a newer codebase is any comparison. You honestly have no idea what you're talking about and Xorg has been mismanaged for so many decades that it's beyond help such that the only solution is a new project.

Mature code has a small number of bugs relative to new code. Linux 2.4 would be another example of mature code. When Willy Tarreau stopped maintaining it in 2012, there were very few bugs being found and at least 18 months had elapsed since the last critical bug had been found.

That said, wayland shares plenty of components with the xorg server, so if you want to replace everything associated with xorg, you also want to replace wayland. If xorg were mismanaged, you would be talking about replacing everything associated with it. Surely, you do not think it is so bad that every part of it that the xorg server shares with wayland needs to be replaced.

[Sergey Podobry]

https://conscientiousprogrammer.com/blog/2014/12/21/how-to-think-about-rust-ownership-versus-c-plus-plus-unique-ptr/

https://www.reddit.com/r/rust/commen...mment/f3tswv7/

What you posted is a comparison of C++ and Rust. What I'm telling is that Xorg is written in C and not in C++. In C++ std::unique_ptr eliminates use after free class of errors.

[brad0]

I am pretty sure that X.org trolls won't disappear in my potential lifetime, 40-50 years into the future. Wayland is ready, NOW, to be used by 99% of Linux desktop users for all their needs. Perhaps a feature or two are still missing, boo-hoo. It is still usable for most. Let the corpse of X11 to die already.

That still wouldn't result in X.org going away. The ignorance is incredible but not surprising.

[mdedetrich]

That being that even if 70% of bugs were eliminated by doing a rewrite from scratch, it would not be enough to justify replacing mature code, because the mere act of writing it from scratch would produce a more buggy result even after the 70% reduction.

Your stating that re-writing software makes it more buggy as an axiom when its an assumption. I have done entire codebase rewrites on non trivial software (10k+ LOC minimum) and the new software hasn't been noticeably buggier than the previous version. There may have been new bugs in the rewrite, but the rewrite itself may have also revealed bugs in the old version (then you have a discussion if the bug is a feature or not).

The biggest reason behind software re-writes making more bugs is that the scope/requirements/features/scope are changed significantly along with the rewrite but this wouldn't even be the case of a hypothetical xorg rewrite.

And when specifically talking about Rust rewrites of equivalent code, there is actually opposite evidence (i.e. the rewrite has less bugs and less security issues), for example when Firefox rewrote their CSS render from C++ to Rust (which also did more than the C++ equivalent, i.e. Rust version was multicore) see https://hacks.mozilla.org/2019/02/re...onent-in-rust/. I am not saying that this is conclusive proof that a Rust rewrite will never have more bugs, but all of the current evidence does show that to a degree.

[mdedetrich]

What you posted is a comparison of C++ and Rust. What I'm telling is that Xorg is written in C and not in C++. In C++ std::unique_ptr eliminates use after free class of errors.

There are ways to bypass this in C++ https://www.fluentcpp.com/2019/01/22...in-modern-cpp/. Even with the new safety features that C++ has, there is no comparison to Rust.