Something really sad and unhealthy in open source community happened yesterday with one of the most exciting projects in Rust - with Actix-web framework actually!
https://words.steveklabnik.com/a-sad-day-for-rust
This happened mainly because dialogue and decision making process went in a wrong way, and the escalation took a wrong turn in this situation.
So, thus, author decided to take his will and made a most hard (and not good for the Rust community) decision to wipe project repo out from GitHub.
This is the point when all we must to take a closer look at the situation, figuring out what actually happened (without any judgement) and realize that something wrong, unhealthy and really terrible happening, especially when community growing fast and in the wrong direction, when we could find that we are already on a point in a wrong way, maybe on a point of no return.
IMO, author did this to gain and attract more closest attention to a situation with less qualified third-party community from Reddit and it's participation (nowadays mostly as angry critiques, trolls and haters of Rust) in life & growth of Rust community projects, and to gain and attract attention to old and really controversial situation with (more or less justified) often usage of
unsafe blocks in projects development as escape hatch from the guarantees of substructural type system and shared XOR mutable invariant of borrow and ownership checker in the Rust compiler.Most of the participants in conversations doesn't really read
Rust Internals forum (https://internals.rust-lang.org), and really couldn't figuring out that unsafe is an escape hatch (to using raw pointers, for example) and this is really essential for Rust as a systems programming language, 'cause not every situation, task and program could have a good fit into model of shared XOR mutable invariant (especially imagine creating of double-linked list with mutable elements, for example).Nevertheless,
unsafe doesn't disable in a whole the main invariants of substructural type system of Rust, it's just weakening the hard restrictions of type system where there're no other possibilities in task resolutions (although, programmer always must be aware of misuse and malpractice of unsafe hatch), this gives the flexibility for systems development (for creation of OS kernels, compilers, for example) and in a more precise way gives the powerful possibility for localisation of errors and undefined behaviour in program code.Answer yourself honestly, could the developers in any other (and more danger!) programming language (except Rust, Ada and ParaSail) find, localize and fix the undefined behaviour in such huge project (as Actix-web was), as fast as Rust developers did this for that
unsafe code block in Actix-web, wich has led to undefined behavior and have had such insulting reaction of the haters of Rust, huh?I think even with static analyzers and all that sanitizer techniques even experienced C++ developers couldn't localize and fix undefined behaviuor cases in the compiler or any other huge program in a such fast and precise way (but, definitely and unfortunately most of such malfunction programs could be compiled in other languages, but not in Rust!), but
unsafe in Rust gives this opportunity to developers, to get this work done as fast as possible!And Steve Klabnik previously was already also write about this in one of his blog posts (https://words.steveklabnik.com/you-can-t-turn-off-the-borrow-checker-in-rust), and Alexey Kladov (https://github.com/matklad) also told about this and describe the use and misuse cases of
unsafe in his lectures upon Rust on YouTube!#Rust
Links to previous posts on the same subject:
@technologique/1332
@technologique/1333
@technologique/1334