News for hackers. Stuff that matters.
Re:Why Bloat Is Still Software's Biggest Vulnerability by whstl on Sunday February 11, 2024 @07:07AM (#39334462)
Fuzzed, proven correct libraries clearly aren't the problem here.

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.

Re:Why Bloat Is Still Software's Biggest Vulnerability by Ygg2 on Sunday February 11, 2024 @06:17PM (#39339803)
> Fuzzed, proven correct libraries clearly aren't the problem here.

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.

Re:Why Bloat Is Still Software's Biggest Vulnerability by Ygg2 on Monday February 12, 2024 @01:48AM (#39342207)
Here are my underlying assumptions:

- 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.

Re:Why Bloat Is Still Software's Biggest Vulnerability by whstl on Tuesday February 13, 2024 @08:09AM (#39357251)
I'm fine with people using single-function libraries if they're audited. The problem is that those are the ones who historically are not cared at all :/
Re:Why Bloat Is Still Software's Biggest Vulnerability by whstl on Tuesday February 13, 2024 @08:07AM (#39357238)
> They aren't. I'm steelmanning your position.

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.