Remix.run Logo
Remix clone Hacker News
new | show | ask | jobsGithub
▲ collinfunk 16 hours ago

I really don't understand why Canonical rushes this. If 'rm' can't remove all possible directory entries, that is a big issue:

  $ podman run --rm -it ubuntu:26.10
  $ apt update -y; apt upgrade -y
  $ rm --version
  rm (uutils coreutils) 0.10.0
  $ gnumkdir -p $(yes a/ | head -n $((32 * 1024)) | tr -d '\n')
  $ rm -rf a
  Segmentation fault (core dumped) rm -rf a
  $ ls a
  a
  $ gnurm -rf a
  $ ls a
  ls: cannot access 'a': No such file or directory
▲teekert 16 hours ago | parent | next [-]

Rush? This is an interim release (95% or so only tracks LTS's) that is not even out yet... Go file a bug reports if you have some time.

▲mixmastamyk 15 hours ago | parent | next [-]

I did, and the original dev of the component fixed it within a few days. It was straightforward, a backwards reading of a spec, reordered.

The fix is still sitting unmerged many months later.

This surprised me since I thought the project was in heavy bugfix/compat mode. I won’t touch it until I see some velocity on open bugs.

▲baq 8 minutes ago | parent [-]

Fork Ubuntu and threaten their business model, that’ll get their attention.

Only half joking.

▲LtWorf 2 minutes ago | parent | prev | next [-]

My experience is that filing bug reports to ubuntu is a complete waste of time. Not sure if it's different for paying users.

▲collinfunk 16 hours ago | parent | prev | next [-]

I have. It has been an open bug upstream for years as well.

▲teekert 15 hours ago | parent [-]

ok, that's concerning, if you post it here I'll vote for it (after confirming).

▲jeffbee 15 hours ago | parent | prev [-]

Reporting bugs before Ubuntu releases has never worked for me. They always land a bunch of major changes after the supposed "freeze" then they ignore all feedback because of the freeze. It's infuriating.

▲collinfunk 15 hours ago | parent [-]

Glad to hear that I am not alone. I feel like launchpad is totally ignored most of the time.

To get a response on a buggy GNU coreutils patch of theirs [1], I had to mention it in a rust-coreutils bug months later...

[1] https://bugs.launchpad.net/ubuntu/+source/coreutils/+bug/215...

▲amelius 15 hours ago | parent | prev | next [-]

Let them first fix Snap.

▲tjoff an hour ago | parent | next [-]

There is no reason for anyone on any distro to use snap.

It will die so just leave it alone.

▲0x696C6961 6 hours ago | parent | prev [-]

They need to kill snap ...

▲cute_boi 2 hours ago | parent [-]

Yes, please. Linux distros is better with macos approach. And making appimage first class makes a lot of sense.

▲tancop 14 minutes ago | parent | next [-]

Appimages are bloated and unreliable. You can't guarantee that your app will run on any machine because it might depend on different system libraries.

Flatpak uses shared stable runtimes that are the same everywhere and don't take up space more than once. It also comes with a native update system and sandboxing. Snap is the same thing but worse.

▲petre 2 hours ago | parent | prev [-]

I'll avoid it at this point anyway. The Rust coreutils is another reason for that. Snap, monetizing updates, telemetry, enough is enough.

▲voakbasda an hour ago | parent [-]

Yup. After almost 20 years, I have had enough of their crap. All of my new machines are getting Debian. Can’t wait until I am free of Ubuntu.

▲lynx97 an hour ago | parent | prev | next [-]

Wow! Memory safety and such... Reminds me when a friend of mine wrote in IRC long time ago: "Hmm, tail just segfaulted." When I asked "Are you on Hurd?" he just replied "Yes."

▲dark-star 15 hours ago | parent | prev | next [-]

yeah, this is a bug. And yes, it should be fixed. But I don't think it will affect many users, I mean who has a 32000 -evels deep directory on their system?

▲tosti 13 hours ago | parent | next [-]

What programmer or programming language can't iterate a loop more than 32000 times?!

▲Ygg2 13 hours ago | parent | next [-]

When triaging an issue you have to prioritise. Do you fix a problem that affects 2-3 people or one that may affect thousands?

▲nh2 11 minutes ago | parent [-]

The point is that such bugs shouldn't exist in the first place.

Using recursion on unbounded inputs on a programming language that doesn't support that (which are most) is an extremely classical mistake that really should be known to all programmers, especially those of low level languages that care about safety.

Every time you call something recursively you should be thinking "how deep is this?".

▲IshKebab 13 hours ago | parent | prev | next [-]

It's a stack overflow which means it's using recursion and for historical reasons that don't make sense any more, stacks are teeny tiny on 64-bit Linux - apparently only 8 MB on Linux! I'm not sure why they don't raise it to something reasonable like 4 GB. I guess because they want consistency with 32-bit? Maybe we can finally change it if/when they phase out support for 32-bit Linux. Apparently it might not be that far away:

https://lwn.net/Articles/1035727/

▲ploxiln 2 hours ago | parent | next [-]

8MB is the default per-thread stack size from glibc, also seems to be the default "ulimit" from pam or the kernel, I'm not sure. So for the main/default thread (or if not using threads) the process can use setrlimit() and for threads it can use pthread_attr_setstacksize() to get bigger stacks if it knows it may need them.

8MB is pretty huge though; musl libc is famous for defaulting to much smaller per-thread stack size of 128KB (to avoid over-committing lots of memory when there are many threads - the main dev is really principled/opinionated on this topic, but again there are a few ways for applications to explicitly size their stacks as large as they need). Linux kernel threads get a bit less than 16KB!

▲tosti 13 hours ago | parent | prev [-]

OIC. Rust doesn't guarantee optimizing tail recursion. How unfortunate for a language that's getting widespread adoption.

▲gpm 12 hours ago | parent | next [-]

For what it's worth there's reasonably active [1] work on implementing opt-in guaranteed tail calls - but it's not particularly fast going. LLVM (the backend rust uses) needs better support for musttail (e.g. some architectures just don't support it [2]).

