To open source or not to?

[Alex.]

Lately I've been thinking a lot about open source software, particularly in regards to my future projects.

From an idealistic perspective it really seems like the pinnacle of programming efforts. A single person's work can grow wings and fly on its own, reaching more platforms and more people than originally intended or even thought possible. I imagine that open sourcing a project you poured a lot of heart and time into can be a very liberating feeling, and in a way the ultimate form of releasing your work to everyone out there.

For every good, there's some bad. Ungrateful people profiting from your work could be one of them, and although you could argue that life is too short to waste on such matters, it would still be a frustrating experience. And what about the risk of having your past work compete with your new one? Say you made an open source program, and later on decide to create an enhanced commercial version. A competent programmer could take your open source version and in a relatively small amount of time clone the commercial program's features on top of it. Would the decision to open source the old software be analogous to shooting yourself in the foot?

I'd like to hear your opinions on this, whether your work is open sourced or not.

 

[Vorporeal]

I think open-source has its places, but in certain instances, programmers shouldn't make ALL of their source available. There is always the possibility of releasing major portions of the source for your application, but leave out your main method or event loop or similar. Leave in the informational material and other salient features in your code, but remove the portions that allow someone to compile it (portions that would make it EXTREMELY difficult for someone to rewrite them and get your code working again). The parts released would still benefit from the source being available - people looking through your source would be able to inform you of places where your code could be optimized, or they could make changes/additions and send you their changes for review. Sure, it wouldn't be the best way, but it's one possibility.

 

[lulzfish]

The problem I'm having is that I like the idea of open source but I also like the idea of making money by writing software.
I'm thinking that if I ever do anything worth selling, I'll use one of those bizarre half-open schemes where it's like:

"First 1000 copies are $1, after that, I open it"
or like
"It's $1, but you get the source and the right to compile the binary on your own machines"

Luckily, I haven't made anything worth selling yet, so I haven't had to resolve this.

 

[Tom`]

I don't know that the issues with people profiting from one's work are as serious as they seem at first. Why?

Well, for one thing, having people attempt to sell your binaries isn't much deterred. It's simpler to plagiarize if your source is available, but for the most part, I don't think the people who buy software available for free (rampant on eBay, from what I've seen) are probably not going to be deterred by your copyright notices or whatever in the binary itself, since whoever is selling it will not allow the buyer to see that. It's certainly possible for situations to occur where an incompetent user is bamboozled into buying free software by code changes, but I have seen no evidence that this occurs more often than any other scam (which could be carried out equally well with proprietary software.)

In the second case - even if you release your application as proprietary freeware, if you make trivial changes, what then makes the software worth paying for? If you make major changes, whether the original software was free or not, it will be worth paying for, and if someone develops a competing program, and makes it free, well, that can happen whether or not you release source. Note that there are a number of companies that use exactly that model (having a basic, free software package, and selling enterprise versions for ridiculous prices), and they seem to be doing fine.

Of course, you have issues with licensing. The most common free licenses are the GPL and the BSD (or BSD-style) license. Some people consider the BSD license to be more free than the GPL, since it places fewer restrictions on distributors of the software (note, these licenses only apply at all to distribution of the software, not personal use, whether or not the software is modified). However, this is (paradoxically) incorrect, because the GPL preserves freedoms for the greatest number of users, in that it requires all distributors of the software to pass on the rights provided by the license to every other user or distributor, whereas the BSD-style license, in allowing proprietary derivatives, allows the distributor to remove rights and freedoms from users and other distributors.

edit for lulzfish:
There's nothing stopping you from making money off GPL (or BSD) software - sure, anyone can redistribute it for free, but unless (even if, actually) you start using some draconian DRM, anyone can redistribute binaries too.

 

[Alex.]

Nice replies guys

I think open-source has its places, but in certain instances, programmers shouldn't make ALL of their source available. There is always the possibility of releasing major portions of the source for your application, but leave out your main method or event loop or similar.

That's a way to consider, though the benefit of having the program continue to grow on its own, independently of the original coder, would be gone. It's definitely a matter of finding the right balance, which is always a hard thing to accomplish.

"First 1000 copies are $1, after that, I open it"
or like
"It's $1, but you get the source and the right to compile the binary on your own machines"

I think that's a great way to do it, a delayed open license, that promises to open the software after n years, or after x sales. I suppose there are still creative ways to release commercial open software, let's hope for a bright future

In the second case - even if you release your application as proprietary freeware, if you make trivial changes, what then makes the software worth paying for? If you make major changes, whether the original software was free or not, it will be worth paying for, and if someone develops a competing program, and makes it free, well, that can happen whether or not you release source.

I never said the changes would be trivial. However, once something is implemented, it becomes very possible for a competent programmer to clone it to the last detail, especially if you provide them with an opensource backbone to build on. That's a bit different than having the competing freeware program need to be built from scratch.

There's nothing stopping you from making money off GPL (or BSD) software - sure, anyone can redistribute it for free, but unless (even if, actually) you start using some draconian DRM, anyone can redistribute binaries too.

Right, but providing source code would give the potential thief the option to make some superficial changes enough to make it seem like the rip-off is a completely different program. It's the difference between not setting your car's alarm on when you get out, and leaving the driver's door open. Both can result in the theft of your car, but one's much likelier than the other.

 

[Tom`]

