[shawxe]

From many of the comments in this thread, one might think that FAANG companies invented the concept of open source software or that software doesn't exist outside the context of a "profit model." Whatever is going on at Mozilla right now, the notion that a piece of open source software even needs to be profitable (let alone supported by a single large company) in order to continue existing is ridiculous.

I'll concede that there are unique challenges associated with developing a web browser (it's certainly a moving target) and that there need to be several people working on it full time, but is that really something that can only happen when one big company/organization is funding the project? As for Rust, maybe someone could point me in the direction of the one benevolent large company that's backing GCC/G++ or CPython or Ruby?

I'm not saying what's going on with Mozilla isn't absolutely terrible, but the notion that Firefox or Rust are going to somehow just go away (and that this is what was destined to happen all along because Mozilla is not profitable) just doesn't really make any sense.

[maccard]

> but is that really something that can only happen when one big company/organization is funding the project?

Have you any examples of any large OSS projects that don't have this problem?

> As for Rust, maybe someone could point me in the direction of the one benevolent large company that's backing GCC/G++ or CPython or Ruby?

gcc [0] has a list of maintainers, which features a lot of redhat email addresses. The ruby maintainer is employed by Heroku. CPython is maintained by a RH employee. The linux kernel is mostly comprised of people paid to develop by their employers.

[0] https://github.com/gcc-mirror/gcc/blob/master/MAINTAINERS

[1MachineElf]

To the parent commenter's credit, none of those companies own the rights to the GCC/CPython/Ruby trademarks like Mozilla does with Rust.

[jpgvm]

PostgreSQL is probably the best example. It's maintained by many people from many different companies.

[maccard]

That's a really good example of the opposite, thanks! I wasn't aware of it!

[coldtea]

>Whatever is going on at Mozilla right now, the notion that a piece of open source software even needs to be profitable (let alone supported by a single large company) in order to continue existing is ridiculous.

Large FOSS projects requiring specialists (like Rust does) all seem to supported by companies paying, and often it's a large single company too, whether that's like PHP and Zend, RedHat and various projects, Mono and Xamarin, and so on.

Else you get something that takes fovered to develop further, releases are sporadic, people go on and off, etc.

Heck, GTK+ is/was one of the most adopted FOSS libs, and a dependency for tons of applications, distros, etc. And yet it just had a single dev working on it at some point (like, e.g., a person doing 300 commits each month, and another 50 persons doing 100 comits a year combined).

[narag]

It seems that projects are adopted by companies not because they control the software but because they could if needed: the code is FOSS and mature so in case of main maintainer quitting, they could pay someone to take over.

Also I wonder if browsers really need to be large projects requiring specialists or they've become this way because organisations making them are happy with such an entry barrier.

[jlokier]

> invented the concept of open source software or that software doesn't exist outside the context of a "profit model."

To be fair, the existence of open source software that is very expensive to develop has always dependend on big companies paying for it.

Firefox could be funded by several companies in collaboration, but as of right now, do you know any collection of companies with deep pockets that aren't happy enough sending users to Chrome instead?

[joepie91_]

> To be fair, the existence of open source software that is very expensive to develop has always dependend on big companies paying for it.

I think you're getting the causality wrong there. A lot of the "open-source" (often barely) software built and funded by large corporations has a tendency of accumulating endless technical debt and complexity, and being inaccessible to outside developers. Not dissimilar to much proprietary software.

Does that mean that serious open-source software requires big companies paying for it, to maintain? No, it just means that big companies produce expensive-to-maintain software. And to top it off, often when they do so in open-source, it's actually an unnecessary reinvented wheel!

And quite often simpler, just as serious software exists that isn't so damn to expensive to maintain and that does just fine without big-corporate funding, because it hasn't suffered from the same organizational bloat and office politics.

[jlokier]

A reasonable argument, and so I've upvoted.

But even taking into account removing unnecessary complexity, a web browser that users will choose is still complex, and has a very high compatibility bar, which is also a moving target.

You might say, does the browser need to much in it? Well, for users to choose it as a daily driver, it needs to work with web standards, formal and informal, and with nearly all sites. The web standards accrue complexity due to commercial development too. So do expectations, e.g. for smooth rendering, running games, etc.

An open source "small" browser which avoids that complexity is certainly possible to write, but few people would, or could, use it as their daily driver.

(Case in point. I used an open source-ish phone for a few years, a Nokia N900. It was great fun. But ultimately I had to stop using it because the browser increasingly couldn't handle ordinary sites.)

Do you know of any "serious open-source software" of comparable scale, which does not require big companies paying for it, even taking into account the argument around unnecessary complexity?

Not much comes to mind. Linux kernel, GCC, RISC-V, things like that are predominantly developed by paid workers, whether from companies or by government & academic grants.

Debian comes to mind as a possible exception but I'm not sure, because so much of it is on the back of big projects which are themselves funded.

[joepie91_]

I agree that what I'm describing doesn't hold for a web browser. But I think it's important to remember that "web browsers" are a very unique category - I can't really think of any other software that accidentally became an operating system (and I mean that in an entirely serious way, not derisively).

While in retrospect it's understandable why it happened (economic forces etc.), it also means that the web-related specifications were never really designed with the consideration of "how could we build an operating system that doesn't highly centralize complexity". And so we're now effectively stuck with a huge pile of specifications that you pretty much have to implement to call yourself a browser.

But for most other software, this isn't true; because most software is implemented according to some pre-defined set of goals and/or requirements, and there is no external specification to satisfy, other than for some internals that can be outsourced to a library. This allows for much, much more reduction of complexity.

> Do you know of any "serious open-source software" of comparable scale, which does not require big companies paying for it, even taking into account the argument around unnecessary complexity?

The problematic part in this question is "of comparable scale". To put it bluntly, pretty much all of the software that meets that description has an inherent complexity problem, either having too broad a scope or reinventing too many wheels. So no, I don't think that at that scale corporate funding is avoidable; but I also think that the scale itself is the problem.

I do think that corporate funding is largely avoidable with a different approach to open-source development entirely; one that (re-)recognizes that open-source is about a shared public commons, not just freely downloadable software, and that prioritizes collaboration and modular, shared implementations over reinvented wheels.

Unfortunately we have a lot of cultural issues to fix to get there, not the least of which is the recent-ish appropriation of "open-source" by certain companies-that-shall-not-be-named as a developer marketing tool, paying basically no mind to the "public commons" part and calling it open-source merely because it's under an open-source license and it looks good on GitHub.

That's certainly not to say that this is entirely a corporation or commercial problem, though; there's definitely also an aspect of NIH culture and dependency avoidance among individual developers, where people have wildly inaccurate ideas about the costs and benefits of dependencies, and lacking knowledge in how to manage them effectively.

One typical example of this is the JS ecosystem, which gets a lot of flak for one-liner modules[1] but was actually well on the way to addressing this problem - right up until Node.js started getting hyped up, and an endless stream of shiny reinvented wheels from startups started showing up, many of them poor copies of tools that already existed and worked well. Webpack is a notable example here, which really is just a worse Browserify in every sense.

Ultimately, this is probably the only plausible solution to this problem that I can see. Modular projects with a well-defined scope, that actually have a reasonable chance to reach feature-complete status, where the implementations are widely available and reusable in a broad variety of different projects that can themselves become feature-complete. Where only one developer has to do the work and it is then forever done. Whether that's in JS or something else entirely.

[1] https://github.com/sindresorhus/ama/issues/10#issuecomment-1...