Open Source

OpenSource is a style of software licensing and distribution, related to FreeSoftware (see also FreeSoftwareVsOpenSource).

The consumer of an open source program has the rights to do the following things to the source code:

read it
use it
modify it
distribute it
charge money for services related to it, such as copying or support, so long as they do not infringe on the freedoms of others

Open source isn't PublicDomain. That means there is a license involved and the license has restrictions, which can include:

distribution must be free
modifications must be distributed
original authors must be acknowledged (i.e. the BerkeleyStandardDistribution license, although the advertising clause has been rescinded July 22, 1999.)
derivatives must be similarly licensed (i.e. the GnuGeneralPublicLicense)

Licenses vary considerably on which of and how these restrictions apply. FrankHecker? has written (draft 20000620) a clear (though long) piece that explains the variations.

http://www.hecker.org/writings/setting-up-shop.html

Depending on the Software, there are quite a long list of licenses involved in OpenSource:

http://www.opensource.org/licenses/index.html

EricRaymond, author of TheCathedralAndTheBazaar and TheHalloweenDocument commentary, and others have founded an organization and site to promote the concept.

http://www.opensource.org/

Potential down- and upsides to OpenSource

Anyone can sell the software without having to give a penny to the original programmer(s).
- However, the OpenSource programmer
  - is not tied to a particular employer, so can program what makes their heart sing.
  - is free to offer consulting (and special client customizing) services on the open market, like e.g. on the OpenMarket? at SourceForge, where s/he will be in a unique position.
  - is free to buy domain-names that represent their programming ideas, which they develop openly in the community, thus getting more exposure than by million-dollar marketing campaigns, with the consequent opportunities to sell/rent/lease these domains for more profit than they would earn as employees. As a real example, you can start to program StocksAtHome?, DomainsAtHome? in analogy to SetiAtHome just right now. Contact here or via the open WikiTrails: ExtremeOpenBusiness or the (to be created) ExtremeOpenProgramming. -- FridemarPache
- Home users aren't going to pay hundreds of dollars for an OpenBSD .ISO, when s/he can quite legitimately get it for a free download or from a competing shop for a few bucks (though businesses are likely to purchase in order to have expert support).
  - OpenExpertSupport? can be superior to ConventionalExpertSupport? (due to avoiding the hotline bottleneck)
Not every conceivable product is available in open source. It requires that enough programmers share an itch that the user may have.
- Something comparable to MicrosoftAccess, consisting of a NimbleDatabase engine, ODBC interfaces, and GUI tools (OpenOfficeBase is still too immature).
  - Part of the theory behind open source is that if it were really a big enough gap, someone would do something about it. Either this theory is wrong or this gap is not really as much of a gap as you think it is. This has already been discussed somewhat on NimbleDatabase, but I think the general attitude among users of open source software is that things like Berkeley DB and mySQL+phpMyAdmin are good enough and nimble enough (for some definition of "nimble") that there really isn't much impetus to create something that is closer to Access per se. (In fact, in the open source world there is more respect than in the commercial world for the PowerOfPlainText; in some sense, the open source hacker's idea of a nimble database is more likely to be tab-delimited text files and sed/awk/perl.)
  - Those DB's listed do not fit the definition of "nimble", and plain-text may be good for inter-process or inter-system communication, but is often lousy at interacting with tabular information. How would you like to use a command-prompt-only spreadsheet, for example?
  - See TableOrientedToolWishList.
- The canonical example is an ERP system. The problem with OpenSource is that only projects of interest to programmers get the attention.
  - Or programs that company programmers get paid to develop, as long as the company paying them isn't one of the closed-source zealots of the world.