Nice replies guys
Right, but providing source code would give the potential thief the option to make some superficial changes enough to make it seem like the rip-off is a completely different program. It's the difference between not setting your car's alarm on when you get out, and leaving the driver's door open. Both can result in the theft of your car, but one's much likelier than the other.

It's certainly possible, but a smart user is probably going to figure out (via google, if nothing else) that he's being ripped off (who buys software without even checking what it does and what people think about it?), and a stupid user could easily be ripped off regardless of any superficial changes to the source. That's all I was saying. :wink:

 

[Vorporeal]

Nice replies guys

I think open-source has its places, but in certain instances, programmers shouldn't make ALL of their source available. There is always the possibility of releasing major portions of the source for your application, but leave out your main method or event loop or similar.

That's a way to consider, though the benefit of having the program continue to grow on its own, independently of the original coder, would be gone. It's definitely a matter of finding the right balance, which is always a hard thing to accomplish.

A slight alternative that I just thought of: Release the majority of the source, leaving out the event loop or main method or similar (as I suggested before). What you would do differently is that you would release the already-compiled object files for the closed-source sections, allowing people to create their own binaries using their modified source. In the object file though, you'd have code that would make the program display some sort of message to the user saying that this is free software/you are the original author/something similar. Sure, someone could probably edit the object file and remove this code/change the message/something to bypass this, but for most people who would profit off your code from simple recompiles, this would be too much of a hassle. I think this might be a decent compromise - allows users to modify your code and recompile their own binaries, but adds a deterrent to people trying to profit off of your code.

 

[Pickle]

I really like the ID method, keep it closed until its not making money and then release the code, but still sell the data.
I wish more developers that were closed used this method, doing this makes games immortal in a sense.
All the ID engines will go with us no matter the platform, other games may just disappear because theres no platform to run them on.

 

[samuraicrow]

If you decide to go closed source, at least use a cross-platform API like SDL, don't use preprocessor macros in your code (except for keeping headers from loading in twice), and compile it with LLVM using the Clang compiler frontend. That way you can distribute the bitcode files as closed source but they still will compile to any processor and (hopefully) any operating system. I haven't verified it yet but I think you can use the LLC command from LLVM to compile the bitcodes to any supported architecture.

My code, so far, is open-source but it's an extensible compiler. I don't think anybody is going to be found that will maintain such a beast without the help of my partner or myself. I've also worked on proprietary closed-source code in the past. They each have their place.

 

[lulzfish]

That would also be cool, since the biggest advantage of open-source programs is being readily available on all platforms.
Might give away some of your algorithms / IP, though, I don't think bigger MS / Apple -type companies will go for that sort of approach.