Login
You're viewing the functional.cafe public feed.
  • Nov 8, 2026, 6:43 PM

    The myth that software needs constant updates has utterly undermined the principles of free software and immensely empowered sloppers and other bad actors.

    The whole idea was supposed to be that, once you get something released as free software, you have it forever, and don't have to care about the people who made it selling out and betraying you.

    That was like the whole distinction from proprietary software, where we knew it would always end that way.

    And somehow we let the worst people in our spaces convince us that we have to accept the same from free software.

    💬 13🔄 175⭐ 281

Replies

  • 💬 4🔄 7⭐ 27
  • Nov 8, 2026, 6:50 PM

    I also blame well-sponsored foss developers/maintainers, i.e. mainly those funded by corporations/LF, who have a vested financial interest in users being kept dependent on them.

    The Linux kernel folks are very explicit that they want to force you to follow mainline and undermine your ability to use the free software you've already obtained from them indefinitely.

    💬 2🔄 6⭐ 21
  • Nov 8, 2026, 6:51 PM

    They do this by intentionally misrepresenting which bugs are vulnerabilities and what their impact is, so that it's extremely difficult for non-experts to keep using a version they like and just patching the rare critical issues.

    💬 1🔄 3⭐ 19
  • Nov 8, 2026, 6:54 PM

    The authoritarian infosec crowd is just like cop apologists.

    They want you to believe it's better to trust abusive authority figures than to risk your luck with the hordes of scary criminals out to get you.

    💬 3🔄 17⭐ 21
  • Nov 9, 2026, 6:20 AM

    @dalias I think there is a lot of truth to this. But one could just as easily extend it to the architectural choices in Linux which engender mediocre security.

    Thus, there is always going to be a bustling business of doling out patches.

    #dependency #microkernels

    💬 0🔄 0⭐ 0
  • Nov 9, 2026, 2:01 PM

    @tasket I thought it was like that until someone pointed me to where kernel folks had explicitly said it's good not to distinguish vulns from ordinary bugs because it makes it hard for vendors to maintain their own stable branches and forces them to push users onto new mainline versions.

    I don't have the reference handy but it was a real thing. This *is* intentional.

    💬 0🔄 0⭐ 0
  • Nov 8, 2026, 7:51 PM
    @dalias the disdain for stable apis for drivers is also a factor, with the constant internal treewide refactorings

    not keeping up with mainline means that eventually porting anything you need back becomes unrealistic
    💬 1🔄 1⭐ 0
  • Nov 8, 2026, 9:17 PM
    @navi @dalias Another reason I prefer microkernels.

    Though as you hint it's perfectly feasible by just having sane engineering practices.
    💬 0🔄 0⭐ 0
  • 💬 0🔄 0⭐ 6
  • Nov 8, 2026, 8:29 PM

    @dalias A lot of infosec practices seem to go back to the late 90s. Windows 95 had a lot of significant security flaws that were easily exploited, but the fundamental problem was that Windows 95 encouraged users to run with full administrative rights at all times. Meanwhile there was the rapid development of an industry that claimed to fix problems in perverse ways. People still think they need virus scanners and that NAT is for security.

    Meanwhile, the main sources of malware are Google, Microsoft, Meta, and Apple. Literally.

    EDIT: It's been pointed out to me that my memory of Windows 95 is inaccurate, that it didn't have meaningful privilege separation, and I may have been thinking of issues with a later version of Windows.

    💬 1🔄 3⭐ 23
  • Nov 11, 2026, 3:09 PM

    @foolishowl @dalias

    > Windows 95 encouraged users to run with full administrative rights at all times.

    Huh? Windows 9x didn't have a protected-mode kernel or a user-rights model *at all*, similar to MS-DOS which it kind of sat on top of. All users *had* to run with full "administrative" rights, because there was no way not to, there wasn't any other kind of unprivileged user, or any protection between the users of a system.

    💬 1🔄 0⭐ 0
  • Nov 11, 2026, 4:12 PM

    @aspragg @dalias Huh. It's been a while, but as I recall, Windows 95 had some distinction between an admin user and a regular user, and at first defaulted to making users admin users.

    💬 1🔄 0⭐ 0
  • 💬 1🔄 0⭐ 0
  • 💬 0🔄 0⭐ 0
  • Nov 8, 2026, 9:26 PM
    Amen to that. Some of these people with their smug "Unlike some people, I care about security" (of my dark masters in their quest to bind the world in chains) just really grind my gears.

    I'm certainly glad I can... hesitate on updates these days, with absolutely insecure AI generated patches being crowbarred into projects left and right.
    💬 0🔄 1⭐ 0
  • 💬 1🔄 0⭐ 0
  • Nov 9, 2026, 1:08 PM

    @dymaxion That presupposes that their answer works. It doesn't.

    Users are still getting popped, just in constantly new and different ways introduced by new things they don't even have time to learn to use safely before the rug is pulled again.

    The authorities who they demand users trust to keep them safe are the same authorities who refuse to give them the tools they need to be safe. Basic things like "don't accept media attachments from unknown senders, period".

    💬 2🔄 1⭐ 0
  • Nov 9, 2026, 1:10 PM

    @dymaxion Just like you might have to file a police report in some extreme situations despite knowing cops are not your friend, you might have to get an update from some malicious party who's catastrophically botched the security of something you're stuck depending on.

    That doesn't mean you have to trust them with 24/7 remote backdoor access or accept their narrative that they're doing it for your own good.

    💬 0🔄 1⭐ 0
  • Nov 9, 2026, 2:52 PM

    @dalias How do you fix vulnerabilities without updating software?

    Yes, most software is written badly, sometimes because the folks writing them don't have the resources they need, and sometimes because we insist on writing code like it's the 90s.

    I'm in favor of more defensive design and giving users better tools, but, for instance, if I use a mail client, I will receive media attachments from people I use email with — and that includes people I've never emailed before. I don't mind if there's an option to turn this off, but if it's not on by default, almost no one will turn it off, and it is off by default, many users will try the software and then abandon it as broken — UX is an unavoidable part of software development.

    Defensive design doesn't fix everything, though — you will always have attack surface, and it will eventually have vulnerabilities.

    We started doing automatic updates because if updates aren't automatic, they didn't get applied. Most systems have options to only apply them manually, for folks who know what they're doing, but they're off by default because it's the wrong answer at the population scale.

    Yes, there are times when malicious updates get applied. Our process for getting code to users securely is good in most places, but not perfect. We're seeing more cases where software gets taken over. A lot of them happen because the teams don't have the resources to do better. Folks are working on adding better tools for detecting malicious code to update pipelines, but that's always going to need continuous work; it can't simply be fixed, because "malice" is a human interpretation of code.

    Large organizations quarantine updates and scan and review them before applying them. It could be made easier for individuals to do this too, but very few people want spend their evenings reading patch diffs, so there's no demand to make this easier.

    💬 2🔄 0⭐ 0
  • Nov 9, 2026, 9:27 PM

    @dymaxion @dalias

    (Eleanor, we met at IFF in Valencia years ago — you loaned me a power adapter for the con, which I returned on the last day. Thank you again for that.)

    More to the point, most software is written badly because (a) software is hard and (b) the vast majority of programmers openly encourage non-professionals to write code.

    I'm one of them. You own that computer: why not learn how to control it a bit better? Why not assert your independence from the tech priesthood?

    I'm all in favor of power-to-the-people, but the combination of "software is hard" and "we encourage non-professionals to join us" results in, well, the consequences of our social choices.

    To demand perfection from software is to demand perfection from the people making the software, and that's just authoritarian and inhumane.

    The alternative requires us to acknowledge that software, even libre software, is allowed to have bugs. In this ultra-hostile network environment in which we find ourselves, that means frequent patches.

    I don't understand how saying "please apply security updates" is authoritarian. It seems quite polite to me. It's certainly not the one-size-fits-all solution we thought it was in the '90s, but I genuinely don't see the downside in making it part of today's best practices.

    But, I dunno. Maybe I'm just lacking in vision. Could be!

    💬 1🔄 0⭐ 0
  • Nov 9, 2026, 9:37 PM

    @rob @dymaxion Because there is no "please apply security updates". There aren't security updates.

    There are new, drastically different versions of the software that break users' workflows, functionality, expected privacy properties, muscle memory, accessibility, etc. Oh, and the vuln fixes are only in these new versions.

    But even if that weren't the case, the software vendor just *having* a backdoor to make changes to the user's system, which entails the potential to access any of their data, and which state authorities can force the vendor to use for that purpose, is itself authoritarian.

    💬 2🔄 3⭐ 0
  • Nov 9, 2026, 9:40 PM

    @rob @dymaxion We don't have to demand perfection from the people making software for others to use. And we certainly don't need authorities establishing boxes to check off to prove that you've been "responsible" in how you made it.

    But we do need systems that don't fail catastrophically when someone makes a mistake. This means privilege separation, sandboxes that actually work rather than trading safety for "zomg faster!!", not putting gratuitous attack surface into everything, etc.

    💬 4🔄 3⭐ 1
  • Nov 9, 2026, 9:42 PM

    @rob @dymaxion We need people committed to doing better here, and we need to stop accepting and stop trying to clone the garbage produced by corporations that keeps expanding scope and attack surface and tightly coupling everything for the sake of brand recognition and market dominance.

    💬 0🔄 1⭐ 0
  • Nov 9, 2026, 9:45 PM

    @dalias @rob You're not going to get disagreement from me about needing hardening. But there is no security mechanism conceived of that won't eventually have a bug that needs patching. It would be lovely to live in a world where software could be done right the first time, but that's a much higher level of demanding perfection than I could dream of asking for.

    💬 0🔄 0⭐ 0
  • 💬 0🔄 0⭐ 0
  • Nov 9, 2026, 9:51 PM

    @dalias @dymaxion

    @dalias @dymaxion

    You say "there are new, drastically different versions of the software that break users' workflows, functionality, expected privacy properties, muscle memory, accessibility, etc."

    Well, yeah. And these are widely regarded as dick moves that cost libre projects their users, so the overwhelming majority of libre projects *don't do that*.

    GnuPG has been trying to drop PGP 2.6 support — which has been obsolete since five years *before GnuPG 1.0 was even released* — literally since day one. Every time it gets suggested, users scream about breaking their now 40-year-old workflows and it gets decided GnuPG will keep supporting it for another few years.

    One thing libre software has always been extraordinarily strong on is the subject of data portability. If LibreOffice starts acting like dicks, take your OpenDocument files to some other app that treats you better. Heck, use an XSLT transform to put it into DocBook or LaTeX.

    This "authoritarianism" line you're on is crashing on the shoals of data portability. As long as you've got data portability, you can always leave. Even if you have to start a new project to do the same job with the same data formats.

    💬 1🔄 1⭐ 0
  • 💬 2🔄 0⭐ 0
  • Nov 9, 2026, 11:11 PM
    @dalias @rob @dymaxion Also proprietary OSes' everything, basically.

    Proprietary software more generally as well, but not quite as much usually.
    💬 0🔄 0⭐ 0
  • 💬 0🔄 0⭐ 0
  • Nov 9, 2026, 9:43 PM

    @dalias @rob How else do you solve the problem for give or take six billion people, not all of whom are functionally literate, let alone technical?

    Yeah, it would be great if teams had the capacity to backport patches to every version ever, but there's never been a software team that could do that.

    With open (or at least source-available) code, it's possible to make malicious use of update mechanisms exceptionally expensive, should folks decide to lean fully into reproducible builds and binary transparency mechanisms. I think this would be a great idea, for many reasons. However, few states are willing to get near this, because the blowback of people in their state no longer patching security vulnerabilities is basically never worth it for any single target.

    💬 1🔄 0⭐ 0
  • Nov 9, 2026, 9:48 PM

    @dymaxion @rob "How else?" isn't an answer.

    If you can't do something ethically, you don't do it at all. Stop making it all.

    That we've allowed people to be pushed into having such large parts of their lives pushed into dependency on things they don't know how to use safely, and where they're expected to just defer to an authority who has full backdoor access into every aspect of their life to "keep them safe", is incredibly and unjustifiably awful.

    💬 2🔄 1⭐ 0
  • Nov 9, 2026, 9:52 PM

    @dymaxion @rob But the end user device vulns that actually have serious impact on the user have not been that numerous, and nearly all were preventable.

    A bunch were MMS apps irresponsibly accepting and auto-decoding media content from untrusted sources.

    A bunch more were browsers doing ridiculous JIT shenanigans rather than just having a simple and safe interpreter.

    Aside from that kind of stuff, there basically isn't attack surface on normie end user devices. At times the vulns have been treated as "in the OS" and requiring OS update, but that's only because stuff was gratuitously bundled into the OS. Which was entirely avoidable; the reason it wasn't avoided was monopolist behavior.

    💬 2🔄 0⭐ 0
  • Nov 9, 2026, 9:57 PM

    @dalias @rob Your device is almost nothing but attack surface. Every piece of code that processes off-device input — every piece of radio firmware, every format parser, every piece of app code that interacts with any data from off the device, it's all attack surface.

    Yes, the iMessage bugs were bad. They not only fixed the bugs but fundamentally overhauled how external media is parsed and literally gave users a switch to halt processing of media from anyone they don't know — they actually built the thing you wanted them to build. It's called lockdown mode, and it exists specifically for iOS users targeted with nation state malware. The apple security team, for all the insane nonsense the rest of the company is doing, is fighting this fight at a higher level, frankly, than 99.5% of the rest of the industry.

    💬 1🔄 0⭐ 0
  • Nov 9, 2026, 9:59 PM

    @dymaxion @rob Yes, Apple is (or at least was) moving in the right direction on that. Except only doing it in lockdown mode, that also forces you to make a lot of other tradeoffs. Media attachments should just never be decoded by default except for existing trusted contacts with e2ee channels.

    💬 2🔄 0⭐ 0
  • Nov 9, 2026, 10:03 PM

    @dalias @rob Cool. I look forward to seeing the system you go build — my calendar is looking pretty open in 2067, so just let me know when the release party is.

    The rest of us are going to go keep fighting for users in the real world.

    I think I'll end my participation here now — I was really hoping you'd come back with a conversation more connected to the world we live in, but I'm not sure there's much more to say.

    💬 0🔄 0⭐ 0
  • Nov 9, 2026, 10:03 PM

    @dymaxion @rob And the radio firmware is not attack surface if you architect the device correctly. Doing it wrong, like they do, is a commercial choice. One that's pressuring them to make the other bad and unethical choices I'm talking about.

    If you isolate the radio entirely from the host computer with just a generic high speed data channel in between, you don't have to worry about attacks on it. At worst they're DoS.

    💬 0🔄 1⭐ 0
  • Nov 9, 2026, 11:11 PM

    @dalias @dymaxion @rob

    A bunch more were browsers doing ridiculous JIT shenanigans rather than just having a simple and safe interpreter.

    Worth noting that we know how to do JIT properly and safely.

    They deliberately did not, for the sake of expediency & "performance".

    💬 2🔄 0⭐ 0
  • Nov 9, 2026, 11:25 PM

    @lispi314
    @dalias @rob We know how to do JIT in ways that formally guarantee that bugs impacting security are impossible?

    Yes, they made trade-offs. Were they the right ones, given a few billion users with low resource machines? I don't know. And yes, there are other places where they could easily have avoided perf bloat, but seeing teams as monolithic isn't really helpful when you're trying to guide engineering work — I know browser perf teams have genuinely been trying hard.

    💬 2🔄 0⭐ 0
  • Nov 9, 2026, 11:32 PM

    @dymaxion @lispi314 @rob Browser perf is like highway construction. It's a no-win game. As soon as you increase perf, adtech malware and bad web app frameworks will just expand to consume all available cycles until performance becomes intolerable again.

    💬 1🔄 0⭐ 0
  • 💬 0🔄 0⭐ 0
  • Nov 9, 2026, 11:35 PM

    @dymaxion @dalias @rob

    We know how to do JIT in ways that formally guarantee that bugs impacting security are impossible?

    We know how to do JIT and assembly with full respect to the type system, contract mechanisms, and other language semantics of a higher level language, yes.

    So if the software isn't broken without JIT, JIT done in such a way does not break it either.

    Some useful keywords for relevant papers here would be: "typed assembly" and "proof-carrying code"

    Were they the right ones, given a few billion users with low resource machines?

    They weren't. The resource issue is entirely addressable by better system design and not insisting on dead languages.

    This applies to much more than just browsers, of course. I would apply it to the entire system.

    Anything short of the most constrained of microcontrollers would work then.

    Smalltalk ran in graphical mode on computers with less resources than several Arduinos.

    💬 1🔄 0⭐ 0
  • Nov 9, 2026, 11:42 PM

    @lispi314
    @dalias @rob Yes, in theory, a perfect JIT written with all the defensive techniques we have should not introduce new vulnerabilities. However, even if we do all that, what we're going to have is an actual JIT, and it will have bugs.

    Assuming any piece of software will not have security bugs has been comprehensively shown to be a mistake for anything dealing with real systems. "I have merely proven this code to be correct, not tested it" etc.

    Yes, we can do better. I've spent twenty years arguing we need to. I also have to work with real engineering teams to get them to do better in practice, and I've never seen a team in a position to do half the things we know we should do.

    💬 1🔄 0⭐ 0
  • Nov 9, 2026, 11:58 PM

    @dymaxion @dalias @rob

    However, even if we do all that, what we're going to have is an actual JIT, and it will have bugs.

    I believe that the size of the JIT is sufficiently constrained that full formal verification is possible.

    "I have merely proven this code to be correct, not tested it" etc.

    In all of those cases, the proof was clearly not complete and ignored various interfaces.

    The main case where this is false is when physical interference is a consideration, as this requires modeling correctness beyond software/logical interactions.

    This is usually supposed to be handled by the hardware. ECC is an example.

    Mainframes and aeronautics have various more examples. Software design is still affected, but it's entirely insufficient on its own to handle all the issues they purport to address.

    Assuming any piece of software will not have security bugs has been comprehensively shown to be a mistake for anything dealing with real systems.

    Indeed, even when the program has been correctly compiled to native-equivalent execution, there is zero reason why it should have ambient authority or universal capabilities.

    The problem domain here was "JIT should not introduce further hazards", but even in the unlikely event that it does, those hazards should still be subject to all the other containment that affects every piece of software on the system.

    I also have to work with real engineering teams to get them to do better in practice, and I've never seen a team in a position to do half the things we know we should do.

    And now we really do get back to "is it end capitalism [...]?" as you suggested in your other post.

    I'm still not convinced it's strictly required, but certainly one cannot expect zero-liability corposcum do to proper engineering in any way that resembles what I suggest.

    If they had the kind of liability other engineering fields have for fuckups that cause harm, grievous harm or death to users or third parties?

    Now that might change a bit.

    💬 0🔄 0⭐ 0
  • Nov 9, 2026, 11:47 PM

    @lispi314 @dymaxion @rob Even if that's true on a theoretical level, I'm not very okay with the concept of moving code out from the embedded-language execution environment we control to native code on the embedded-language host on the basis of trusting it's correct/safe. Doing that is inherently removing a layer of defense.

    💬 1🔄 0⭐ 0
  • Nov 10, 2026, 12:00 AM
    @dalias @dymaxion @rob It is, indeed, a tradeoff.

    One that should not be mandatory either.

    Various Lisp Machines were fully capable of using interpreted drivers (with harsh performance degradation) without native compilation.

    It was actually a semi-common user-error to do so and forget to compile them, then wondering why the performance wasn't matching up expectations.
    💬 0🔄 0⭐ 0
  • Nov 9, 2026, 9:53 PM

    @dalias @rob Ok, so it's somewhat unlikely that, until we hit the final collapse of globally organized civilization, we're going to stop using software.

    We have learned a whole lot about how to build systems securely in the past 75-odd years of writing code, but chief among those is that you harden your systems for the place you'd like to be when a compromise happens, because no matter how careful we are, bugs are inevitable.

    The singular counterexample we have is the Shuttle Software Group, who never had a bug in production and only ever found one bug in QA. However, a) they were only dealing with functional bugs, not attacks, b) they had a completely bespoke uniquely redundant environment, and c) they produced one line of code per developer day. Everyone else lives in sin from the start.

    💬 2🔄 0⭐ 0
  • 💬 1🔄 0⭐ 0
  • Nov 9, 2026, 10:01 PM

    @dalias @rob Ok, cool. Let's build a new microkernel with proper hardening and sandboxing and all the tools you'd like, as little legacy dependency as possible, and pick a single hardware configuration so we don't need device drivers or anything. Then we'll need a windowing system, a basic browser, and some utility apps. Let's say, very very conservatively, that we can do all of this in only a million lines of code. Let's say we have a huge team for a brand new open source OS effort — a hundred full time senior developers at the top of their craft, a separate hundred QA testers, plus technical writers, designers, UX testers, etc.

    It'll be finished in 41 years, and you still haven't written your own compiler, so you're depending on GCC.

    💬 0🔄 0⭐ 0
  • Nov 9, 2026, 10:04 PM

    @dymaxion @dalias

    HAL/S for the win.

    One of the problems we're running up against is economics and the need for growth. Yes, we absolutely could use formal methods to generate provably-correct code. Have you ever written Floyd-Hoare proofs? They suck.

    And sure, we could write our algorithms in Zed. But then we'd need to port those algorithms to something we actually had a compiler for.

    And this isn't even getting into Rice's theorem, which is sitting in the corner laughing at us whenever we think we're in control.

    Global poverty has dropped off a cliff since the information age began. A lot of that is directly attributable to software enabling better supply and distribution of goods, services, and resources. Wages in the U.S. have been stagnant for decades but the fraction of people trying to survive on $5 a day is at lows never seen in human history.

    What you're advocating — basically to stand astride software development and scream, "STOP!" — would completely cripple software production, with massive consequences for world economic growth.

    I'm not in favor of making tech bros richer, but I _am_ in favor of economic growth. It's the best tool we have to keep lifting people out of the muck.

    Anyway.

    Dude, you do you. Knock yourself out. Keep calling the software development I do authoritarian, it's okay, I don't care. I'm going to just enjoy my Rust for a while — even if I'm sure there are bugs in it.

    💬 0🔄 0⭐ 0
  • Nov 9, 2026, 11:02 PM

    @dymaxion @dalias

    Most systems have options to only apply them manually, for folks who know what they're doing, but they're off by default because it's the wrong answer at the population scale.

    Given how those settings are actively ignored?

    No, they don't have such options. They have the illusion of such options.

    How do you fix vulnerabilities without updating software?

    Not making broken software to start with sounds like a good idea.

    Having a system that doesn't default to ambient authority as well.

    UX is an unavoidable part of software development.

    So is user education if one wants anyone else but oneself to reasonably use it.

    Defensive design doesn't fix everything, though — you will always have attack surface, and it will eventually have vulnerabilities.

    That is both a hefty assumption and too imprecise to be useful.

    Attack surface that requires unrealistic vectors for remote attackers (remote here being "without physical access" is perfectly possible). I would not consider that nearly as problematic.

    There are ways to design schedulers so that the various CPU & memory bugs of the last decade are impossible to exploit.

    We started doing automatic updates because if updates aren't automatic, they didn't get applied.

    The excuse, at the time, was the dogshit design of Microsoft Windows having no package manager or any way of updating in a structured and reliable manner by the users.

    The solution wasn't adding automatic updates and dropper capacity to every program.

    The solution was moving off Microsoft's garbage or forcing them to fix it.

    Third-party package managers are a nice effort but insufficient since their lack of official support means most programs ignore them.

    A first-party package manager requires undue trust in an American company's goodwill & diligence, even with third-party repositories by more trustworthy parties (antitrust would be helpful here), but so does using their OS to start with.

    Yes, there are times when malicious updates get applied. Our process for getting code to users securely is good in most places, but not perfect.

    Bearing in mind that everything I wrote before still stands...

    That only works when the call isn't coming from inside the house. Linux and Microsoft both push malicious slop patches now.

    We're seeing more cases where software gets taken over. A lot of them happen because the teams don't have the resources to do better.

    The impact those malicious updates have, in first or third party software, is in considerable part possible due to bad system design & architecture.

    One can't even say Microsoft doesn't know better, they abandoned two superior OS designs that fixed a number of their problems but that never made it to market.

    In part this is because the incentives are wrong for proprietary vendors. If they can remain profitable selling garbage, they have no reason to sell anything better. Particularly when they have an effective monopoly in various ways.

    Though Google's Android has been eating at Microsoft's monopoly, but some malicious parties in Europe seem poised to make Google's a legally required monopoly.

    Folks are working on adding better tools for detecting malicious code to update pipelines, but that's always going to need continuous work; it can't simply be fixed, because "malice" is a human interpretation of code.

    Malice is a social dynamic. It can be embodied it code, in design, in UI, it doesn't require any code directly doing anything harmful in itself.

    Gross negligence is frequently indistinguishable from malice. We see this with slopware and devs so readily adopting fashtech.

    Large organizations quarantine updates and scan and review them before applying them.

    Indeed, trusted parties, as chosen by the user are a valid mitigation mechanism for malice.

    It could be made easier for individuals to do this too, but very few people want spend their evenings reading patch diffs, so there's no demand to make this easier.

    There is such demand, but corposcum very much do not want to share designs & knowledge.

    Just look at how much of Right to Repair is pulling teeth from hen (figuratively) and that's for rather mediocre results compared to what was just readily provided with one's electronics half a century ago.

    Proprietary software should include the source and all the engineering documentation for users to fix it.

    Hardware should include full specifications & firmware source. No NDAs, no bullshit.

    There is demand and it is being actively resisted.

    💬 1🔄 0⭐ 0
  • Nov 9, 2026, 11:37 PM

    @lispi314
    @dalias Reading what you're assuming about users here is like the xkcd geologists cartoon. It's good if more folks understand the systems they use in technical depth, but if your answer requires them to if they want to be safe or have functioning systems, it's inaccessible in ways that are incompatible with the society we live in. User education is great, but if you're trying to define how all software in the world should work, it has to at least pretend to work for all people.

    Do you have any actual proposal for how to get to an outcome, or is it "end capitalism and rewrite the world, and shoot any engineer who doesn't join the glorious revolution"? Like, I'm not even against that, but even if you do all of that, you're still gonna have bugs, you're still gonna have limited resources, you're still gonna have software versions, and you're still not gonna be able to backport every fix to every version.

    💬 1🔄 0⭐ 0
  • Nov 9, 2026, 11:47 PM

    @dymaxion @dalias

    It's good if more folks understand the systems they use in technical depth, but if your answer requires them to if they want to be safe or have functioning systems, it's inaccessible in ways that are incompatible with the society we live in.

    You just conflated several distinct points I made.

    They should not require that knowledge to be able to use it safely, but it should always be readily available to them if they want to.

    I actively acknowledged the use of trusted third parties chosen by the user. (And the use of an existing body of law to force OS publishers to enable it.)

    User education is great, but if you're trying to define how all software in the world should work, it has to at least pretend to work for all people.

    A single approach doesn't work for everyone, that is one of the reasons I presented several, which for the most part are not mutually exclusive.

    Do you have any actual proposal for how to get to an outcome, or is it "end capitalism and rewrite the world, and shoot any engineer who doesn't join the glorious revolution"?

    Honestly, just actually applying antitrust and abolishing the DMCA & its equivalents (easy since the USA unilaterally violated basically every single trade agreement that was conditional to those laws, so they're not even really valid anymore) would be a good start.

    Maintain Right to Repair and competitive compatibility in consideration of that and you've got a fairly considerable improvement over the current situation.

    It doesn't even require abolishing capitalism, though that should also be done but it's not strictly required for this.

    Like, I'm not even against that, but even if you do all of that, you're still gonna have bugs

    True, though with a good design the consequences of practically all of them can be reduced to "denial of service".

    With better storage systems, such as versioning ones, it becomes trivial for a user to rollback and recover whatever limited surface the buggy or malicious software had access to and damaged.

    you're still gonna have limited resources

    Indeed, and the current trends in software engineering are actively worsening the problem and disrespectful of resource limitations.

    It's effectively impossible to modify & build Android on anything but a fairly hefty developer workstation. That's ridiculous.

    It should be exactly as reprogrammable as Lain's HandiNavi if one feels like doing so. There shouldn't even be need of a secondary computer except if one unwisely decides to ignore safety precautions and messes with core systems that crash it irrecoverably on its own (even then, multiple system images being saved in a ring buffer could mitigate that).

    💬 1🔄 0⭐ 0
  • 💬 0🔄 0⭐ 0
  • Nov 8, 2026, 7:02 PM

    @dalias Hm not sure.

    Agree on the general problem, but those guys are just bastards independent of this specific problem.
    They also show up in it, but not as a cause.

    I would argue it's more the general trends of the time. ZIRP, VC, Hyperscaling.

    If you're not up to date you're going to get left behind/leapfrogged by a 17yo from the bay area macrodosing adderall and all that crap.

    The general societal trend pushed towards demanding more regardless of how sensible (and how actually "more") that more even was.

    I mean look at culture. Marvelslop 27 in cinemas now. That's just a reflection of that.

    Consumerism and infinite free money eroded people's perception of what value even means, as that only really shows when encountering friction.

    Friction that has been the enemy of the SV.

    💬 1🔄 0⭐ 3
  • Nov 8, 2026, 7:13 PM

    @Hypfer I don't think normal people who want to use software for actual useful stuff in their lives even know those words. They're just being told by "experts" that they need to keep up with updates on their PCs, phones, etc.

    💬 2🔄 0⭐ 4
  • Nov 8, 2026, 7:28 PM

    @dalias @Hypfer

    I mean look at culture. Marvelslop 27 in cinemas now. That's just a reflection of that.

    I don't think anyone in my family even goes to the cinema anymore, outside of one that's into art films and that's not the same places.

    I'm the only computer person among them.

    💬 0🔄 0⭐ 0
  • Nov 8, 2026, 8:06 PM

    @dalias Probably, but one doesn't need to actually understand the concept or terms or anything like that to be influenced by it.

    Just following the defaults is enough, as you say, yeah.

    💬 0🔄 0⭐ 0
  • 💬 1🔄 1⭐ 0
  • 💬 1🔄 0⭐ 0