- No idea when the above was written, but as of 2014, there are plenty of OpenSource ERP systems: See http://en.wikipedia.org/wiki/List_of_ERP_software_packages#Free_and_open-source_ERP_software
Open-source products tend to have poor or inconsistent user-interfaces. As bad as Microsoft products are, at least one can find most functions in a fairly short time by noodling around the menus. Open-source products seem to often have functions that are nearly impossible to find or figure out unless one reads the manual or Googles a solution. I believe commercial firms, such as MS, do extensive actual testing with real users, and fill in the biggest UI gaps based on that experience. O.S. projects generally don't have the budget for that, and UI gaps stay gaps. One MS "trick" is to sometimes make multiple ways to do the same thing such that one will eventually run into the solution. It may be in the text menu, tool-bar (or ribbon), and right-click menu under "other" all at the same time, for example. It's not elegant, but at least gives the user a chance. They don't do this to all commands, just the ones that seem to stump users the most during user testing sessions.
- What a gross over-generalisation. Many open-source products have superb user-interfaces. A vast number of commercial products have dire user-interfaces, but you've probably never seen the majority of them. Some Microsoft products are a user-interface nightmare, with bugs retained through over a decade of updates.
- That's my honest personal observation of open-source products. I try to use open-source when I can, but the UI's can be damned frustrating. If your observation differs, so be it.
- It would be useful for you to identify the open-source products that you find frustrating, rather than pointlessly conflate software products' quality with the manner in which they're distributed.
- I don't think it's "pointless", any more than your general observation notes are "pointless". Why couldn't you just ask, "I'd be curious to see specific UseCase's of UI problems." No need to make it personal and rude. Rudeness doesn't help this wiki nor is more likely to produce the desired affect than the polite approach. General anecdotes are generally better than zero evidence, by the way (EvidenceTotemPole). If you personally don't like general anecdotes, that's fine, but don't extrapolate that to other readers. And, you did such your very self. --top

I'd like to clarify the difference between open source as platform and as a development method (OpenSourcePlatform)

At the risk of defining YetAnotherMethodology, I would like to characterise OpenSource. This list is an interpretation of my reading of EricRaymond's The Cathedral and the Bazaar book ISBN 1565927249 . The purpose of this characterisation (I'm not a fan of PigeonHoleThinking?, but sometimes it has its benefits) is to try and draw parallels between OpenSource and ExtremeProgramming in order to define what might be understood by CorporateOpenSource.

Roles defined:
- Development Coordinator: someone who is responsible for maintaining a single codebase, i.e. revision controller. This person is clearly known and respected in his/her role.
- Developers: People directly involved with development of the software. Usually in close contact with the coordinator, and in fact these roles can overlap or be rotated.
- Co-Developers: Also sometimes know as Users. Offer feedback, advice and fixes, however, are not directly involved in development.
- Beta testers: Users in the sense of ClosedSource customers. I.e. find bugs and give feedback but lack the know-how/time to fix the bug directly in the code.
Global code ownership: no single person owns the code.
Release early & often: a short iterative cycle.
Users can be co-developers: extending the two heads are better than one principle to many heads.
PairVersionControl?: because of the centralised development coordinator, at least TwoSetsOfEyes check any changes in the main codebase.
Unwritten rules: for handing over control of the codebase to someone else, and for preventing version fragmentation.
Plan to throw one away; you will anyhow is quoted by Raymond from TheMythicalManMonth.
Perfection (in design) is achieved not when there is nothing more to add, but rather when there is nothing more to take away. is quoted by Raymond from AntoineDeSaintExupery
Lots of Feedback: from beta testers and users.

-- GerritRiessen

See also OpenSourceProjectOrganization.

Note the above describes the Bazaar Development Process described by EricRaymond in TheCathedralAndTheBazaar. FreeSoftware and OpenSource are involved strictly with the practice of providing full access to source code to your clients without imposing onerous restrictions on its use.

[If no one objects here, I'll come back in a week or so and ReFactor the first section to better reflect the 4 freedoms, and OSS Definition]

Homebrew and Open Source

Are the OpenSource and FreeSoftware communities really a software version of the HomeBrewComputerClub? I guess the key differences are 1) software vs. hardware hacking, and 2) licenses to guarantee everyone's hacking stays in the community.

I would be really interested in thoughts on this from a former member of the HomeBrewComputerClub (1970s/1980s Silicon Valley group that started Apple, and many other computer companies).

-- EricRunquist

As both an original Homebrew Computer Club member, and open source proponent (I was part of the original GNU WebChat? project in 1995, and have enjoyed using Linux since 1994), I'd say the most stunning similarity between Homebrew and today's Open Source movement is the spirit of freely sharing information and ideas. At Homebrew code was often shared freely, just as we did with schematics and information about group chip buys.

If you are interested in more detailed information about the Homebrew Computer Club see http://www.bambi.net/bob/homebrew.html

-- BobLash?

Websites involved in Open Source Dev:

