For quite some time, I have felt some unease at the public discourse around OpenSource. In the past few years, we have seen a growing discourse around the sustainability and security of the large body of OpenSource software.

If we combine these two sets of data^1 we obtain a fascinating result^2.

  • 46% of all code out there, in every app, is maintained by hobbyists
  • 13,8% is maintained by “I sometimes get a bit of pocket money for my code”
  • 40% of all code out there is maintained by an industry-paid person

So, nearly 60% of all code being actively shipped in an app or product in the wild is hobbyist-maintained open-source.

See also this discussion on lobste.rs on the economics of the average (as in median) open source project:

https://lobste.rs/s/ftwkvo/hobbyist_maintainer_economic_gravity

To sum up, apparently most open source projects are small, and aren’t funded as paid work. And they matter because of their number, which has the effect that they make up a large part of all software in use.

  • Dogiedog64@lemmy.world
    121·
    1 day ago

    In other words, 60% of code used in any piece of software today can be assumed stolen from normal people by corporations too greedy to pay for it. Great.

    • HaraldvonBlauzahn@feddit.orgOP
      5·
      23 hours ago

      Depends on the license.

      And yes, you could say that the relationship between companies and open source contributors is a bit parasitic at times. But a part of them don’t care because for a start, they are not motivated by money to write open source software.

  • HaraldvonBlauzahn@feddit.orgOP
    281·
    12 hours ago

    I think that one reason why the proportion of open source code grows is software quality:

    Companies would love to own all their code. So, when they employ people who work on proprietary code, the amount of proprietary code should grow, shouldn’t it?

    Except that companies have mostly very short-term goals. And this affects quality: A lot of proprietary code has quite shit quality and is not really maintainable. Which has the effect that either the project dies, or becomes very slow to develop further, because of tons of technical debt.

    FOSS projects do not have this constraint on short-term returns, so they often have better quality. Which makes it more likely that these projects live and prosper a bit longer. The short-term difference might not be even large - but the process goes year for year, round for round, and it becomes an evolutionary advantage.

    In the end, everyone uses that Finnish students former hobby kernel project, and nobody uses Windows 95 - or wants to use its shitty successors.

    (And this is why I also think that Guix will win in the long term: The capability to re-produce all components of a program or system from freely available source is, in the long run, an overwhelming evolutionary advantage.)

    • dustycups@aussie.zone
      4·
      9 hours ago

      Guix vs Nix will be an interesting example. Nix has a way bigger user base right now but it has the whole Anduril & governance issue.
      What is your experience with guix like? Does getting away from systemd affect things?

      • HaraldvonBlauzahn@feddit.orgOP
        1·
        8 hours ago

        Guix vs Nix will be an interesting example. Nix has a way bigger user base right now but it has the whole Anduril & governance issue.

        Guix has a way better configuration language and one can learn in an afternoon enough to use it productively.

        What is your experience with guix like?

        I am mainly using Guix as a package manager on top of Debian stable (and on top of my Arch install running in a vm). I use it mostly to have a reproducible development environment for my free time projects (which use Rust and Guile), and it works very nicely to that. It is also certainly a nice way to distribute software as source, with very little effort (just putting the own package definutions into a channel repo).

        Does getting away from systemd affect things?

        I have also started to run it directly on my PC as a base system. After replacing the NVidia GeForce card with an AMD Radeon one, I had no issues.

        The configuration and init system work well - the only thing I would have to do is to write my own stumpwm(*) init script, which I didn’t have time for, so I use, as a fallback, i3wm and Gnome or XFce2, what I use at work, too.

        (*) Stumpwm is a highly configurable tiling window manager written in Common Lisp. Similar to i3, but using key chords, and window manager actions are just lisp functions one can program and extend - they are called via key chords like Emacs commands.

        In respect to the init systems, I have to confess that I am mostly agnostic. As long as it works, I am fine. I think Guix is the more modern and better approach.

    • Mavvik@lemmy.ca
      12·
      1 day ago

      When I stopped using proprietary software I noticed that I stopped fearing software updates. Proprietary software is always changing things in ways that dont necessarily improve the user experience, and often make it worse. My experience with OSS has (almost) always been the opposite, every update improves the software and either adds useful features or fixes old issues I’ve had. I think the only exception to this has been Firefox. I noticed this shift in thinking most obviously when I finally switched from Windows to Linux.