[1] https://github.com/rust-lang/rust/issues/112788

[2] https://github.com/rust-lang/rust/issues/153827

By-default guaranteed tail calls really isn't rust's style, because it means subtle changes (introducing a destructor, re-ordering code, etc) can change semantics without you realizing it. If you want to guarantee that a call can't allocate a new stack frame you should have to say it.

▲lioeters 12 hours ago | parent | next [-]

Not so familiar with this area, but isn't the existing behavior of implicitly creating new stacks more of a problem than implicit tail-call elimination? Seems the latter is a kind of compiler-level optimization, of which there are already many (I think) that change the semantics internally but guarantee the outward behavior stays the same.

But I can understand the preference for an explicit opt-in, to make clear that it is enforced and not assumed.

▲gpm 12 hours ago | parent [-]

> implicitly creating new stacks

I'd argue that it's explicit - that's what a function call does and you don't have implicit function calls in rust.

> Seems the latter is a kind of compiler-level optimization, of which there are already many (I think) that change the semantics internally but guarantee the outward behavior stays the same.

What you're asking for here already exists. Tail calls might be optimized into not allocating extra stack frames, the rust compiler just doesn't guarantee that it will perform that optimization (and almost certainly won't when code is compiled without optimizations... for instance).

What people want is the semantic guarantee that the stack frame won't be allocated. Not just a compiler that often performs the optimization. Otherwise you can't be sure that your code will keep working with new compiler flags/versions/architectures/... You could say "whenever the code is the right shape we'll guarantee the optimization" (C++ famously did this for things like copy elision)... but now the shape of code comes with non-obvious semantic guarantees and that's not rust's style. Hence the proposal for a keyword instead.

▲lioeters 12 hours ago | parent [-]

I see it, certain algorithms need guaranteed tail-call elimination, otherwise they are too inefficient and must be manually unrolled or rewritten to avoid blowing the stack. So a compiler optimization that is "nice to have" is not good enough.

▲clhodapp 3 hours ago | parent [-]

No algorithm requires tail-call elimination in a general-purpose language with imperative mutability. It's just another way to express iteration.

▲jmalicki 3 hours ago | parent | prev [-]

> because it means subtle changes (introducing a destructor, re-ordering code, etc) can change semantics without you realizing it.

No, it won't change semantics - if you say @musttail or similar, it will simply fail to compile if you, say, introduce a destructor - the semantics will not subtly change.

▲afdbcreid 2 hours ago | parent | next [-]

Incorrect. `become` does change drop order - https://play.rust-lang.org/?version=nightly&mode=debug&editi....

▲jmalicki an hour ago | parent [-]

That's not implementing tail calls breaks things, that's bad design of implementing tail calls breaking things.

The whole idea of "let's change semantics to make it easier" is dumb.

If you want guaranteed tail calls, change your code until it works.

▲gpm 3 hours ago | parent | prev [-]

Uh, yes, if you guarantee the semantics only when the code explicitly opts in and not by default then semantics will not subtly change, that is the point of my comment

▲jmalicki 3 hours ago | parent [-]

It's not a change in semantics of compiled code. It is only a change of whether or not the code will compile.

▲IshKebab 9 hours ago | parent | prev [-]

Do any widely used languages guarantee tail call optimization? It's a pretty niche feature.

▲gpm 9 hours ago | parent [-]

Scala, ocaml, racket, clojure, zig.

For recursion only kotlin.

(For most of these only with syntax specifying it)

▲hulitu an hour ago | parent | prev [-]

Rust ? Because of ... memory safety. /s

▲secondcoming 15 hours ago | parent | prev [-]

That way of thinking just means it'll never be fixed

▲abirch 15 hours ago | parent | next [-]

"The Linux philosophy is 'Laugh in the face of danger'. Oops. Wrong One. 'Do it yourself'. Yes, that's it." Linus Torvalds

▲dfox 15 hours ago | parent [-]

The problem there is that this is exactly the class of bug that does not exist in GNU coreutils because of philosophy of that project. Non-existence of such bugs proves that the impementation is not copied from AT&T code.

▲gpm 15 hours ago | parent | prev | next [-]

Nah, people should (and do) fix small issues as well as big issues. Lying about the scale of issues and calling them "big" when they aren't just leads to no ability to prioritize or evaluate.

Incidentally someone submitted a PR for this issue about 3 hours before the first comment about it in this thread - https://github.com/uutils/coreutils/pull/14554 (and 2 hours before this link was submitted to HN)

▲7bit 15 hours ago | parent | prev [-]

What approach would you suggest for priorisation of tickets?

▲mrkdkirlwkfkf 2 hours ago | parent | next [-]

Capitalism.

▲secondcoming 15 hours ago | parent | prev [-]

Ideally there should have been no tickets at all if all that's happening is a program being ported to another language.

▲gpm 15 hours ago | parent [-]

This isn't a port - it's a re-implementation without any use of the original source.

That's also not all that's happening. It's also making improvements like better internalization support, better error messages, and a small handful of other extensions.

▲collinfunk 15 hours ago | parent [-]

I have had to tell them repeatedly to stop copying tests verbatim, including the original comments from GNU coreutils. So I doubt this is true, which is frustrating.

▲IshKebab 13 hours ago | parent | prev [-]

I mean, that should work... but you can see why that would be considered low priority right?