For example 'Bad design is expensive' - how releasing your source lead to bad design? That's a complete non-sequitur.
That said, I am skeptical that many of the points in the post apply to Wolfram specifically, I suspect that is more aspirational on their part. Nonetheless, many of the points are valid as a generalization.
“Open source” is a different thing than “source-available” or “shared-source.” Many closed-source products are “source-available” in the manner you’re talking about, but this does not make them “open source.”
You’re not really an open-source project, in the conventional meaning of the term, until either
1. Your project starts accepting code contributions from the community (if perhaps after a gruelling code-contribution process); or
2. Your project’s codebase becomes licensed in a way that allows people to fork it, add their own changes, and then use the result themselves to achieve their own ends (if perhaps only non-commercial ends.)
Which are two sides of the same coin, really; they both imply that people will be tinkering inside your code; and that the “canonical” version of your code in everyone else’s mind might then become the version that the community thinks is better, rather than your official release.
> SQLite source code is in the public-domain and is free to everyone to use for any purpose.
That being said, I agree with your sibling poster that "open contribution" is not a requirement for "open source".
> Similar to SQLite, diagrams.net is open source but closed to contributions.
> The level of complexity of this project means that even simple changes can break a lot of other moving parts. The amount of testing required is far more than it first seems. If we were to receive a PR, we'd have to basically throw it away and write it how we want it to be implemented.
> We are grateful for community involvement, bug reports, & feature requests. We do not wish to come off as anything but welcoming, however, we've made the decision to keep this project closed to contributions for the long term viability of the project.
> 1. Your project starts accepting code contributions from the community (if perhaps after a gruelling code-contribution process); or
> 2. Your project’s codebase becomes licensed in a way that allows people to fork it, add their own changes, and then use the result themselves to achieve their own ends (if perhaps only non-commercial ends.)
There is a formal definition of Open Source by the Open Source Initiative:
Only 2 is open source (but the no-commercial condition means this it is not), while only 1 is not open source.
This is not the conventional meaning of the term, and has repeatedly been used as an avenue to attack the concept in general.
As a comparison, how happy would you be calling a system where you can only vote for candidates approved by a single leader a "Democracy". Under these standards, both the USSR and China are democracies.
The differences matter, it is not pedantry and it is not some organization enforcing "their definition" overtop of what people "commonly think".
I’ll restate. My descriptivist definition of the term “open-source”, was that something is “open-source” if you are free to do at least one of either forking the thing for your own use, or modifying the thing and pushing those modifications upstream. In other words, “open-source” software is software where you’re free to notice a flaw in the program and, by some mechanism, get it fixed in such a way that other people can benefit from the fix.
And yes, the OSI definition of “Open Source” is an organization enforcing an arbitrary definition, because it disagrees with many uses of the term “open source” — specifically, the OSI considers GPL-licensed software to not be capital-letters “Open Source”, despite everyone conventionally considering it regular-adjective “open-source”. (The FSF does a similar brain-damaged thing with the term “Free Software”, which has not-much to do with what people would call “free software” — but at least “free software” isn’t a very common term in modern parlance; people aren’t constantly talking about “free software” with the FSF then misconstruing their words as if they had said “Free Software.” Which is exactly what the OSI does when people talk about “open-source software”, and then the OSI misconstrues their statements as statements about “Open Source software.”)
Yes, this is exactly why pedants use the term “FOSS” — i.e. “Free and Open Source Software”, a union-ing of the set of software that is FSF-jargon “Free Software” with the set of software that is OSI-jargon “Open Source Software.”
Regular people, who aren’t trying to be sycophants toward these two organizations, on the other hand, just use the uncapitalized adjective open-source to refer to this larger set.
What? OSI disagrees with you.
https://opensource.org/licenses/alphabetical
"Free software", "open source software", and "free and open source software" are often used interchangeably because they refer to software that is largely protected by the same set of licenses. The terms differ by emphasizing different aspects of the philosophy behind FOSS.[1]
[1] https://www.gnu.org/philosophy/open-source-misses-the-point....
Respectfully, this definition of "open-source" does not match common use, even with a loose colloquial interpretation in mind. As commonly understood, an "open-source" license requires the ability to acquire the source, and to modify it, and to redistribute it.
Your definition, quoted above, would call open-source a license that allowed for personal modifications to source but forbade redistribution of those modifications. Your definition would also call open-source a license that required all modifications of the source to be made through a single point of central control. I think both of these cases fail even loose understandings of what "Open Source/open-source" is. I do think they both describe "source available".
You draw a distinction between "open-source" as a colloquial term and "Open Source" as defined by the OSI, but I don't think this isn't very compelling or useful. Sure, language evolves and people use terms incorrectly all the time, but that doesn't make erroneous use correct. In particular, "Open Source" is used as a legal criteria for a set of software licenses, so precision in its definition is important. Also, I have not personally come across any cases where there was any material difference between colloquial use of the term open-source and precise definition of Open Source as defined by the OSI. Do you have anything to cite that justifies a distinction here?
So I beg you to reconsider the idea that the OSI is "some organization who just decided to name themselves after the term" and the idea that "Open Source" is a term "defined loosely by how people use it." In point of historical fact, the term was first used by the people behind the organization, who formed it to popularize it as a new concept, and an alternative to "Free Software": https://web.archive.org/web/20021001164015/http://www.openso.... The OSI is not some organization formed to co-opt and redefine the term for their own purposes after it was already in common use.
I do agree with you that often times people think of specific project management structures when talking about open-source development. I.e. the debates about what makes for a successful open-source project, cultivating a community, making it easy for community members to contribute, etc. There can be non-open-source projects using open-source development methodologies, sure, but it doesn't make them "open-source" even in a colloquial sense. The sole criteria is always the license granted to users of the software.
As others have said, #1 is not really necessary since no open source project needs to accept contributions from anyone. #2, on the other hand, is absolutely necessary because open source software must allow users the freedom to copy, modify, and use the code as they wish.
> (if perhaps only non-commercial ends.)
However, software under licenses that forbid users from using the code for certain purposes (including commercial purposes) are not open source. Both the OSI[1] and the FSF[2] object to this type of restriction. Allowing arbitrary restrictions on use would raise the question of the types of discrimination that should be allowed in FOSS licenses, which is something many in the free and open source software community prefer not to deal with.
[1] https://opensource.org/osd#fields-of-endeavor: The license must not restrict anyone from making use of the program in a specific field of endeavor. For example, it may not restrict the program from being used in a business, or from being used for genetic research.
[2] https://www.gnu.org/philosophy/free-sw.html#selling: “Free software” does not mean “noncommercial.” On the contrary, a free program must be available for commercial use, commercial development, and commercial distribution.
Emphatic agreement.
Bryan Cantrill touched on this too:
"...we [now] know that OpenSolaris didn’t go far enough: even though the right to fork was understood, there was not enough attention paid to the power to fork. As a result, the operating system never quite got to being 100% open"
http://dtrace.org/blogs/bmc/2010/08/03/opensolaris-and-the-p...
I experienced this first hand while being paid to work on FOSS. At the time, I just couldn't figure out why our very well resourced, well intentioned project was chowdering. Cantrill's illuminating insight, per usual, was spot on.
--
To the pedants arguing with u/derefr: Stop it. Step back, get curious, ask u/derefr to clarify. u/derefr is trying to say something important.
Some of us have actual experience with this stuff, not covered in the manual. It often takes great effort to reflect and articulate novel experiences. Especially when those experiences don't meet anyone's expectations.
"In theory, theory and practice are the same. In practice, they are not."
--
Further, definitions, rules, bylaws, and code of conducts are just starting points. Ever DM a role playing game? Tried to get your local party to approve a resolution? Had your day in court?
As if some formal definition somewhere is the last word on running a successful FOSS project. Please.
Human projects are at least as complicated as the humans themselves.
http://www.catb.org/~esr/writings/cathedral-bazaar/cathedral...
From Wikipedia:
>In 1998, the essay helped the final push for Netscape Communications Corporation to release the source code for Netscape Communicator and start the Mozilla project; it was cited by Frank Hecker and other employees as an outside independent validation of his arguments.
Netscape's public recognition of this influence brought Raymond renown in hacker culture.
The way to interpret his argument is to imagine an alternate past history where Mathematica was open source from the beginning and how that would have lead to an inferior product. He wrote:
>[...] I think that it would not have been possible to create the Wolfram technology stack using a free and open-source model.
So instead of thinking they can just go ahead and open source what they have today and everything would be just fine, we need to consider how game theory would have played out in an alternate universe where they tried FOSS model from the beginning.
Maybe his argument is still flawed but to at least entertain his scenario, let's study other projects and compare:
- open source GIMP is considered very good -- but also is several years behind closed-source Adobe Photoshop in features
- OpenCAD, OpenSCAD not as full-featured as proprietary Autodesk, SolidWorks, etc
- LibreOffice has less features the MS Office
- Code::Blocks and Eclipse as IDE for C++ coding not as good as MS Visual Studio
- OpenStack less features than AWS
- SageMath has less symbolic computing features than Wolfram Mathematica
To counterbalance the above, we can try to identify open source projects that are equal or superior to proprietary solutions:
- LibOpus is superior algorithm to Fraunhofer FDK AAC
- Linux (server) is comparable or superior to MS Windows (Server).
- GCC, Clang comparable to Microsoft "cl.exe" compiler.
Is there a pattern to the above? It seems like a combination of :
- big complex software with lots of features
- GUI
... often means that open-source collaboration model falls behind the proprietary commercial offerings. Why?
So if Wolfram tried to open-source Mathematica from the beginning of its history, a different proprietary XYZ software may have outcompeted them. E.g. the salaried programmers working on today's Mathematica wouldn't have worked on the open-source Mathematica for free because they would have been at XYZ Corporation. In that alternate timeline, we'd complain today that "Mathematica isn't as good as XYZ"
Interaction Design (IxD) isn’t something that can be done piecemeal; it needs to be done top-down, with an overarching vision, to achieve its ends (an intuitive design.) Intuition comes from obvious implicit structure, where you can easily “get into the mind of” the designer, discover their mental model, and then use it to predict how other features will work. If there’s no single designer (or very-tightly-constraining design document) then there’s no unified mental model to learn, and so no intuition.
And there are relatively-few professional designers in the open-source community.
It’s easy and low-friction for a professional programmer to “scratch their own itch” by implementing just one little change in a piece of software, and by that means, FOSS software’s source code quality can be improved piecemeal. But it’s both difficult (you have to re-do everything at once for it to help) and high-friction (hard to convince the software maintainers to accept the change) to contribute a design change to FOSS software. So useful FOSS software design changes are almost impractical (unless the stars align); and so professional designers just don’t bother to even try to take part in the community.
So instead, FOSS software just tends to languish without any unified design vision ever being applied to it. (Or with a bad, arbitrary, and unintuitive design vision being contributed at some point by some inexperienced designer, and being accepted because the maintainers are all programmers with no sense for IxD themselves.)
There’s also the fact that a lot of IxD needs to be informed by data — e.g. user workflow studies — that cost money to run; and FOSS projects don’t tend to have the budget for this, or don’t tend to see it as a priority for spending what budget they do have, since they have no “design advocate” on the team to ask for it.
The four essential freedoms[1] might not make you rich, but they will keep providing you with true freedom.
Wolfram Mathematica would be a more valuable contribution to the future of humankind, if the essential freedoms were guaranteed.
[1] gnu.org The Free Software Definition: The four essential freedoms.
I already split my designs about 50/50 between Altium and KiCad--and that's before KiCad 6.0 which is imminent (6.0RC2 exists right now).
1) KiCad has one killer feature: it's cross platform.
I would argue that this will, over time, kill anything that isn't. Mostly because "open a VM in the cloud and do all your work there" is becoming really common.
2) PCB software, by and large, doesn't need new features. PCB software does need features that work.
Altium is infuriating with not killing bugs and introducing new ones every release.
3) Altium and bunch are basically blocking access to libraries without a subscription fee. That's going to erase Altium for use by small people. This drives me up a tree because it prevents me from sharing a design.
KiCad will slowly but surely eat everything at the bottom and then start upwards--there's just simply no other decent alternative in the space.
This is why I suggest that Altium is likely to be the first victim.
The non-Altium proprietary systems have a lot of legacy to hold them in place (like parts database integration across your company). In addition, they do have some very advanced features around routing matched memory buses and the like.
If, however, your design doesn't need that, KiCad will cover you, and Altium won't bring anything you need to the table.
I'm learning PCB design with https://github.com/horizon-eda/horizon instead — and here library (pool) management comes first. You actually place full "parts" (that associate symbols and footprints and other metadata) onto schematics — and if you don't want to decide on a particular model number, you can still place a "base" part (e.g. "generic 5k resistor") and change it later. Oh, and the schematic editor actually edits nets, rather than what KiCad does (seemingly just a basic CAD drawing that gets analyzed into a netlist as a very separate explicit step).
1) I see its value. The cacophony needs to be tamed. And a larger company can dedicate staff to keeping the library up-to-date and organized.
But it's kind of like the problems between a monorepo and multiple repositories.
I've never been part of a company where we could afford to dedicate people to BOM management and library control. I know a really good person who does this--but the companies she works at move at a sclerotic pace. They're medical or aerospace. They have zillions of ISO certifications and testing requirements. You have to file 3 forms to put a new part in the "system". And this is fine--I want someone like her preventing random changes sneaking into a medical device, thanks.
And even still, she has to fight with people every day to hold back the chaos.
2) Everybody has a different notion of "library management" and someone else's version will always be an impediment.
"Library management" is, practically by definition, opinionated. Mine is too.
I have a very idiosyncratic way of parts numbering my resistors, capacitors, inductors and a few other things in the system. It's optimized for the fact that if you put things in boxes in order sorted by those numbers, I can browse through our inventory very quickly and pull parts, values, and footprints that I need as well as know if I don't have something or have a substitute. All without having to consult some master spreadsheet or database that will always be out of date.
It drives the aforementioned library organizer crazy. She wants me to use the "standard" parts numbers and classifications. However, she also acknowledges that I have a solid reason for what I chose. If I ever manage to hire her, I will let her at it and I will comply with what she wants.
> "manually match symbols to footprints" was its approach to library management :/
It is, but I also find that "footprint management" at the schematic simply isn't as useful as people make it out to be. "Generic" footprints are fine when you're throwing around DIP chips or 1206 components. However, footprints get a lot less "generic" and interchangeable when you're working with 0402 and smaller components.
A lot of my components wind up with "unique" footprints anyway.
Altium was about to be a good high-end piece of software until they did this. Now it's homeless and it will lose to KiCAD for low-end things and Cadence for high-end.
Altium had just gotten to the point that everybody providing chips was also providing an Altium library footprint and symbol.
It was really nice--for about 12-18 months.
And then I started getting Altium libraries that I couldn't pull the symbol out of and couldn't use without being logged in.
Fscking idiots. Talk about snatching defeat from the jaws of victory.
They had finally reached the point that they were an alternative to Orcad in commercial engagements, and then they gave it away in order to try to go after subscription revenue.
I literally picked up KiCad the day after I couldn't extract a symbol from an Altium library and add a couple of missing pins for a new part. I was that infuriated.
Right now, I'm evaluating KiCad 6.0 for work. I'll probably transfer over completely for personal projects (I've been doing more and more personal projects in KiCad over time with only PCB->Schematic back annotation holding me back from full transfer--that's fixed in 6.0 with the new file formats). It may take a bit, but I'll probably transfer over to KiCad for work projects that I'm the only designer on once I get a couple of projects under my belt with KiCad 6.0.
> open a VM in the cloud and do all your work there
is something that will allow you to run any "platform" instead of being restricted to your(s) ?
It the reason why, VSCode, for example, runs your editor locally even if it's running the compilers and stuff remotely.
Second, some software builds on a body of proprietary domain knowledge that someone happens to own. I'd put mechanical CAD in that category. Probably the symbolic computing technology of Mathematica as well. In some cases, users of specialized engineering software actually put up with horrifying user interfaces because the software vendor has a lock on the domain knowledge.
The successes of open source include anything without a user interface, such as the infrastructure of the universe, and non domain specific programming tools.
OSS GUIs are exactly what you get if you leave it completely up to an army of pure programmers (whether well-paid or not).
I totally get open-source for libraries/components/building blocks/etc, and strategies like “commoditise your complements” have been mentioned elsewhere. But I’m struggling to see how open-sourcing the actual end-user product isn’t just literally giving away everything for free?
OBS is another counterexample that is heavy on GUI and absolutely superior to similar solutions (where they don't just fork it and hide it).
Proprietary and open-source modes share the same challenges. 1. Developers need incentives and it has to be sustainable. Money is the biggest of them but reputation, fun and self-realization also matters. 2. Organization and scale. A team of experts supported by staff can do a lot more than a single developer. But a large corporation is inefficient and can fail to deliver. 3. Momentum. It's difficult for a software to compete with large established softwares like AutoDesk, MS Office and Photoshop even if delivers the same features and performance.
No they didn't and that's why I put those lagging open-source projects as examples to make readers imagine that an alternate-history-open-source Mathematica may have lagged behind like them too.
I think you lost track of the argument put forth by this thread's essay from Jon McLoone of Wolfram. Your emphasis about "no big budget" actually supports his listed benefits of the paid model in: https://blog.wolfram.com/2019/04/02/why-wolfram-tech-isnt-op...
Again, when he wrote : >[...] I think that it would not have been possible to create the Wolfram technology stack using a free and open-source model.
... he's saying you wouldn't have the comprehensive Mathematica product we see today with the open source model. Perhaps the histories of how GIMP/OpenCAD/SageMath evolved supports his point that Mathematica was correct in not choosing their open-source model?
The company that created Java went out of business and was sold to Oracle for a fraction of its original worth. So Java was a business failure -- or at least I'd be interested to see someone defend Java as a business success.
So I think it's realistic to at least engage with their argument seriously rather than dismiss it.
The argument is that open source licenses are incompatible with the kind paid license they're offering their customers. These licenses pay for the salary of their skilled employees.
Oracle makes money EXACTLY the same way -- by selling commercial licenses to a non-open-source database. That's why Java can be open source and not bankrupt the company.
Again, the argument here seems to be Just come up with a different business that makes hundreds of millions of dollars and use that to pay for Wolfram !
-----
edit: Since this comment is highly upvoted and visible, I'll mention that I'm seeking funding for a compiler engineer for the Oil shell, which I just mentioned on the blog:
http://www.oilshell.org/blog/2021/12/backlog-assess.html#mor...
So I know from over 5 years of direct personal experience that compiler engineers don't just show up to your open source project and start implementing things! Even if you have tens of thousands of readers on Hacker News for years. (Oil has had 48 contributors but not very consistently, which is understandable.)
To be clear, I did not expect help! I have asked for it, but I thought I would be able to finish it myself. So it looks like hiring someone with specialized skills is the most realistic way to accelerate the project (now that the language design is in good shape).
This funding is to finish the Python to C++ translation, which is already half done. Example:
Oil's Parser is 160x to 200x Faster Than It Was 2 Years Ago http://www.oilshell.org/blog/2020/01/parser-benchmarks.html (lots of progress since then)
I'm applying for 50K euros of funding from NLNet. Also in the process of setting up Github Sponsors. E-mail me at andy@oilshell.org if you want to make a donation -- I think I will need at least $250K to properly pay for this position. If you're a professional programmer and spend 2 hours fussing with a shell script, that's probably worth a few hundreds dollars.
I'll start mentioning this in more posts when everything is set up, but I thought I would use this extremely relevant topic to raise awareness. Programming languages don't pay for themselves! https://www.oilshell.org/release/latest/doc/oil-language-tou...
I don’t see them making that argument in all these points.
For example they say
> Crowd-sourced decisions can be bad for you
Well ok that’s a valid point so… don’t do that. Crowd sourcing design decisions or code is not a fundamental part of open source. You can have open source but do all the development internally if you want to.
I think they’re confusing source licensing with a development methodology.
Which is why as nitpicky as it sounds, we should really be making an effort not to use the term "open source" to refer to both.
Something is Open Sources if the code is published under a license that grants the user the right to study, change and redistribute to anyone and for any purpose.
There is other similar things, like source available, or stricter subsets like Free Software. And there is many things associated with open source, like collaborative development in public, community building and so on.
This is certainly not a universally accepted definition. ‘Open source’ has long been a generic term for any situation in which the source is available. People may want it to be a term of art with a technical definition, but that isn’t how it is used in general.
That's how some people define open source. Other people use it to mean being able to see the source.
There is absolutely no reason to have any doubt about the true meaning of the term when this definition is on every search result on Googles first page, in Wikipedia, when it's that name of a non-profit that defines it like that and when the page that literally is called opensource.org defines it like that.
This is not about owning a term, it's simply about the fact that term had a definition that people agree on. The fact that some people don't know about that definition or that some people don't agree with it doesn't change it.
Lol how is it 'official'? Who officiated it?
The folks who coined the term were among those that led the OSI.
> The “open source” label was created at a strategy session held on February 3rd, 1998 in Palo Alto, California, shortly after the announcement of the release of the Netscape source code. The strategy session grew from a realization that the attention around the Netscape announcement had created an opportunity to educate and advocate for the superiority of an open development process.
> Two of those present at the Palo Alto meeting (Eric Raymond and Michael Tiemann) would later serve as presidents of OSI, and other attendees (including Todd Andersen, Jon “maddog” Hall, Larry Augustin, and Sam Ockman) became key early supporters of the organization.
These folks went on to create the Open Source Definition: https://opensource.org/docs/osd
The folks who created the term started an organization named after the term, created an official definition, and registered the domain. If that's not enough for us to have an official definition, what does it take? And what do we gain by arguing about this? Reading your posts in this thread (and elsewhere), my impression is that you're invested in insisting that "open source" doesn't have that definition, but I can't figure out what your motivation is.
FWIW, my motivation is to create an environment where terms have precise meaning so we can discuss complex issues (like copyright, licensing, development models, etc.) effectively. If we're wrangling over terms and language all the time, communication becomes much more difficult.
You can see the term gaining popularity prior to 3 Feb 1998, and there are references to for example BSD being 'open source' as far back as 1990.
https://books.google.com/ngrams/graph?content=open+source%2C...
Martin's article pleads with readers not to be pedantic when using the term, but offers no alternative definition, beyond 'let people use it when they can read source code'. Perhaps that's the proposed usage you and Martin prefer?
If I'm understanding your position correctly, perhaps you would agree that Ocarina of Time has now been released as open source?
https://arstechnica.com/gaming/2021/11/reverse-engineering-t...
If so, the term is uselessly vague, as it says nothing about the rights of the licensee. In this sense, 'Free Software' has much more meaning...perhaps RMS was onto something!
If the OSI picked a term that wasn't simply descriptive they could trademark it, then they could enforce their definition and there would be no ambiguity. That would be better for everyone.
“Open source” has older non-software uses, most notably in the intelligence context, where it picks up sharply in the 1980s:
https://books.google.com/ngrams/graph?content=open+source+in...
I'm a suspicious, cynical person, so I think that's deliberate.
Conflation is a very useful rhetorical trick.
I don't know that open sourcing Java killed Sun. More likely it was Intel coming close enough to SPARC performance at a lower price, and Linux coming close enough to Enterprise reliability also at a lower price. But it's certainly true that open sourcing Java and Solaris didn't save Sun.
Likewise, open sourcing Mozilla didn't save Netscape. In fact, I would bet the vast majority of companies that start out proprietary before deciding to open source ultimately die because they're already unhealthy and doing it as an act of desperation.
If a company isn't designed from the start to support an open source model, it's very hard to make the transition and survive. And we have no right to demand they try. Just like everyone should respect the license F/OSS authors choose, everyone should respect Wolfram's right to stay proprietary.
Of course it's also important to remember that proprietary software vendors are more likely to yank the carpet from under their users without warning. Instead of demanding the vendor open source, users should just find and support open alternatives.
I think that was part of the point - let people run their existing applications on Sun hardware. Yes it was more expensive but it was also more capable. Emphasising running on lots of smaller 'commodity' instances wasn't yet the done thing at the time.
Sun was riding high on the dotcom era where every new company ran out and bought an E10000, and maybe one with less specs for a development server. I've heard stories of these being shipped before payment just so they could declare the sales early -- once the bloodbath started, it Sun was left holding the bag.
BSD and Linux on commodity hardware killed everything at Sun and Java really had nothing to do with it.
Even your more qualified point has loads of counter-examples, that companies that did not start with their software as open source find it hard to succeed at open source: Google's search engine and much other software is not open source. Many companies mix their approach to open source with proprietary systems and products. As did Sun.
That Wolfram's justifications are weak is not necessarily a knock on their decision. But the specific point that "High-level languages need more design than low-level languages" seems particularly odd. There are high level languages where all the widely used implementations are open source and few cases of them becoming chaotic. I suppose there is survivorship bias in that observation but there are also obvious reasons why no language user community would have a lot of patience for a proliferation of variants.
This doesn’t make a good argument that Microsoft is evil, so Silicon Valley created a mythology in which Netscape failed.
Netscape did not bet on open source. It didn’t fail. And the browser has a de facto monopoly anyway in the form of Chrome.
AOL bought Netscape (with stock) and the founders, Clark and Andreesen liquidated their Netscape stock. So did the investors. So did vested employees such as Zawinski.
Or to put it another way, if Netscape failed, then so did Viaweb. I don’t think the YC founders would describe Viaweb that way.
As a product, Firefox is still around. And Netscape disappeared in large part as an unsuccessful ground up rewrite as the brand continued following the company sale.
Bitcoin is not a company. Participants had different objectives. Those whose objective was to hold had success. Those whose objectives were political perhaps less so.
Entrepreneurs are in it to make money. Exits are how startups do it.
Telecom, oil, steel, and automobiles are state industries. Even if political correctness often demands pretending they are not…it wasn’t called the arsenal of democracy for nothing.
It's never worth saying this on HN. "downvoted" has temporal dependence, and so right now, for example, the comment you're replying to is not at net-negative. Just comment on what they said, not on how other HN readers are voting what they said.
https://news.ycombinator.com/item?id=29605638
And to be clear I would like an open source Wolfram -- in fact it's almost a requirement before I spend the effort to learn it! (I have never learned a proprietary language outside of work or school)
I just think it's obvious why it's not open source -- because they have a working and sustainable business model! And on the other side, I think it's great to actually pay for what you use, rather than having something free that's filled with dark patterns or irrelevant ads, etc.
It's a hard problem, and it's obvious that we still don't know the answers :)
The name Sun Microsystems is one that I, and most people, associated with microsystems - with workstations (and servers). Sun was founded in 1982 with Bill Joy as a founder, who was already a renowned programmer from CSRG. Andy Bechtolsheim had an exciting hardware design. Vinod Khosla and Scott McNealy risked starting a new company, and had enough chops to manage it into a success. Sun IPOd in 1986. Sun almost bought Apple right before Java was released.
Java was released in 1995. Sun Microsystems already had over a billion and a half dollars in revenue a quarter, which was pretty good at the time.
One reason for Java was protective - Sun wanted a language people could run on workstations and servers that it had some say over. A free, open source language was part of that, it helped in its adoption. Java was more of a defensive move, that Sun wouldn't be locked out of some kind of language ecosystem controlled by Microsoft or Netscape or other companies.
Sun wasn't a software company, they were a hardware company that released a product to defend their hardware from being locked out of competitor's ecosystems. They also weren't in a position to put out a computer language and force programmers onto it, being free and open source, and the ability to run on multiple platforms helped in its acceptance. Being able to run on multiple platforms was the whole point, they didn't want people to get locked into the Microsoft ecosystem with the release of NT 3.51 etc.
The fact that Java remains at all today is a testament to the power of open sourcing something.
Java ultimately kept their declining hardware and operating systems afloat for longer than they would have been otherwise.
Just as Java is an afterthought to Oracle's database sales today, Java originally was an afterthought to Sun's workstation sales. Java was never intended to make money directly but rather as a conduit into the money-making side of both owners.
Sun and its peers declined because PCs running Linux became good enough; selling commodity hardware is a different business model (https://yarchive.net/comp/sgi_market.html) and it's incredibly difficult to move down market.
Oracle acquired Sun because they didn't want Java be owned by a competitor (https://www.reuters.com/article/us-oracle-alphabet-trial/ora...). Java was also why IBM offered to buy Sun; it seems hard to consider Java a business failure when it's most of the remaining value of the business.
Additionally Java has been a major success to those that played into the ecosystem, people keep forgetting there were several (some are still around) commercial implementations of Java with features not available on the free beer JDK like AOT compilation.
The way Sun managed Solaris and SPARC hardware had more impact on their wallet than Java.
As an open source maintainer, the part that stood out to me was all the stuff nobody really wants to do. For example, look how long it took GIMP to switch to GTK3. In a paid corporate environment switches like that are scheduled, assigned, and implemented.
I'm very fortunate to work on a project (solvespace) that has members who tend toward different specialties - build system, macOS, Windows, C++ modernization, algorithms & math. And yet I don't get to assign tasks and expect results because we are all volunteers. If we were all paid things could go way faster.
Wolfram has been going fast for decades and would not work as OSS. The best we have in OSS is Octave, Maxima, and Julia, but none of those come close.
Most of the benefits of open source (for the company) would come from running it as a community project, which would imply giving up some of the control. Simply throwing the code over the wall without accepting contributions doesn't meaningfully benefit the company. There are of course graduations between "don't accept any contributions" and "let the community run it", but that's just different levels of giving up control.
I think "11. It takes steady income to sustain long-term R&D" is still the key aspect. Without money, software doesn't get maintained to a high level. Some projects work because many companies depend on it and contribute (but they wouldn't do it - or at least not nearly as much - if the project was strictly centrally controlled), but many other projects are basically one company running and publishing it and many others using it for free.
I can't help but think of Linux when you say this, and Linux is strictly centrally controlled
This is exactly it. I'm amazed that so few people in this thread are recognising this key ambiguity which underpins the confusion. As Wittgenstein writes in the Tractatus[0]:
> 3.323 In the language of everyday life it very often happens that the same word signifies in two different ways — and therefore belongs to two different symbols — or that two words, which signify in different ways, are apparently applied in the same way in the proposition. Thus the word "is" appears as the copula, as the sign of equality, and as the expression of existence; "to exist" as an intransitive verb like "to go"; "identical" as an adjective; we speak of something but also of the fact of something happening. (In the proposition "Green is green" — where the first word is a proper name and the last an adjective — these words have not merely different meanings but they are different symbols.)
> 4.003 [...] Most questions and propositions of the philosophers result from the fact that we do not understand the logic of our language. (They are of the same kind as the question whether the Good is more or less identical than the Beautiful.)
[0] Hilariously republished here by Buzzfeed as '7 Fantastic Ways To Distinguish Between Sense And Nonsense': https://www.buzzfeed.com/ludwigwittgenstein/fantastic-ways-t... It's such a mindblowingly profound work of philosophy, especially the kinds of philosophy that programmers are often unknowingly engaged in, that I feel you just can't read it all at once. You have to keep referring back to tiny chunks of it, as you start to understand their meaning and significance through epiphanies arising from particular concrete problems you wrestle with in your life.
But the opinion on that has changed I guess?
this is commonly referred to as "source available".
TL;DR - development model != license
Google's V8 engine is essentially an example of this, though they do notionally have some framework for outside contributions (https://v8.dev/docs/contribute).
I completely agree that Mathematica needs a steady stream of income to continue, it is a great language and for many use cases the best available. But every time I see a paper that relied on Mathematica for critical conclusions I'm forced to dismiss it as incomplete speculation.
If you can fork it, it's open source, even if contributions are not accepted upstream. If upstream accepts patches but does not allow forks, it's not open source.
It's about the license, not the project's governance model.
Open source = bazaar-style (highly-decentralized development)
Not open source = cathedral-style (highly-centralized development)
Free software = source code released under a license that grants rights such as freedom to modify, redistribute, own a copy of, etc. (see [1] for the proper definition)
Nonfree software = source code not released under such a license
[1] https://en.wikipedia.org/wiki/The_Free_Software_Definition
> Not open source = cathedral-style (highly-centralized development)
Don't conflate cathedral/bazaar to mean open-source/not-open-source. Wasn't the original example of cathedral the open source Emacs project?
Then some people wants to add some romance around it but that is just their own opinion.
I wanted to correct your statement without getting into an argument. I view an attempt to differentiate as a type of reaction.
Free as in freedom: You're free to do whatever you want with the code
Free as in beer: The product does not cost money
Whether or not they accept patches is up to the maintainer, and does not affect the freedom or open source nature of the software