News for hackers. Stuff that matters.
Re:Why Bloat Is Still Software's Biggest Vulnerability by Ygg2 on Saturday February 10, 2024 @08:25AM (#39325963)
It's not a false dichotomy. You either put your vulnerabilities in a few baskets, or you spread (and multiply) them in many more baskets. Neither is intrinsically better.

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.

Re:Why Bloat Is Still Software's Biggest Vulnerability by whstl on Saturday February 10, 2024 @08:48AM (#39326102)
I never said people should roll their own. I said code should be auditable for end users. Hundreds (or thousands) of packages isn’t auditable.

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.

Re:Why Bloat Is Still Software's Biggest Vulnerability by Ygg2 on Saturday February 10, 2024 @03:26PM (#39329869)
> I said code should be auditable for end users. Hundreds (or thousands) of packages isn’t auditable.

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.

Re:Why Bloat Is Still Software's Biggest Vulnerability by yukkuri on Sunday February 11, 2024 @12:00AM (#39332770)
Yes, even the original link admits their "simple is better" solution is only better in limited use cases.

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

Re:Why Bloat Is Still Software's Biggest Vulnerability by whstl on Sunday February 11, 2024 @07:12AM (#39334490)
You two are talking with a straw man.

Nobody ever said anything of the sort.

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.

Re:Why Bloat Is Still Software's Biggest Vulnerability by yukkuri on Saturday February 10, 2024 @11:57PM (#39332756)
Once upon a time I had to track down a catastrophic performance failure (process that should have taken a few minutes couldn't finish in the THREE DAYS allotted to it as a maximum runtime) that turned out to be because it was using a hand-rolled "simple" JSON parser instead of just pulling in Newtonsoft.