Comment by Jyaif

10 days ago

> a subtle data race and a rare deadlock

That's a langage problem that humans face as well, which golang could stop having (see C++'s Thread Safety annotations).

13 comments

Jyaif

Reply
kbolino  10 days ago

Go has a pretty good race detector already, and all it (usually) takes to enable it is passing the -race flag to go build/test/run/etc.

Thaxll  10 days ago

No language protects from dead lock.

  • Groxx  7 days ago

    Not true! There are a fair number of them, and they're even reasonably general-purpose, e.g. https://www.ponylang.io/

    Most that can recall achieve this by simply not having any locks at all. That's feasible with some careful design.

    Outside proof-oriented languages though, I'm not aware of any that prevent livelocks, much less both. When excluding stuff that's single threaded but might otherwise qualify, e.g. Elm. "Lack of progress" is what most care about though, and yeah that realm is much more "you give up too much to get that guarantee" in nearly all cases (e.g. no turing completeness).

  • Jyaif  9 days ago

    I probably agree that they don't protect you from all deadlocks, but some languages protect you from some dead locks.

awesome_dude  10 days ago

You should be using rust... mm kay :\

  • danudey  10 days ago

    Doing concurrency in Rust was more complex (though not overly so) than doing it in Golang was, but the fact that the compiler will outright not let me pass mutable refs to each thread does make me feel more comfortable about doing so at all.

    Meanwhile I copy-pasted a Python async TaskGroup example from the docs and still found that, despite using a TaskGroup which is specifically designed to await every task and only return once all are done, it returned the instant theloop was completed and tasks were created and then the program exited without having done any of the work.

    Concurrency woo~

    • Groxx  7 days ago

      Yeah, I'd really have liked to see something like [Trio](https://trio.readthedocs.io/en/stable/) gain mid more attention in Python. Structured approaches can prevent a huge amount of those issues, and Python code is absolutely riddled with concurrency problems in my experience. Much more so in practice than other languages except maybe javascript (when including async ordering mistakes). It makes it a real nightmare to try to build anything actually reliable.