How to "Open Source" Custom, Contract Software? 392
customWorks asks: "I've been approached to write a piece of custom software for a small business owner with the promise of autonomy in its design and implementation. I do not intend to stick around for incremental development after I've delivered it, and so I feel strongly that open sourcing the software would be prudent for the both myself and prospective client. That said, I still expect to be paid for the developing the software. The issue of course is over convincing the client of the benefit of giving away the source to something they've just paid to have developed. I'd like to know if any of you who've done similar contract work have had experience (success?) in presenting an argument for open sourcing the end product? What were the major concerns/misperceptions that you had to overcome in making the case for open source?"
Viral Nature (Score:2, Funny)
Just make sure you own the IP (Score:5, Informative)
If the customer insists on owning the IP, then there is a great reason to raise your rates.
Re:Bah... (Score:5, Insightful)
This is fairly common in contracting actually.
IN many kinds of contracting at that.
For instance.. construction. Often when you hire someone to come in and renovate your building, they do up blueprints of the finished design.
Generally they own these prints, not you. Sure, you were paying them along the way, but that was for labor and a result, not everything in between.
Just the same, if you pay me to write you some software, you do not own everything I think about in the meantime by default.
The terms of who owns what IP has to be set out in the contract, otherwise it's far too ambiguous.
If a company comes to you with a deisgn and they just want someone to implement, odds are they aren't going to let you keep the copyright. On the other hand, if they are merely paying you to deliver a solution, then copyright can stay with you.
It really boils down to what they want.
Re:Bah... (Score:2, Insightful)
Applying the analogy, that would be more like the programmer owning the copyrights to the specification and use cases etc, while the customer owns the software.
I would think that contract programming would be a 'work for hire' kinda deal.
Sounds like (Score:3, Interesting)
you don't know the difference between contracters and employees. Generally IP to software written by salaried employees is owned by the company, but software written by contracters usually isn't, for a pretty simple reason.
IP to software is useless to a company that isn't planning to resell or profit directly from the software. Companies that hire contracters are usually looking for specific peices of software that will perform a specialized function, so they wouldn't have much use for the software IP, only for the software itself. Perhaps some contracters do hand over the IP rights as well, but most certainly don't.
I'm sorry, but you are trying to say that the guy doesn't know much about "real companies", when it actually seems he would be more justified in drawing that conclusion about you, if indeed your post was not a troll.
Re:Sounds like (Score:2)
On the other hand, if you are hired to implement a timesheet management system, and you choose one from scratch, you wound own it.
I think this is even true for regular employees, barring any IP assignment contract (which most places require you to sign). If your job is to do payroll, and you write software that automates the process, you own that software, though your employer gets a "shop-rights" license to use the software without royalties.
In any case, you shouldn't rely on this. A good contract should specify who gets what.
Re:Sounds like (Score:2)
You have it backward from how I read the supreme court decision.
Work for hire only applies if its work done within the confines of your employment.
As an independant contractor if copyright is not assigned as part of the contract it is yours.
U.S. Supreme Court [findlaw.com]
COMMUNITY FOR CREATIVE NON-VIOLENCE v. REID, 490 U.S. 730 (1989)
and further... (Score:2)
graspee
Re:and further... (Score:2, Interesting)
Re:and further... (Score:3, Insightful)
Me thinks the guy just wanted to get on the front page of Slashdot, and he figured the phrase "open source" was a good way to do so.
Re:and further... (Score:2, Interesting)
Re:and further... (Score:2, Insightful)
If it's useful, and people hear about it, they'll use it.
And since he's doing it for a client, it's got a headstart in that he will actually produce a working model, rather than one of those projects that never even gets to a beta version.
Why would the company open source it?
First, they need the product. They need a working tool, and it's not something that is currently available (to their knowledge). So they are going to develop it, regardless of Open Source support to begin with.
But, that's all they need. It's internal, so they aren't going to sell it to anyone else. They wouldn't be losing any income.
It will need maintenance. It may need small, ongoing maintenance forever - somethings are like that. It sounds like original developer may not be available.
If they opensource the product when it's been developed, they haven't lost anything, they still have the tool they wanted.
Meanwhile, on the principle maintenance costs just keep accumulating, and can add up to more than the cost of the original product over time (depends what it is of course), if it goes opensource, the maintenance costs get taken on by the other users as well.
The company benefits from any improvement or maintenance that other users make to the product, with no extra cost to them.
It depends. (Score:3, Interesting)
If they are paying the hourly cost of development, then it is absurd, even rude, to expect them to let you keep the copyright.
On the other hand, if they are simply paying you a flat fee for a solution, and it is up to you how you attain that solution, then it's another story. You can write the code and license it to them and keep it yourself.
The client should own the code (Score:4, Interesting)
1) The binaries
2) documentation
3) support
If you can't give them support, the ethical thing
to do would be to let them know, and give them the
source code so that they can have someone else
maintain it. But THEY should choose whether to
open source the code or not. They paid for it. It's their decision, not yours.
Re:The client should own the code (Score:5, Insightful)
As a side note, putting it under a Free license (GPL, BSDL, whatever) doesn't necessarily mean he's going to release the source to the general public, or even at all. With the GPL, he only has to give the source to anyone to whom he supplies the binaries.
Re:The client should own the code (Score:2)
This is the single most insightful comment made in this entire thread.
Why does everyone think that just because the software in question is GPL'd that therefore everyone in the world will have access to it? In the traditional closed-source model, two parties have access to the source: the contractor (programmer) and the buyer. The contractor licenses the binaries to the buyer under non-exclusive terms -- meaning that he can later turn around and sell the same code to a competitor if he so wishes.
If the contractor GPLs the code, then he's required to provide the buyer a written offer for the source code, free of charge. This isn't a big deal, since the buyer ought to have access to the code anyway. The contractor is also required to provide a similar offer to anyone else to whom he supplies the binaries. Just as in the closed-source model, the contractor can distribute the program to whomever he wants! The buyer only has a non-exclusive license to the program.
As long as the buyer doesn't expect to own the code, there's really no difference from their point of view. They have to trust the contractor, or else make the terms of his contract such that he cannot supply copies of this program to their direct competitors. IANAL, but I don't believe terms like that would preclude licensing the program under the GPL.
Of course, depending on the type of project in question, GPL may be impractical for other reasons. Especially if the design of the software would include, for instance, trade secrets or other information (like APIs or other interface specs that are internal and proprietary to the buyer's company), it may be better to opensource the majority of the program under the LGPL and then use a closed-source link between them. Or it may be better to simply keep the entire program closed.
But the program certainly shouldn't be closed source simply because someone thinks "open source means this will help our competitors". That's misleading at best and flat-out wrong at worst.
Re:The client should own the code (Score:2)
*If* what you say is true, then what would be the point of GPL-ing it? The customer, after all, has access to/owns (according to your statement) the source code anyway, so should the original developer be unavailable, they can take it to whomever they want to after they've 'bought' it anyways.
That said, I doubt if what you're saying is true. I know for a fact that the company I worked at a few years back developed custom applications for clients, but to the best of my knowledge these customers were never provided with the source (which would've been useless to them anyways), just with a (hopefully) working binary. Now this was in the Netherlands (yes, the country where fanatic lefties shoot insane right-wingers, yadda-yadda) and things may be different in the US or wherever you're from, but if they are in this respect, I really can't see why.
Re:The client should own the code (Score:2)
Re:The client should own the code (Score:2)
And if you do give them support it makes it so much easier if the client already has the code.
Comment removed (Score:4, Insightful)
Re:What's in it for the client? (Score:2)
If the software is popular/useful enough to be adopted by open source volunteers the company will have the benefit of ongoing development of the product that they paid for once.
Also, depending on the program, it may make sense to hold some key (but not critical) object back as closed source they way Sun does with Star/Open Office.
Re: (Score:2)
Re: (Score:2)
Re: (Score:2)
Re:The client should own the code (Score:2, Insightful)
The client is paying you for your time in developing an application.
Not always. In my experience, there are several types of customers for contract programming:
one who wants a tool
one who wants a new product
Those interested in a tool aren't normally interested in the source code, other than as a form of support. Normally, they're not paying you for your time or for ownership of the source code. They want a tool to do a job and are willing to pay for it.
Many of them know enough to ask for the source code so they can get bugfixes if you happen to be run over by a doughnut wagon. Even in this case they usually don't want ownership of the source code--they just want a license to it.
Normally the people who want you to create (part of) a product are the ones who want you to relenquish the rights to the code. If so, make sure you charge them accordingly. After all, for my customers who buy a tool, I can use significant chunks of code I've used in many other projects. I can't use my subroutines for customers wanting exclusive rights, so not only do they pay for the extra time in reinventing wheels (or the purchase of third-party libraries to do tasks), they also get to pay for the exclusivity.
As an (admittedly ridiculous) example, suppose a secretary wanted a word processing program, but no word processing software exists yet. She could pay you to write one for her. She doesn't really want to sell word processors or anything, she just wants one to help her business. You could write one for her, and she could write you a check.
For that money, they should get at least:
1) The binaries
2) documentation
3) support
No argument there...
If you can't give them support, the ethical thing to do would be to let them know, and give them the source code so that they can have someone else maintain it.
Giving them support can come in many forms, one of which is making available the source code so they can get someone to fix it if you're unavailable.
But THEY should choose whether to open source the code or not. They paid for it. It's their decision, not yours.
cyber_spaz
Open sourcing it buys the client and yourself nada (Score:5, Insightful)
So lots of comments and documentation are what you would produce if you truly have your client's best interests at heart.
Re:Open sourcing it buys the client and yourself n (Score:5, Interesting)
> them to produce something useful to your client
There are many more reasons to open source something than to sit back and let people hack at your code while you just absorb the patches, you know.
Sometimes the code is dead to you. But you make it available just in case someone else wants to use it. Sometimes a hack you made would serve as a great example to help teach someone else. Sometimes it tackles a problem in a totally new way that someone would just love to incorporate into their program.
I make a habit of tarballing everything I write and tossing it up on my website. I don't clean up the code, I don't turn it into a distribution.. I just let the people have the code because it serves no purpose to let it rot on my HD. Has anyone ever sent me a thank you email? No. But watching my http logs, once in a while someone does download something, and it feels cool to know that someone somewhere might be learning something from it.
THAT's what open source is about.
Just give him the source (Score:3, Insightful)
TWW
Re:Just give him the source (Score:2)
ala Big Corporate Mofos (Score:2, Interesting)
Or say that the custom app will be based on your own technologies so that you can open source say the main engine, and not give out proprietary stuff, such as database data.
Re:ala Big Corporate Mofos (Score:5, Insightful)
its not (Score:2)
OTOH, ih its something people will enjoy enhancing, then they get value from free enhancments.
Explain to the the philosophical reason for opening source. Or just GPL it.
Depends what exactly you have been paid for (Score:2, Insightful)
If the contract with the client states that all the IP you create belongs to the customer for whatever he wanted to do with it, then there's little point forcing the customer to do something specific with it.
Either way, the customer will face the problem of later support and evolution. If he cannot get hands on you, he either has to hire someone for hard bucks, or he donates the stuff to the public and crosses his fingers that someone will take care of it. Which does not necessarily mean the necessary work is done then - this depends on how 'hot' that piece of software actually is. You might have problems making some 08-15 applet Open Source in the hope of getting volunteers.
--Ben
major concern (Score:4, Insightful)
The dialouge will go something like this:
Coder: Let's open source this after you pay me to write it.
Buyer: Wait. So once we pay you to produce this for us, you want us to let you open source it, in effect giving it away for free?
Coder: Yeah. It's neat. Information wants to be free.
Buyer: But you want to be paid.
Coder: Yeah, I gots ta get paid.
Buyer: They don't require computer science majors to take economics, do they?
Seriously here. A buyer who is paying to get a custom piece of software made for them will be very very reluctant to let the rest of the world have that software for free once they have it. Especially if they have competitors. Especially if that software is mission critical at all.
In summary, best of luck. But perhaps opensource idealism should get a bit more used to taking a back seat to harsh economic reality.
*ends post, dons flame proof suit*
Actually (Score:5, Interesting)
You almost always give the client an Unlimited Non-Exclusive license to the stuff, but you certainly dont give away what you can sell.
If a client adamantly wants exclusive rights to whatever you produce, then you certainly raise the rates. And if you bring any preexisting code in an the product, which you will always do, you have to be clear that they dont get exclusive rights to that as well.
Re:Actually (Score:2, Informative)
So the question is "How do you get around this?" I'd love to know, because from the contracts I've had (mostly large telco's) it was either sign the paper or I don't get the work.
Re:Actually (Score:4, Informative)
This can get tricky because you might want to use some of it for in house code libraries and the like, and in some cases they have objected to using any pre-existing code and/or using any of "their" code for future projects. Yes, this affects the price, and yes you should get a contract signed that covers all of this.
Furthermore, there's the matter of good business sense. Even if you do own copyright, giving away what you just sold to your clients competitors doesn't sound like a good idea. It causes ill feelings when a developer is selling a app they were paid to write -- much worse if they just posted it on their website.
Re:major concern (Score:2)
Coder: Let's open source this after you pay me to write it.
Buyer: Wait. So once we pay you to produce this for us, you want us to let you open source it, in effect giving it away for free?
Coder: Yeah. So that if other people find it usefull and make it better, we can benefit from it.
Buyer: But you want to be paid.
Coder: Yeah, I gots ta get paid. But if you closed source it, you will have to pay me forever, and if someone else puts more money than you, you'll be damned. For nobody will help you out and you'll be on your own. And even if you start to depend on this someone, it will always be for the price they ask. So your "competitive edge" either costs you a lot, reducing the incentive, or it is avalilable to everyone else, same result as making it free. The difference is now you don't own the product, you can't make it better and you can't even modify it if you even want to add some speacial feature for use within your company (that GLP explicitly allows).
Buyer: Mhhh, then did computer science majors start including economics course?
Re:major concern (Score:3, Insightful)
Buyer: But that means that I will pay you for a product that all of my competitors will get for free. They also get all the advantages I do, including other people improving the code. They get that for free, as well.
Buyer: Why do I not just wait for them to contact you to write an open source solution and then use what you write for free?
Re:major concern (Score:2)
Seller: Well, you might be waiting for a long time...
Re:major concern (Score:2)
- Paying ALL the cost and ALL the upgrades, in which case making it open is a no.
- Paying someone else who did the product, still getting nothing. The someone can also sell the product to everyone of you competitors. And you fund that company.
Then you and your competitors start to realize that they are BOTH paying money do this other company which got in the middle, and because you really depend on that single app, you'll have to pay whatever price they ask. And by that time, you also realize that if you NOW want to produce your own tool, it will costs you the SUM of ALL MONEY you and your competitors spent on this product.
And this is what companies are nowadays finding out. They thought they had a competitive advantage, and everyone thought that. But reality turned out that the software producer was the one that had the competitive advantage. How else would you collect $40B in a competitive market?
Good try though...
Re:major concern (Score:2)
Sometimes it makes sense, some other times does not. When you want a competitive advantage and stagnated developement (beyond what you do) then don't make it free.
But if you prefer to but closed source and fund a company that OWNS ALL OF IT, and many people do that, then it just does not make economic sense.
After all, i see no important company benefiting from Office beign expensive and irreplaceable, and having to buy it over and over every two years. EVERY will have this suite and the competitive advantage will go to the product seller.
In cases where you KNOW you will not really have a competitive advantage is where open source will excel. And it can be proven that in most of the cases you will NOT have a competitive advantage. Competitive advantages come in another form: naely what you do with those tools, your strategy as a company.
Re:major concern (Score:2)
Re:major concern (Score:2, Insightful)
How is that not a great deal for the client?
Re:major concern (Score:2)
When I worked for ICL we often had one customer pay for development that later benefitted other customers.
There were features we weren't interested in adding to our base product but we would add them if a customer would pay for that development. Once the feature had been added to the base product the benefit was available to all our customers.
Also, customers did not receive the source code to our modifications (the code they paid would have done them no good without the rest of the code). The product was ours and if they wanted to pay for an enhancement that was fine but the product remained 100% ours.
By the way, the customers were banks.
Re:major concern (Score:2)
People paid a whole lot for 486s way back when, and the price dropped quickly once these initial people had bought them.
The client is paying to have this software available to them. They should negotiate a price that reflects the value to them. If the software is mission critical, it will probably save them more money than they pay for it. The fact that their money additionally benefits others is something they should be prepared to live with, because it's an economy of scale, like everything else, and client #2 always gets a better deal than client #1.
Furthermore, if the software becomes open source, they stand a good chance of being client #2 for some features they want later; if the software is a totally custom job for them and unavailable to anyone else, it's automatically orphan code.
Open Source Policies (Score:3, Informative)
If you're working with a firm that's more familiar with the a community or is part of a larger scientific community, it's another matter. Some firms view releasing open source software as almost a promotional effort and you might egg them to develop an "open source policy" to satify their concerns.
Board of director types have bazaar stigmas and FUD like "won't we have to support it," "won't it give away our business model," and so on. You can address those questions by suggested an OSS policy. The policy basically comes down to how and when they'll open source software. For example, they won't open source software that would be directly useful to their compeditors. When they do, putting the employee email addresses won't be allowed, as it will burden them with emails. Open Source projects shall be included on another website, etc etc etc.
But they will be more warm to a policy than simply deciding to open source things adhoc -- so if you give them a policy to address their concerns, you might have better luck.
And of course if your Philip Greenspun [greenspun.com] good, you can TELL them it'll be Open Source.
2 cents.
Re:Open Source Policies (Score:2)
Paying good money for someone to reinvent a rather poor wheel.
Paying lots of good money for people to reinvent a lot of bad wheels, some of which don't even work.
Paying lots of good money to ensure that disfunctional wheels never get fixed.
Figure that closed source cost GE several billions last year over and above the cost of hardware/software itself.
Don't reveal your client's identity (Score:5, Funny)
If I were paying someone to write code for my business I would want it as customized to my needs as possible while making it modular for further enhancement. What I would not want is for the entire open source community to know what network OS, database version, hardware, etc. I am using since that would reveal too much useful information to potential intruders.
Re:Don't reveal your client's identity (Score:3, Insightful)
Here's the easiest way to put the argument: sure it's harder for the attacker, but it's like using a Kryptonite lock and duct tape to attach your bike to the bike rack. Sure it's more secure, but not worth the effort. If you think you need the duct tape, maybe you should lock your bike in a better neighborhood and spend your time walking an extra 4 bocks or something instead of spending that same ammount of time attaching and cutting duct tape. In the same way, you should spend your time properly securing and maintaining all of your boxes, setting up proper cryptography, and enforcing strong passwords with proper limits on lifetimes. Try getting help setting up a firewall from MIT Network Security and they'll tell you to set up cron jobs to port scan your boxes and vulnerability scan your boxes instead. It's a bit extreme to discourage the use of firewalls, but I can definately see where thy're comming from. Just like Morris discouraging shadowed password files. md5 passwords and strongly enforced password complexity offer MUCH better seccurity than shadowed crypt password files.
Emphasize the benefits (Score:5, Insightful)
As a second, less important, benefit you can mention that there is a possibility that others will pick it up for use in their projects, and those improvements will benefit them without it costing them anything at all.
When they ask why they should pay you to write it in the first place if you're just going to turn around and open it, point out that without a developer under contract to write it, it won't be written at all in the first place. Emphasize that the open sourcing is about the maintenance of the software after it's been written, not about a different model for the development.
/Janne
Re:Emphasize the benefits (Score:2)
In either case - company recieving source or not, the IP would belong to the company - not the contract programmer and they wouldn't have to say anything to him if they wanted to extend the application. Any company who would hire a programmer to develop an application from scratch that would not become the IP of the company (opensource or not) would be stupid.
Re:Emphasize the benefits (Score:2, Informative)
No, since they have the source, they will provide it to the "anybody" you mention to fix/enhance/etc. I've been that "anybody" many, many times.
Remind them that without this move, the IP will still be yours and they will have to negotiate with you for improvements and further development, and that if they want the IP themselves, that will mean a cost increase for them.
This is just not true. They paid for your time, they own the source. You however, can go off and reimplement it at your next client... Remember, you didn't just get paid for some text files, you got paid to transform a set of requirements into a tested solution... This includes testing, debugging, looking on #dumbass for help, etc.
Re:Emphasize the benefits (Score:2)
Can't they do that anyway? The small business owner will get the source code regardless of whether or not it's open-sourced, won't he?
Remind them that without this move, the IP will still be yours
No, unless the contract explicitly says that the coder retains copyright, the copyright on the code will belong to the small business owner. When a work is commissioned--a "work for hire"--the copyright belongs to the person or organization commissioning the work, not the creator.
(Not to mention the fact that if the IP did still belong to the coder, as you suggest, he would not need the business owner's permission to open-source it.)
Re:Emphasize the benefits (Score:3, Informative)
If I design a logo for a company I state up front in the contract what they can do with the logo. For instance if they were going to just use the logo on a web site I would charge accordingly. However, if this logo is to become the company's entire identity system I charge a dfferent, more lucrative (for me) fee. I can't turn around and sell this logo to another company but as I own the copyrights to the logo, I can include it in my portfolio without the company's approval.
Are you using any GPL'd code fragments? (Score:3, Insightful)
Depending on the scale of the project, and the odds that the code segments you need already exist, you have to determine how much time savings you'd have by researching previous GPL'd projects over writing it on your own.
Although many companies wish to retain the rights to software you write, there are very few people who don't re-use bits from project to project. [Hell, it'd be downright foolish not to use already written and tested code]. As such, on any programing project I take, although there might be an NDA, I still retain the right to re-use the code in any further projects. Otherwise, I run into the risk that my common code library will be locked down once it's in use in this project, and I'd rather not take the project.
[even if they paid me more than my going rate, I'd be worried about using knowledge that I got from the project towards another project, and getting sued.]
Re:Are you using any GPL'd code fragments? (Score:2, Insightful)
Re:Are you using any GPL'd code fragments? (Score:2)
You aren't obligated to make the source code publicly available, but you are obligated to "cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License."
If you're a contractor, and not an employee, you almost surely are considered to have "distributed" the derivitive work. While you aren't obligated to make the source code available, you are obligated to GPL the code, and unless you are under an NDA to not disclose the code, if it happens to get onto a public FTP server, then anyone is free to use, copy, and redistribute it.
Re:Are you using any GPL'd code fragments? (Score:2)
C//
Why is this guy hiring you? (Score:3, Insightful)
Custom apps (Score:5, Insightful)
Next, you'd have to show me that releasing the code would not open me to any liability nor to any security breach. Saying that "more eyes see more bugs" is not an answer either, because I'd still have to pay someone to integrate fixes or, at least, re-install on my system each time an eye found a bug.
Finally, you'd have to show me that I couldn't profitably sell this as a product - probably not a big deal, as software doesn't appear to be your customer's area of expertise, but small businesses live and die on cash flow and, if I can keep it proprietary, not do anything to support it, and still charge money for it (i.e., the Microsoft strategy :-), I'd still do it...
Easy (Score:2)
Now I wouldn't go shoving it in their faces. Heck, I wouldn't mention it at all. But if you release it six months or a year after it's finished - A. They might never know, and B. Even if they do pitch a fit there's nothing they can do if you own the rights to it.
Businesses understand money (Score:3, Interesting)
Present the potential customer a list they can choose from like this:
If they take the software with a non-exclusive license, you still own the copyright and are free to release it under GPL or whatever other terms you like.
*Clue Stick* (Score:2, Insightful)
Remember though, that your name is going to be associated with that code for all future developers to see. You better take some time and carefully document everything you do. Your code is a personal reflection of you and your work ethic, so you don't want people to get the wrong idea.
Re:*Clue Stick* (Score:2)
Not true. Unless the contract says you are doing a "work for hire" the writer retains the copyright. Also, only works that are created to be part of a larger existing work can be a "work for hire".
Also increasing the strength of an author's claim to ownership is the fact that he's a contractor and not an employee.
Therefore, if you are hired to write a program for someone, you own the copyright, even if the contract describes what you are doing as a "work for hire".
IANAL but Google can confirm what I have said.
It's a WHO YOU ARE question (Score:4, Interesting)
But I've been in this guys position. Small companies are control freaks. They aren't willing to pay the money that a larger client is, they don't understand the debug cycle, they are usually more of a hassle to deal with, and to make it that much more irriting they want to own the IP.
Stick it to them straight. You'll provide them the solution, and the source, you own the IP and will do whatever you want. Don't be rude, but be prepared to walk.
Your idea (Score:3, Insightful)
I'd have fired you long ago because you won't continue to support your work. (Of course, writing an app so good it never NEEDS suport is another matter altogether.) It's completely ridiculous to assume that publishing the source under whatever open license will instantly give you an army of developers willing to continue to support and continue developing on the application for free.
Normally what you'd do is write the opensource app, and then a compnay would hire you to extend and support your own application inside of their project - in that case, then you could start talking with the compnay about whether the changes would be opensourced or not. In this case, you're turning the whole thing on its head.
Still, you may be right in that opensourcing the project would be a good idea for the company - but that is a decision that should be made INDEPENDENT of the development itself. The company should approach the decision with the assumption that the package is already developed, or even better AFTER the package IS developed. Most importantly, do not give this company any kind of false hope about what opensourcing the software will do. If you are a developer who actually runs any opensource projects, I don't really know why you would even think of recommending this so soon.
Who is the customer here (Score:4, Insightful)
1) Moral objection -- then do or do not (sorry Yoda). You may choose to express you moral view or not to client depending on whether proseltyzing is worth the effort/benefit ratio. If you fail to persuade, do you turn down the job?, if not, see point 3
2) Don't want to support -- then don't support, let customer know this, and why (at least if they ask). If you feel OSS makes a different in support, see point 3.
3) Anticipated benefit to customer -- explain your view of benefit, let customer choose.
4) Want to use exising OSS, see #3
If all you want is additional bullet points for #3, I'm sure you'll get plenty of opinions on slashdot. But, I would recommend sticking to things I believe in and understand (preferably have experience with) when making the case for OSS.
Hmm, point 3 seems to be pretty important. Give the customer a rational (or emotional) basis for making a decision. And let them make a decision. It's their money, their project, not yours. Of course, if its a moral issue with you, don't violate your morals. Don't come crying to anyone if you have to sacrifce though, high morality requires that you be consistent and be willing to accept the sacrifice it may involve.
My life is complicated enough without having to convert others. Matters of religion, politics, etc. are very similar to the arguments we coders get into -- We believe strongly in what we believe, for waht we believe to be good reasons, others believe just as strongly differently. You may convince some, other's you just make mad.
I may believe it's worth arguing religion (save their soul, or save the waste of their time/beliefe in myths, not saying which i follow). Politics -- you get morality and economics. But coding
It won't be yours anymore, but... (Score:2)
*OR* Sign it over to him under the GPL and restrict yourself from distributing it.
Any body he hires to modify it is restrained by the contract they sign with him as it is an internal project (to his company), and -if- he ever decides to release it he can do so.
And no future developers can take any rights away from him on the code, or modifications to the code. (ie: they couldn't hand him binaries without sourcecode).
If you want to get paid to develop something you have to expect that you won't have full rights to it when your done. If you client says 'sure, no problem', great. Otherwise you won't have a choice.
You definitely need to give the client the source (Score:3, Insightful)
Your best bet is to give the client the source code. You need to choose whether or not you want to retain rights to the source code, or give all rights to the client. Most contract programming jobs I've ever heard of require that the client not only gets the binaries and documentation (and sometimes training) but also the source code and complete rights to the source. That way, you don't depend on you for incrimental improvements. They can hire their own developers to do that if they have the source.
Honestly, if this is a custom job that is likely only of interest to the client (and perhaps the client's business competition), you are ripping them off by not giving them the source. But again, it's your job to choose whether or not you want to retain the copyright to the code for yourself, or give all rights to the client.
Standing on the shoulders of giants (Score:5, Interesting)
Most business problems have been "solved" in one way or another elsewhere -- extol the virtures of sourcing in something that they will be able to get support for, using the old "if i get hit by a bus" scare tactic
Otherwise, through good architecture, you can compartmentalize the proprietary bits to a few files, thus allowing them to have something of their own at the end of the day.
And again, BE OPEN UP FRONT -- you are probably not in a position to identify on your own what the client may or may not consider proprietary -- lots of businesses have "grey-matter" or "raw experience" when it comes to processes and methods that are not obvious to their competitors.
But basically we get a lot of mileage becase I stand on the shoulders of giants everyday!
and remember, work = force * distance
Geez... (Score:2, Insightful)
First, there are an awful lot of folks here who are beginning to sound a little like a bunch of NW fools I can think of.
Second, I'm no coder. I'm one of the owners of an engineering co. that hires coders. And I "get it".
If some coder thinks he can tell me what to do with something I am paying him for he can hit the road, period.
OTOH, I am currently paying a coder to develope a number of OpenLDAP tools for managing and syncing user accounts across multiple servers. I have every intention of "open-sourcing" these once they are debugged and useful.
But just because I get it does not mean I will stand for being told what to do by an employee. Instead of arguing about IP, you folks should be figuring out how to make the PHBs "get it".
Change the order :) (Score:2, Funny)
of open source INTO his app. So write the open-source on the side, increase the hourly rate
accordingly so that the labor of integrating it
pays the same, voila
You do it for less if you open source it (Score:2, Insightful)
Why tell him? (Score:2, Funny)
Umm... How does open source make sense in this? (Score:2, Insightful)
The bottom line is, he will have to hire someone else to maintain it anyways, because I can assure you that the open source community will have no interest in maintaining it for him, but he will have given it away to all his competitors. He is a fool to go the open source route.
give them a choice (Score:2, Insightful)
You could try convincing them about the virtues of OSS, but at the end, most businesses are more interested in the bottom line...
I've done this in the past (Score:2, Informative)
The software will include Open Source components for which neither CLIENT nor CONSULTANT will hold exclusive copyright. CLIENT will be granted an unlimited license to use the software. The right to resell the software will be granted but will be restricted by the terms of the GNU General Public License (http://www.gnu.org/) and/or other Open Source Initiative approved licenses (http://www.opensource.org/).
This particular case was for a project which I knew would include some custom code in addition to some pre-existing open source components, but you could apply the same idea to 100% new code.
Be OPEN with the client. (Score:2, Insightful)
Does the client know this?
Be open with your clients.
Lay all the options on the table and let the customer decide.
Explain why you cannot maintain the software.
You could be assuming they expect you to maintain it. (Assuming too much is a bad habit).
Being open in all aspects, is the best thing "Open source" advocates have going for them.
What's the problem? (Score:2, Interesting)
I had a client ask me to do a piece of software. I said right in the contract that I owned the rights to it. I GPL'd it and it morphed into MIMEDefang, which is a far better product now than it was when I originally delivered it.
I'm working on another piece of software which has certain proprietary and competitive features. After a lot of back-and-forth with the client, we've agreed that I can GPL parts of it (called "core infrastructure code") while giving up rights to other parts (the "non-core code.")
Just do it. (Score:2)
Disclaimer: IANAL, TINLA
How about extending an existing OSS Project? (Score:2, Informative)
But please don't bother open sourcing anything if you (or no one else) plans to maintain it.
There are enough dead projects out there already. Don't add to the graveyard.
could be easy (Score:2)
Have your cake || Eat it (Score:2)
Re:Have your cake || Eat it (Score:2)
Do all your work in front of a webcam and sell the client a ticket to watch you create open-source software that just happens to meet his exact project needs. This way, you get to thumb your nose at all the self-righteous /.ers who are wailing about "having your cake and eating it too." You get paid for your performance (just like an actor), the client gets his software, and the software is liberated.
And if you didn't realize this was a joke, well... either you need a better sense of humor or I need to work on it and tell it again when it's funny.
Client's IP, your advice (Score:2, Insightful)
Your client could be convinced to open-source something if:
On the last point, they might agree if you can show the client that what you will be writing will indeed be picked up by some other people/companies. These other people would be interested in what you wrote because they would also need what you wrote, and the improvements made by others can provide a direct benefit to your client.
I realize that the logic is somewhat circular here. You have to prove it's good enough for everybody, and then everybody else would do something that's good enough for your client. Presumably then they would also need the technical expertise to actually use what you did.
The other problem is convincing the client that there is nothing proprietary to them in the software. If they hired you, it usually means they don't have enough in-house expertise to decide this, and their decision will be no.
If this gets open sourced, your name would be on it, and that means you would be on the hook to _everybody_. It does not absolve you of the responsibility of maintaining the software and defending your design decisions. In fact, it makes you more responsible.
I have worked with companies who thought about this long and hard, and typically did not do it. The exception was software that was end-of-life, with maintenance being cut, and the costs amortized. At that point, unless one of the points above applies, it can make sense because open-sourcing internal software is a hedge for maintenance provided several others start using it and work on it.
On the IP-side, the work you are doing is considered "work for hire." This means your client owns the IP, all of it. It's like being an architect: you draw plans, and if the client goes ahead with building the building they have full rights. Yes, your name is on it, yes, you have liability exposure, but they own the work, because they bought it from you. The only way to get around it is if the agreement between you and the company states clearly that you are giving them a license as opposed to performing work for hire. If you want to be really clear about what you're giving away, get a lawyer - your client likely has one too.
just my half-cent.
Sell them your service ... (Score:3, Interesting)
Re-organize it so they are paying for your support and service while you are paying to write the program.
Frankly that is what you are trying to do anyway. You want them to pay you for your services not for your code or you wouldn't have even considered open sourcing your SW.
What goes around comes around (Score:2)
I'm going to assume, perhaps incorrectly, that you are developing an application which will be deployed in a GNU/Linux or BSD environment. I'd simply say "I'm able to provide this solution for you because other people have provided free license for use of their software. In exchange for my services you are paying me money. In exchange for the contributions (which are 99.9% of the total package) provided by the free/open source software community, you are simply agreeing to contribute something back."
So you don't want to be paid to maintain it? (Score:3, Insightful)
If anyone has ever had to deal with a Lawyer you know what I mean. Call the man to chit chat for 15 mins and you get a bill in the mail for his $450/hr rate divided by 4. No kidding. Why should your time be worth anything less?
Don't give your software away and don't sign away your ideas if you can help it(i.e. IP). Every idea in your head is worth money to someone even though you may not realize it. Telling your client that you recommend giving this software away will make them feel insecure and they will also be reluctant to hire you again to maintain and extend the software. Also, If the software truly is 'unique' it is another feather in your hat that the next contracter DOESNT HAVE. Don't work yourself out of a job. Know the difference between what is work and what is your hobby.
Regards,
Peter
This IS slashdot, right? (Score:3, Interesting)
First, base your project on an existing Open Source project. Show the client how much value s/he gets from starting with the project(s), not limited to the fact that others have reviewed the code.
Second, once the client sees that h(i|er)s project will benefit and that the total project will cost less, explain the need for continuous updates and maintenance. Explain how costly it will be to maintain that work totally and solely in house.
Then, propose a solution to 'leverage' the Open Source community to assist with the project by releasing the changes, with the client's approval, back to the project. Explain the benefit of many eyes and many users perfecting the codebase.
This is exactly what I and a colleague have done with a very properietary-minded client. Now he's onboard for releasing the modifications and enhancements we will create back into the project community. Actually, he's excited to do this.
The way to your client's heart is through the bottom line.
We WIN bids due to the GPL. (Score:3, Interesting)
1) If we die, then they arn't left up a creek without a paddle.
2) Their data can be easily migrated over to a new peice of software if need be.
3) They can extend the program if they later decide that we suck.
It wins contracts, and we don't low-ball our bids.
Aside: Never low-ball a bid, it looks syspicious and makes the prospect nervous.
Contracting (Score:2, Interesting)
What is the point of open sourcing the code? Put it in escrow if the company requires that, or negotiate code release into the contract if they want that, but make them pay for it. Remmember, it is always more expensive to contract someone to produce reusable code for you, than it is to have a system built.
Framework/Application model works best here (Score:2, Insightful)
We have an arrangement with our customers which works out very well for both of us. Once you factor in the incentives of both parties, this arrangement naturally leads to a happy situation for both parties.
We come into the relationship with a substantial framework, which we license to the customer under the GPL. As the relationship progresses, we build many components. Some of these components are specific to the customer's business process, and some are more generic. We retain all IP rights to the generic components, which we integrate into the framework and license back to the customer under the GPL. The customer retains all IP rights to code that is specific to their business process.
We maintain a code repository for each customer which contains their business specific code. These are typically workflow definitions, business specific data models, entry screens and reports, etc.
We also maintain a common repository for the framework, which contains all the reusable code (whatever we define to be reusable). We usually have a few projects going on at the same time, and this repository receives contributions from all of them.
The benefits of this arrangement for the customer are:
* Customer owns specific business process logic, UI elements, data models for their business, which means that they control their trade secrets and we can't go to their competitors and sell them the system they payed to custom build. In return, customer is solely responsible for paying someone (usually us) for maintaining and enhancing these components as their business changes.
* Customer does not have to pay to build a major system from scratch. They get a tested and tuned framework for free upon entering the contract, and only pay for customization, which is a process we excel at. In this fashion, we can deliver a return quickly and with minimal expenditure, since we don't have to build much infrastructure.
* Customer gains the benefit of framework enhancements for other customers. Over time, as contributions are made to the core framework, more and more reusable functionality is available to incorporate into our custom solutions. This has the effect of bringing sophisticated functionality into the customer's price range. In effect, all our customers indirectly share the cost of maintenance, tuning, and additional generic functionality.
* If we go out of business for some reason, the customers have all the source code they need to achieve continuity.
The benefits of this arrangement for us are:
* We gain a powerful framework that is tested and tuned across multiple production deployments.
* We can out-bid competitors who need to build things from scratch, who base their work on proprietary software which they cannot enhance or control, or who must recoup massive amounts of R&D , marketing expense, and capital risk.
* We spend our time solving unique business and technical problems, as opposed to re-coding functionality for multiple customers simply because we don't own IP.
* We spend very little time on maintenance because most of the difficult code is maintained in one place- application specific code is mostly declarative.
* We do not have to pressure customers to buy upgrades. We keep customers current as part of the development process.
We have been modestly successful using this model, and people who work with us, both developers and customers, are happy and getting good value.
Once caviat- our customers tend to be in a line of business other that software development, thus they care less about owning software IP than than do about streamlining their business processes.
Hopefully this will inspire some ideas.
Mike
Open Source Misunderstanding (Score:2)
Let's take two examples, the BSD license and the GPL. The GPL only requires you to give the source code to the recipient. In this case it happens to be your client. Once they get it, it's up to them as whether they want to distribute the source further. The BSD license doesn't even require this. But you're going to give your client the source code anyway. So it makes no difference.
That said, I think it would be extremely rude if you charged your client for the code and then turned around and posted it on your website. If you're going to do this, let them know ahead of time.
Depends on your deal. (Score:3, Interesting)
Typically, If I intend for the software to be OpenSource, then I only charge for the installation of the software.. and not the development of it. I will normally charge for the installation of opensource software which I did not create, why should I not charge for the installation of software which I have created?
I have worked for some clients who have requested, at the completion of the software.. for it to become Opensource, for the sole reason that the software meets their minimum requirements.. but would like continued support after the end of my contract.
If you have any doubts, discuss it with your employer/contractee.
Recap of some of the above (Score:5, Informative)
- The contractor owns everything; customer gets license to a binary
- The contractor owns everything; customer gets license to binaries and the source code under some circumstances (such as contractor unavailability)
- The contractor owns everything; customer gets license to use and modify binary or source for any internal purpose
- The contractor owns everything; customer gets an unlimited but non-exclusive rights to binary or source.
- The contractor owns everything, but agrees on limitations on reuse or redistribution; customer gets some license from above
- The contractor owns nothing; it's a work for hire, since the customer contracted for the work rather than a service
- The contractor owns nothing, but the customer grants certain rights to the contractor, such as limited reuse of modules.
- Ownership is mixed, with some parts retained by either sides.
It sounds like what you need to do is agree with your customer what their expectation is on licensing, and get that in the contract. For example, if you own the work but agree not to disclose certain modules dealing with business process, it's clear to both sides what you can and can not disclose later. That may mean reuse on other contracts, provision to their competitors, or release to the general public.In general, the more restrictive the customer rights to work performed, the higher the rates.
Copyright and Work for Hire (Score:2, Insightful)
That said, you have an ethical obligation to work out a resolution with your client.
(Assigning it in the contract is also considered a work for hire.)
In theory, theory and practice are the same, in practice, they are not.
I've done this (Score:3, Interesting)
Open Source in Two Years Clause. (Score:3, Insightful)
The client gets exclusive rights to the software for two years at which point the software becomes open source. This would manifest in the form of a clause in the contract stating such.
This would give the client room to breathe against competitors or enemies seeking to compromise their software, gain from their expense, etc. while still allowing for the continuation of the code in the open community. If the code is interesting enough to still be viable in two years then it will persist.
This is very similar to having someone license technology but instead of losing their rights to the tech they merely have to share with everyone else, though not any additional modifications they have made to the code in the meanwhile.
This would also mean that the code would have to be put into escrow in order to meet the requirements of the contract for both parties and as an insurance measure for both parties.' Escrow 'meaning that a 3rd party would have a copy of the original code and would release it into open source according to the contract despite any intentions of the two parties otherwise.
Seems like a lot of effort but if you think your code is important enough to the community at large then this would be worthwhile because of the checks and balances it imposes. The client would of course pay for everything.
No Benefits to OSS'ing this - Even ESR Says So (Score:3, Interesting)
The company asked him if OSS'ing their software would be beneficial. His reply was "no", since the software had a somewhat limited application outside the context of this company.
The situation cited in the article sounds similar to the one ESR mentions, so I would have to say "Nay" here.
-PS. The story was in his book, The Cathedral and the Bazaar, so I am not certain if it exists in the online white paper of the same name.