I don't know if that was a deliberate portmanteau of obtuse+ontological, or if it was a happy typo, but I'm stealing it.
please don't... I understand your point but there are hundreds of vulnerabilities introduced every day in memory-safe languages that have nothing to do with rust's concept of "unsafe".
the root cause of a problem in unsafe could can absolutely be from safe code because the safe code can set state in a way that causes problems.
One can easily see this if you consider safe code that sets an index and then calls into unsafe code but the index is out of range. The root cause is absolutely in the safe code.
However, I do believe Rust gets a whole lot of things right.
I sincerely hope that unnecessary use of unsafe code is avoided.
People have got to stop believing that safe code in rust is automatically not the root cause of problems. It's a misapprehension.
I hope that the code that streams your data out to an endpoint isn't memory safe, so you easily find it!
The amount of code might be the same, but that doesn't guarantee that the level of risk is the same. A lot of bugs are introduced at interfaces -- the provider of an API makes a subtle change without realizing how it affects some of the API consumers -- and that's inherently more likely to occur if the two sides of the API are developed separately.
In the FreeBSD world we've found that it's incredibly useful to develop the kernel and libc and system binaries together; all sorts of problems Linux trips over simply never happen in FreeBSD.
For example, rust happily lets you access a database before checking that the user's auth token is valid - absolutely nothing prevents you from that.
No one is forcing you to use the libraries. Just write your own software stack yourself.
But big problem is vulnerablilities. Is it better to fix hundred libs by fixing a bug in one shared lib or is it better to fix hundred libs one by one?
What is actually better is to have code that is properly auditable for end-users, or even to not introduce the risk for those vulnerabilities in the first place.
Things like Heartbleed and Log4Shell were serious vulnerabilities that were useful only for a minority of people, and were hidden inside bloated code. The same thing is happening now with package supply chain.
Why multiply? If everyone rolls their own libs, you can expect different library makers to repeat similar mistakes (stuff like not sanitizing input, forgetting to cap anything that generates output from outside sources, etc.).
> Heartbleed and Log4Shell were serious vulnerabilities that were useful only for a minority of people
Minority of people need SSL and logging?!? Most applications need logging, and most of today's applications need the Internet to function. Could have they been omitted when possible? Perhaps, but you're not making a persuasive argument.
I didn’t make a suggestion, but micro-packages aren’t silver bullets.
Deep transitive dependencies are problematic for their lack of visibility, and often a signal of bloat.
> Minority of people need SSL and logging?!
Heartbleed and Log4Shell weren’t caused by the core SSL or logging code of those libraries, they were caused by code in niche features (heartbeat extension and SAMBA) that should have been plugins (or at least deactivatable by flags). that would massively decrease their impact.
Both Heartbleed and Log4Shell were caused by feature bloat and lack of auditability.
And what is your idea to fix this?
> Deep transitive dependencies are problematic and...
Gonna stop you right here. Deep transitive dependencies are nothing more than huh, other library find this functionality useful, let's pull it into a library.
By not having deep dependencies, you are in no uncertain terms claiming everyone should write their own. Or God forbid copying code into your own project.
Imagine we write a set of perfect auditable libraries. Fuzzed, written to spec, proven correct & fast in theory and practice.
Guess what? Everyone and their mother will use it leading to deep transitive dependencies.
The complexity of consumer hardware and software requires that even trivial libraries carry with them lots and lots of dependencies.
Alternative is basically Ludditism.
"Our software will be so much better quality if it won't do the things you're paying me to make it do" is a non-starter in the real world.
Nobody ever said anything of the sort.
But this is really far away from the bulk of Rust or NPM libraries, and it's very naive to pretend that the situation isn't like that.
I already mentioned two examples of things that could have been separate from the main libraries (or at least require flags or separate compilation) and caused global problems: heartbeat extensions from OpenSSL and LDAP/JDNI from Log4J.
EDIT: I can mention two other examples that I already talked about in this thread: I often come across simple GraphQL-API-consuming apps or libraries that have dependencies on large frontend libraries, while a simple fetch would suffice. The library is needed for introspection, or for building autocomplete clients, but for pure consumption this is unnecessary. Another example are libraries from authors that are splitting code only to bump their NPM or Cargo metrics, like is-odd, or the ora package that has 15 dependencies and a lot are covered by stdlib.
They aren't. I'm steelmanning your position. "What if there exists a set of well audited libraries". And "what if we have package managers everyone uses". The logical answer is that everyone reuses them, leading to deeply nested transitive dependencies. Hence a contradiction. Deeply nested libraries aren't a problem.
> caused global problems: heartbeat extensions from OpenSSL and LDAP/JDNI from Log4J.
Already covered that. How do you disambiguate what is a crucial feature and what is overhead? On surface it seems simple, but constraints, call for features and backwards compatibility guarantees makes that something that only seems obvious in hindsight.
- Some set of libraries are fully audited.
- Some libraries can't be fully specced and audited because their specs are in flux (e.g. games, GUIs, webapps)
- Those libraries/apps will limit their maintenance burden by using audited ones
- Package managers are useful.
As long as the set of audited libraries is large or tends to grow large, or the audited libraries build upon each other, or the non-audited libraries depend on many other libraries, the "deeply nested" (I don't think it's deeply nested as much as many dependencies) hierarchy will be replicated.
Sure, but nevertheless: if this were a reality, sure, it would be perfectly fine! But we don't live in the fantasy world so we have problems.
This is why people don't complain about this kind of code being moved to standard libraries: stdlibs they are often heavily audited (with exceptions),
So maybe that's a suggestion: moving SOME things (NOT ALL) that are traditionally in stdlibs in other languages to the stdlib of your own language.
Or perhaps force yourself to only use heavily audited libraries (parent commenter mentioned NewtonSoft.JSON, this is a good one that is an industry standard).
> How do you disambiguate what is a crucial feature and what is overhead
To keep using the same two examples: if you don't need something for 99% of regular use cases, then it can definitely be optional.
I'm not advocating removing features or not making it, like another person said. I'm just advocating building software a bit differently.
Instead of having 100 features and a lot of dependencies in one root package, have instead 1 base package (with fewer features and fewer dependencies) + N plugin packages (with the remaining features and dependencies).
This way you can reduce the blast radius of problematic dependencies without removing features.
The fact that Rust makes it easy to pull in a large number of small dependencies instead of a few enormous dependencies is irrelevant. You aren't using any more code.
For example are you counting Rusts `regex` crate as a dependency? Well that's just in the standard library for C++.
Does Boost count as a single dependency in C++? Because that would be like 30 separate crates in Rust.
Maybe you have 70% fewer vulnerabilities per line of code than C++ if really 70% of (old) C++ vulnerabilities are memory related.
But if you then pull in hundreds of packages in Rust and have 10x as many lines of code...
30% of 100k lines is more in total than 100% of 10k lines of code.