GnuProject
FreshMeat
SourceForge
AsianOpenSourceCentre
CSharp-Source.Net (http://csharp-source.net)
PosseNet
Java-Source.Net (http://java-source.net)

People involved in Open Source:

EricRaymond
LinusTorvalds
RicardoMoral
you?
.... and many more!

RichardStallman and the FreeSoftwareFoundation reject "Open Source". They promote FreeSoftware, which is philosophically distinct (and predates OSS by about a decade). However, FreeSoftware is often considered to be a subset (or superset, depending on who you ask) of the OpenSource movement.

It's suprising that MicroSoft has not been using a MondeGreen for OpenSource as open sores within its documents.

In UserFriendly, Illiad used this represent industry ridicule of OpenSource in early 1999; two years later, he played on his earlier joke by referring to MicroSoft's SharedSource? plan as 'shared sores'.

Question from someone else: is MicrosoftCorporation into SponsoredOpenSource these days?

There's also Castor, which is a java-based project that generates source for java objects that represent XML data files.

Why doesn't someone create a Wiki for Source Code examples? Or, if there is one, where is it? You mean, like CodePedia and MassMind? Are there any others?

AnswerMe Are there any good examples of failed open source projects, what happened, and how things could have been different (with or without open source development)? I have heard many good things about different aspects of the open source paradigm, but, I'd really like to know more about the down side of open source development. That way, I can have a more rounded understanding of the pros and cons of each. Thanks. - IntaekLim

Specific examples are what you asked for, and I hope someone more informed provides some.

Broad conclusions, however, need not anecdotes, but a broad base of evidence. Good attempts to derive lessons from well designed studies:

The Institute for Software Research at the University of California at Irvine has a large body of empirically-based research available on its Open Source Software Development Project's homepage at http://www.isr.uci.edu/research-open-source.html

The International Institute of Infonomics, University of Maastricht, Netherlands published their Free/Libre and Open Source Software: Survey and Study (FLOSS Study) in June 2002, available online at http://www.infonomics.nl/FLOSS/report/

Both resources might help you sharpen your question, as different criteria and metrics for measuring 'success' and 'failure' make comparison of open vs. closed software development problematic at best. We can't see inside closed shops as easily as we can browse Source Forge (see Part V of FLOSS Study: "Source Code Survey" for an attempt to glean information from code repositories). We have no comparable way of learning closed shops' true rate of 'success' on any conceivable metric; the best proxy would be a sample taken to be representative of the entire population of closed shops, but even then, the ones that refused to participate in such a study might well differ systematically from the norm. Failures certainly may make it to market, but they are not generally advertised as failures. For that matter, nominal open source projects that are failures on commercial and conventional open source criteria alike may well be counted as successful by their primary developers, for instance, student projects. These would need to be somehow eliminated from any code survey. In sum, like most software quality or programmer productivity questions, this is a very difficult question to answer empirically.

The conventional wisdom seems to be that systems tools or infrastructure software attracts more &/or more talented developers to open source projects than application or enduser software, making the latter more prone to failure in open source development (see examples above). How would one operationalize these variables in order to substantiate or falsify this perception? I'd like to know myself. -- PaulWilson

Please provide a link on OpenSource rationale... as the only profession on the planet that en masse provides a cost free service I think this would help: much appreciated.

http://www.redhat.com/about/whoisredhat/opensource.html

http://www.gnu.org/philosophy/open-source-misses-the-point.html

http://www.allianceinteractive.com/blog/cost-isnt-only-rationale-open-source-adoption

As a developer, my time and sometimes my ability are limited, so I use OpenSource software. Because I rely on OpenSource software -- the product of other developers' effort -- I feel it appropriate to contribute my effort in return. Therefore, I write OpenSource software.

Without OpenSource, we would be forced to reinvent many wheels, and the evolution of software would thus be impeded. Earning a living from software development is only a small motivation -- for me at least -- to write software. I mainly write software because it's my contribution to building a better world, so I give it away.

For every example of a successful, useful OpenSource project, I can give you 20 or more examples that ended after the few programmers that created the project, stopped working on the project so they could get a paying job to feed their families. I am well aware of the few very successful OpenSource projects including Linux, Apache and others. I would like to point out a few of the problems with OpenSource.

Likewise, for every example of a successful, useful ClosedSource project I can give you 20 or more examples that went out of business, leaving their users in the lurch. At least when an OpenSource project dies, its source is still there for people to use and maintain.

What happens to the businesses where their very expensive programmers use the "open source" code and then the OS project is abandoned? The programmers working for that company got paid but what does the company do now?
- Keep working on the project? Abandonment of an OpenSource project doesn't mean its source can't continue to be used. In fact, that's a benefit of it being OpenSource -- if the developers abandon the OpenSource project, at least the source is still available. What happens if the commercial firm providing a proprietary, closed-source solution goes out of business and your project is dependent on it?
- I distinctly said the developers had moved on and the abandoned open source code is of no value to a company without programmers.
- (It wasn't clear to me whether "that company" and "the company" meant the OpenSource developer or the OpenSource user.) If the OpenSource user of application <x> has a need to modify the source code of <x> and <x> is no longer maintained, then it has the freedom to hire its own developers or pay someone else to work on <x>. If a ClosedSource user has a need to modify the source code of <x>, then it can only go to the company that maintains <x>. If that company no longer exists, then it can only try to replace <x>. At least with OpenSource, there are options that don't necessarily involve replacing <x>.
Should a company that pays thousands of dollars for software enhancements, have to give that source code to their direct competitors because they use open source code elsewhere in their project?
- Depending on the license associated with the OpenSource code, the company may not have to give away any source code. However, does the company's only competitive advantage lie with the source code itself? If so, there's a bigger problem here: even if its competitors don't get its source code, they're going to easily re-create what its software does. Any "competitive advantage" that depends on hiding code isn't a competitive advantage.
- If the "open source" is "copy left", then including open source means you have to make your software open source as well. I obviously know that there are other kinds of open source licenses. Nobody said anything about hiding code but most companies do try to get/keep a competitive advantage by having "trade secrets" of many kinds that could include source code.
- There are indeed trade secrets around proprietary algorithms or software processes, but in over 30 years in the industry I've never seen one that couldn't be trivially divined from how the application worked. Value lies in human expertise, business strategy, and business or domain knowledge, not what chunks of source code you keep to yourself.
What happens to the software company that invests millions on designing, creating and finding a good useful set of programs only to have somebody create an "open source" copy of the final design, even though all the code was created by themselves? It is at least an order of magnitude easier to copy someone else's design (your code only) rather than design something original yourself. You can't patent ideas after all.
- What happens to the software company that "invests millions on designing, creating and finding a good useful set of programs" only to have somebody create a cheaper commercial copy of the final design? Either way, if your only commercial value is your binary distribution, you're toast.
- So all non open source programs are commercially useless (Oracle doesn't make billions in profit does it?)? Do you actually know anything about software? Have you ever actually made a commercial product that sold thousands of copies?
- Did I write that non OpenSource programs are commercially useless? They can be very valuable to the company that makes them, until someone makes an equivalent alternative and supports it. Why do you think Oracle bought MySQL? It's because MySQL was a threat. I do know a little bit about software. I've been developing it for over 30 years. I've made commercial software products that sold only dozens of copies, but the market consisted of only dozens of possible customers. It was a limited vertical market, and product support and use was licensed on a monthly percentage-of-revenue basis. It was effectively OpenSource -- source was freely available on request -- and we encouraged our users to hire us or their own developers (their choice) to implement customisations and extensions. It was very successful. Now I teach university ComputerScience students how to do what I did. I also maintain an OpenSource product that has been downloaded thousands of times.
What harm has come to computer language developers because most computer languages are just given away? These companies lock businesses into their language by the business's programmers just using the language and then overcharge for service, or other goodies that can only be got from that company. Is this good? Even free software that isn't OpenSource has the potential to harm other companies by devaluing what they have created. How many potential computer languages and tools would have been created if others hadn't spiked the market with "free software"?
- How many potential computer languages and tools wouldn't exist without free and OpenSource software? The Internet and Web were built from it.
- I obviously think that "free software has decreased the number of languages and tools that are available. I will agree that Linux and the "free" LAMP stack has created a huge number of servers (many of which are not looked after because their owners have no professional expertise) but how many more (and better) tools would have been created if these products had charged "something" and allowed others to compete. We will never know for sure. Obviously MySQL deciding to charge for their Windows version helped add many billions to the pockets of Microsoft and Oracle.
- MySQL is free; people pay for support and enterprise add-ons. Without OpenSource, you'd never know about all those extra languages and tools, because the Internet wouldn't exist. The sharing of knowledge, tools and techniques that OpenSource provides thus wouldn't have occurred, so there would be fewer developers with the know-how and motivation to create all those extra languages and tools. So, it's unlikely there would be more languages and tools without OpenSource. At best, there'd be a lot more failed attempts at building a business around some commercial product, and a lot more little handfuls of customers left in the lurch when the product-makers go out of business.
Some people have said that "software should be free" for moral reasons. What is moral about people devaluing the work of others? Software programmers are amoung the best problem solvers of any kind, anywhere, but are rarely valued at the level of skill they have and can demonstrate. How much has "open source" cost all professional programmers in loss of perceived value?
- OpenSource doesn't "devalue the work of others". It puts the value right where it belongs: on the programmer, not the program. ClosedSource implies only the program is valuable; the programmer is... Irrelevant. OpenSource says it's the programmers who are the valuable commodity; the program is -- in effect -- irrelevant.
- So you think that only custom programmers should get paid? The program is irrelevant? How does it work when you try to execute a programmer rather than a program on your computer?
- Certainly not. Everyone should get fairly paid. However, if I choose to develop (say) the RelProject and give it away because I believe it will be of benefit, then I am free to do so. I'm also free to get paid to develop extensions that are proprietary, or get paid to produce extensions that meet someone's need and then give away the source code. I am paid for my knowledge, my ability to write code, and my ability to teach about writing code. I am not paid for the lines of code that I produce, but for my ability to produce them. The lines of code are merely the mechanism by which my expertise is expressed; the value is my expertise, not the lines of code. Even if all code was OpenSource, that wouldn't change -- people would still pay me to write code that meets their needs because I can meet their needs better than the next guy. It's me who is of value, not my code. Similarly, if I write a book, the book isn't kept secret. Everyone can read the words I've written; the words are OpenSource -- we all can read them, just like OpenSource code -- because it's their arrangement by me that is valuable, not the words themselves. Or, to use another analogy, if I create a new kind of car transmission, anyone can see how it works and fix it themselves -- it's inevitably "open source" because it's there in the vehicle to take apart and repair -- but that doesn't mean I shouldn't be paid to engineer transmissions.

For all the reasons above, I don't think OpenSource or "free software" is a victim-less crime. -- DavidClarkd

Given all the responses above, I don't think OpenSource is a crime. ClosedSource isn't a crime either, but it's akin to being sold a new car with the hood/bonnet welded shut. Sure, you might never intend to fix it yourself, but if the manufacturer goes out of business, no-one can fix it. At least with the hood free to open, someone can open it and fix it no matter what happens. -- DaveVoorhis

Apple is very much like that "welded shut" bonnet whereas Google is more in the open source camp. I have traditionally disliked Apple products since the 1970's but I own 2 iPhones, an iPad Air and Apple TV. Yes, these are closed products but I just want the functionality they come with. I don't view them as a product I would want to screw around with. I have used Linux for about 15 years but have never downloaded the source. It is just not worth my time to look at the code, understand enough of it to matter and then have to throw away the changes when the next version comes out. Android from Google is arguably not as user friendly as iOS because it comes in so many flavors. I think it would be a bad thing for a number of competing versions of my system to come to market and do nothing but confuse my potential buyers and hurt my reputation.

There's considerable difference between a consumer gadget and enterprise software. When a consumer gadget breaks, you throw it away and buy another. OpenSource for such Apple products would be nice, but isn't necessary. When enterprise software breaks or can't be updated because its maintenance is no longer viable, not having the source code can ruin the business.

There are ways to have the source code available if the owners aren't willing to continue developing and debugging the code. Open source isn't the only way. As a professional programmer, I expect to get paid for my work. I have no problem paying a reasonable price for the tools that allow me to make a good living. In fact, Red Hat made a whole business selling software to companies that could download the source code for Linux for free. Business knows that free rarely pays. I don't think any professional should work for free as that will degrade the value of those who need to make a living charging for their time and are deserving of just compensation. Many professional organizations forbid any of their members from giving away their services or even undercutting others on price alone. That might be going a bit too far but I agree with the sentiment. -- DavidClarkd

Sure, code escrow and the like is viable. However, you appear to be conflating OpenSource with "free and unpaid". The former does not obligate the latter. Whilst OpenSource products like Linux can be downloaded cost-free, what's notable is that RedHat, Canonical, SUSE and others aren't making revenues from selling Linux per se; they make revenues -- very good ones -- from selling Linux support. The difference is profound, and demonstrates where the real value lies: Linux itself (i.e., the source code) is essentially worthless; it's Linux knowledge that is valuable.

You say "Linux itself is essentially worthless" which is an unsupported and therefore worthless remark.

It's self-evident. You can't make money on Linux source code (please read what I wrote) -- or the binaries compiled from it -- because it's freely available cost-free. That makes it financially worthless. Linux expertise, however, is highly valuable.

I said that people who want to charge for software, they have created, are undercut when others say it is worthless.

How so?

Please tell me how you can charge for software that you allow to be given away in source form?

Charge for documentation, customisation, installation, support, consulting, or further development to meet specific needs. The last item -- development to meet specific needs -- is an excellent way to get paid for OpenSource, and it works well in a generally OpenSource world: Let's say company <x> needs software <s>, and <s> isn't available as OpenSource. So, <x> pays developer <d> to develop <s> and releases <s> as OpenSource. Now company <y> can use <s> for free. Company <y> saves money, but company <x> has spent money. Now company <x> needs software <p>. It is available as OpenSource, because <y> paid developer <e> to develop it and release it as OpenSource. This time, company <x> saves money because company <y> has spent money. Overall, companies <x> and <y> have each spent money on developers <d> and <e> to develop software <s> and <p>, but both <x> and <y> have saved money on code they didn't have to develop. Neither has had to spend money on duplicated effort. If you extend that to hundreds, thousands, or millions of companies, it means any individual company spends only a relatively tiny percentage of the overall development cost on code that isn't yet OpenSource. Every company saves development money, the developers get paid to develop code, duplication is minimised, and the industry as a whole (both software developers and users) benefit from the knowledge and effort that is shared.

How is equating free and open source not logical? Why do you mix up the difference between charging for the program and changing for service or support? I never mentioned either and I obviously think that service and support should be paid for as well as the use of the program. Please name the profession that works for free?

I know of no profession that works for free, but remember that the "free" in OpenSource is free as in freedom, not necessarily free as in free beer. Before the microcomputer revolution of the late 1970s, mainframe software was almost invariably sold with source code. It's the microcomputer world that thought hiding source code provides a competitive advantage -- which it does, until a competitor creates a better piece of software to do the same thing yours does and then you're forced to compete. With OpenSource, you differentiate based on expertise, knowledge, business relationships and domain knowledge rather than your ability to hide a collection of bytes.

Your conclusions doesn't refute any of the arguments that I made. I obviously know that some companies have given away the software and sold support. Redhat has done very well for themselves off a product they didn't design or program. There are also many companies that don't make their software open source like Oracle, Microsoft for almost all it's products, Adobe and thousands of other companies. Are you saying that these companies aren't making a profit off the software they have paid to have written?

Where did I say that? Of course, there are many companies making money from ClosedSource software. There are also lots of companies making money from OpenSource software.

Last I read, Linus Torvalds was getting in excess of 1 million dollars a year from the Linux foundation to work on just the core of Linux. How much support do you think Linus does?

He's not paid to provide Linux support. (1 million dollars per annum? Do you have a citation for that?) He's paid to create and maintain Linux kernel code. He's recognised and respected for his ability to create and maintain Linux kernel code, so he's justifiably paid for it.

The fact is that a few companies have found a way to make "open source" pay, either through advertising, a sugar daddy, or service. Most software that is currently profitable today isn't open source. Don't take my word for it, go look it up in InfoWorld or any other industry source. As a creator and developer of software for most of my adult life, I am personally insulted that others would think that, as a professional, my efforts and work is worthless and must be given away for free. You argue like a child. Why not make your case with arguments, and facts and show where my arguments and facts are incorrect? If this is a debate, you don't seem to know how to play the game. -- DavidClarkd

Who said your efforts and work are worthless? As I pointed out above, if you're a good programmer you'll be paid for your ability to make good code, not for your ability to keep it to yourself. However, if you do keep your code to yourself, why would a smart business risk loss by buying ClosedSource binaries from you when you could go out of business?

There's nothing that stops you from (and there are good reasons for doing so) commercially licensing your software to (say) enterprise users and providing it as OpenSource. Will some companies use it for free and not pay you? Almost certainly, but it's unlikely they'd have paid you for it whether it's OpenSource or ClosedSource. At least their using it is helping to build your reputation and increase your exposure to those who are happy to pay for your expertise, customisations and support. Think of it as free marketing.

Why do you make comments while ignoring all that I have written? This is very annoying! I have already said why I think open source is bad (multiple reasons) and how I would overcome the problem for a business if I couldn't support the code. I can always let people use the code without forcing them to pay, that doesn't require open source. There are many ways of marketing non open source and I am familiar with them all. Just read the posts above. -- DavidClarkd

Where have I ignored what you've written? I've responded to every point.

Yes, I know you think OpenSource is bad. I think you're wrong, and I've explained why I think you're wrong.

Contrast with ProprietarySource, ClosedSource.

CategoryOpenSource