Slashdot Mirror
Why Paying For Code Doesn't Mean You Own It
Barence writes "Why do people think they own code just because they've paid for it? PC Pro's Kevin Partner says many of his clients believe that by paying for the work to be done, they take ownership of it. But, put simply, code is owned by its developer even once the client has paid, unless that developer is legally employed by the client or a contract exists that transfers full ownership (and even then it's far from clear-cut). He discusses the thorny issue of making clients understand that distinction and gives advice on how developers can assert their rights."
yeah, I am used to paying for an item, and software happens to be an item (especially when it is delivered on a CD)
In soviet Russia, God creates you!
If I buy a bible, I don’t own the original Lindisfarne Gospels
Yes, actually you do. At least where I live they are public domain. You might not own the particular translation or interpretation of said gospels but you do own the core concepts. All of us own them. They are a part of humanity whether it be good or bad. This is the most confusing analogy one could produce.
if I pay a plumber to fix my tap, I don’t ask him to leave his toolbox so I can fix it myself next time;
No, but if you bought a book on plumbing you might just fix it yourself next time. The results may vary but it's different from compiled code in that the person has no option to 'decompile' the code and go through it. You're right but the analogy has flaws. The plumber isn't producing a copyrighted work for you, he's performing a service. No goods are exchanged between you and the plumber like a software release.
if I buy Harry Potter and the Half Blood Prince on Blu-ray, I don’t own the movie but only a copy (whose usage is restricted by the terms of the licence); if I buy Microsoft Word, I own one copy of the compiled code, not the source.
This is it, it comes down to licensing and copyright. Why do you waste so much breath on this rant when it's a legal agreement between you and your customer that is based on commonly known and accepted copyright and licensing terms?
I will say that with the advent of the Agile Methodology in where I work, the customer is much more involved. We meet with them every two weeks. We constantly incorporate their ideas into their site or program through our own code. And at the end it's a mixture of ideas but we're still the ones that coded it. Between you and I, I'd love to give them the code. But that's the decision of the guy who runs my company, not mine. If you have switched from the previous models of "wait a long time and big bang release" to "constant customer input" then you may now be experiencing something natural--the customer feels they own the code. Because they were with you every step of the way from infantile code to adult production code. Just keep that in mind.
My work here is dung.
Back when I contracted, all contracts had that I was doing the work as "Work For Hire".
That seems pretty clear cut to me. Meaning, they own it.
Why do people think they own code just because they've paid for it?
Because they assume they are paying you for a product, not paying you because they like giving away money.
I subcontract to a company and on Monday morning I'm going to walk right in (actually send an email) and tell them that all that code I have developed for them over the last several years is actually mine and that if they want the source code then they need to pay me a $$$ more money.
I'll try to remember to keep my head high when I am kicked out of my home and am sitting starving on the side of the road!
In theory, practice is the same as theory. In practice, it differs.
I am Slashdot. Are you Slashdot as well?
Write a good contract and the issue is moot, for both parties.
---- Booth was a patriot ----
If someone pays you to perform work, they own all rights to that work. When I was married, we had a difficult time finding a photographer that agreed, and simply didn't do business with those that wanted to be paid for their work, and wanted to keep all rights to said photos for use in promotions and fees for reprints. I consider that a form of double jeopardy where I'm being forced to pay for something twice.
Software is no different. If you're being paid to perform a specific work, it's no different than if the person/organization paying you did the work themselves. You can't have both.
There's a practical presumption in law that if you pay for something and it is delivered, you own it. You have to have it in writing if you don't want to work that way. That, for instance, is why we have those obnoxious (and legally tenouous) "shrink-wrap" licenses. Because "licensing" is not the same as "owning." If licensing were the normal case in common law, you wouldn't need a "licensing" agreement.
It depends upon your local laws and your contract. In the U.S., the default laws tend to vary by state. The last time I checked with my attorney, he told me that here in NY, all work is considered to be work-for-hire unless specified in writing. This means that the source code is automatically the property of the client, unless I get a contract stating otherwise. Which I do sometimes, but not that often.
Things get stickier if you use other people's libraries or even open source software within your project.
I've found that it's easiest to avoid problems if you simply discuss it with your client beforehand, and be as transparent as possible in your methods and expectations.
Let's say I buy the software, the end product. It's bits. It's ones and zeros. Do I own them? Am I allowed to tamper with them? It isn't the source code, and I lay no claim to owning that. But do I have a right to be able to manipulate the bits as I see fit? Can I share the bits? These are the truly thorny questions, and they're the ones that are changing our society.
I've had clients who think that they own the code simply because they paid for a website that uses one of our libraries. They buy the right to use the code.
When you buy software in a store or online you don't own the source code. Open source software may provide its source along with the executables but that doesn't mean you own it either.
When doing custom work we offer the client the option of full ownership at full price or 'shared' ownership for a reduced fee. With 'shared' ownership they can modify it at will but aren't allowed to ever resell it. We can't sell it to anyone who would be considered a competitor. I've yet to have someone opt for the full price/full ownership option.
IANAL, but I have researched this subject for my own work-product. The ownership of work produced on contract depends highly on the terms of the contract but nominally is considered work for hire, and, therefore, belongs to the client. If the contract does not stipulate otherwise, then the client owns the work-product.
Now, if the work-product consists of delivered source code, then the client owns the source code. If the work-product consists of delivered compiled code, then the client owns the compiled code.
Again, IANAL, but my research into this question boils down to something just that simple. The important conclusion is: if you desire a specific disposition of your work-product (like you retain ownership, or retain the ability to sell the same work-product to someone else, or retain the ability to modify it, or release it as open-source, etc.), you should put that in your contracts.
Put my fist through my alarm clock with its ding-dong death inside my ear. - The Blackjacks.
Someone pays me to take photos & thinks they can make their own prints. But they don't own the photos. I do. Then they get all cranky when they go to Walgreens with the crappy 800 pixel (long side) image I gave them for web use & wonder why one of two things happens:
1) their 4x6 print looks like crap
2) the store manager won't print watermarked photos without a signed release from the photographer
I copyright law f'd up in this world right now? Certainly! But right now this is how it is. I do remain open to Something Better but haven't seen it yet.
If I hire software to be written under a work-for-hire agreement, I sure as hell own it, barring pieces that are used that fall under the ownership of others. Original code plus the arrangement of licensed code is what I'm paying for.
This is a weird and slippery slope. I don't think that anybody feels that because they buy software they own rights to the source code, to edit code and distribute it, etc. But they do own the rights to use or utilize the software as they see fit within the confines of common copyright laws.
The author uses the example that you can buy a book or movie, but you don't own the rights to that book or movie. And that's fine, I think we'll all agree to that. However, if I buy a replication of a piece of art, a book, etc., I'm allowed to vandalize/defile it in any nature I wish as long as its for personal use and it is not distributed.
I'm not sure that I like the slippery slope that a lot of developers are trying to tread these days. Notice my use of the words "use" and "utilize." These are two very different words in the English language. Use means, well, to use something. Utilize means to use something for a purpose in which it wasn't originally intended. I can go to the hardware store and buy thousands of different tools and items for home repairs and various other projects. Many times I'll buy patented items because they almost meet my uses. I modify and "utilize" them for the specific task at hand. And this is fine, as you don't see me on the street corner trying to sell modified black and decker pecker wreckers at a markup. I think think that 1) that would infringe patents, 2) that would infringe registered trademarks and patents, and 3) I'd probably go to jail for trying to sell "pecker wreckers."
In the end, I have a product that meets my requirements and the vendor makes money off of my purchase. Everyone is happy, right? I think that this is the hurdle that software developers have to get over. As long as people buy your software, that's all you should care about. Let them modify it to their hearts content as long as they're not selling it for profit. In fact, possibly learn a lesson and integrate some of these features in your next version to appeal to a larger market. I think this is mutually beneficial in the long run. EULA are trash and need to go away.
Wise men say, "Forgiveness is divine, but never pay full price for late pizza."
You might ask why I didn't make a contract with this client in the first place. It's because I've found, over the years, that insisting on a contract before development starts will result either in a delayed start or even a project being shelved.
Not having a contract in place before you start does speed things up, but it's kind of like running a heavy industries company without insurance.
Why not have two general contracts drawn up in advance; one which points out that the client gets what is essentially first publishing rights, or whatever comes closest to emulating the copyright system, and another where you sell the code outright. Explain the difference up front and then pull out the pen. "Option A is cheap, but I can sell the same code to other clients and you can't change it, and Option B will cost you several orders of magnitude more, but it's all yours forever and you can do whatever you want with it. This is standard copyright practice. We can start work as soon as you sign!"
People like clear options and little check boxes, and this would avoid weeks of legal dickering. Yes, you may lose some work in the short term because people realize that you're not selling what they actually want for the price they can afford, but this way is more honest and your headaches will be fewer.
Just my opinion.
-FL
IAAL, but the issues here are complex so this is NOT advice for any particular person in any particular situation:
If what you are interested in is owning a copyright to source code there are two ways for a "customer" to get the copyright:
1. If the software is a work made for hire. "Work for hire" is a legal definition (see 17 U.S.C. 101), with two different paths. The first path is for the software to be written by an employee within the scope of employment of the organization claiming copyright. Employee specifically does NOT mean an independent contractor, and code written by a contractor is NOT a work for hire! The definition of an employee goes into all sorts of common-law factors a court will look at, but the shorthand is the tax status of an employee with the IRS.... merely calling a contractor an employee is not enough. Also, the work has to be made within the normal scope of employment, so no, the employer cannot claim copyright as a work for hire for something the employee did outside of work. In fact, even if the employee works for the organization as a regular employee, if writing code is not within the normal scope of employment it still might not be a work for hire (up to the courts to decide if things go south). While some works for hire can be done by an independent contractors along with a specific written agreement, software code generally does not fall into any of the specifically enumerated categories where these written agreements work (see 17 U.S.C. 101 for more details).
Interesting: Technically, code written for a big company like MS or IBM by the armies of independent contractors are NOT works made for hire. See point 2 for how the companies can still get rights.
2. Assignment of Copyright: This is much more common for any work not directly made by an employee. There is a written agreement assigning ownership of the copyright to the contracting organization. The usual rules of contract law cover what is and is not within the scope of the assignment. Assignments can be non-exclusive (we can do what we want with the code, but the developer is also free to do what he wants), or more commonly, exclusive (the assignee getting rights to the code has full control, the original developer loses his rights to that specific work). So is there any difference from a work made for hire? YES! In a work made for hire, the organization OWNS the copyright for the entire length of the copyright term. However, in an assignment, Copyright law specifically splits the copyright term into two parts. An assignment made when the work is created transfers rights to the assignee (usually the company) for about 1/2 the term (the time varies depending upon whether the author dies and some other factors, but it is usually a long time > 30 years). The copyright automatically reverts back to the original author, and the assignment agreement cannot override this rule. The law is written this way to give the authors a "second bite at the apple" in case a work they assign away for peanuts becomes very valuable later. The author can extend the copyright to the second half of its term by paying a nominal fee, and can then go out and the assignee loses all previously held rights.
The upshot for the software industry: Any assigned copyrights will eventually revert to the authors. Now, by the time the reversion occurs most software will be long out of date, but as we all know there is plenty of software out there that lingers for a LONG time, and non-employees DO get there rights to the underlying code back.
One other point: Binary code gets a separate copyright from the underyling source code. But binary code is a derivative work of the underyling source code, so even if the developer never compiles code he writes, the binary distribution using that code would violate the copyright of the original code if ther
AntiFA: An abbreviation for Anti First Amendment.
It's pretty simple. If you are an employee, your employer owns your code. If you are a contractor you own your code unless your contract or agreement states that the work is a "work for hire" (or uses equivalent language). Requisite Wikipedia reference.
Then Linux came along and somehow "closed source" became a synonym for "proprietary", and "open source" a synonym for "free" (gratis). Microsoft feeds into this by not releasing the source code to Windows. Windows would be an even stronger (proprietary) product, IMO, if the source code were available.
Lawrence Lessig tried to rectify this false dichotomy by founding the Creative Commons. But the public has little knowledge of the existence of the Creative Commons, let alone the particulars of any of the licenses it offers.
The Linux community shares some of the blame by touting libre, gratis, and "open source" in the same breath. This lawsuit is a consequence of that.
I deal with this frequently with sub-contractors (and firms) doing development.
It's actually very simple.
The understanding starts out as: This is a work-for-hire. All work product is property of the company.
Which eventually leads to a contract containing:
All source-code, build scripts, documentation, keys, any other materials required to use or reproduce the deliverable item are exclusive property and proprietary information of the company.
The contractor shall not release, reuse or redistribute any component of this work in any other business. This includes any custom libraries, headers or other application work-product.
This does not apply to off-the-shelf open-source tools and libraries, however such items shall be documented and approved in advance to avoid GPL contamination.
I don't see a problem here.
I expect to pay through the nose if i want exclusive rights and ownership to someone's special library, for exactly the reasons the article dictates.
Otherwise a non-exclusive source-code license that I may do with as I please is cheaper. A binary-only license might be cheaper still.
They devs have to make a living and if it wasn't cheaper/faster to use them in the first place I'd just write it myself.
Just try explaining these legal subtleties to someone who doesn't understand software.
work itself
Has a cost once. (Extra work adding extra cost.)
The work that has already been done has no extra cost. It is only greed wanting to gain without giving.
leave his toolbox
Plumber looses what he has but with IP a copy isn't a loss.
The client has paid only for the results of the labour
Source code is a result of labour.
ownership of the code has a value
Greed has value.
pre-existing libraries
Cost has already been paid for.
First of all, client expects to be able to use and MODIFY code you've done for them, both physically and legally. Who owns the code - is the second question. They don't want to own your library - they just want THE LICENSE allowing them to see, modify and use that modified code. It is the same thing as open source, except that they don't get the right to redistribute your library.
Don't be a dick, just give them that license.
The arguments he's posing actually have merit - his main argument seems to be that if a customer buys something that he developed, they on occasion believe they own his self-written custom libraries - essentially his tools. The plumber analogy begins to make more sense at this point. They paid for the finished product and can do whatever they want with it (unless contractually obligated not to, but that's another can of worms) but they did NOT pay for the tools he used to develop it. Perhaps the best analogy would be to say that if a customer pays for software they should not expect to own the development platform which was used to create that software.
In the article, he states "One problem is that if you’re working in an interpreted language such as PHP then your code isn’t compiled, so in practice your client does receive source code and can do what they like to it, even though they have no legal right to."
It's your responsibility to elucidate what's accceptible and what's not. Moreover, if someone updates your code to fix say a spelling error, then that's not copyright infringenment, it's just updating.
It is funny watching everyone on here discuss how ignorant all their users are for thinking they own the code simply for paying for it...and later today there will be a post discussing the RIAA and why they are an evil organization for trying to force their users who purchased their works to recognize that they don't now own that music.
"if I pay a plumber to fix my tap, I don’t ask him to leave his toolbox so I can fix it myself next time"
"You might ask why I didn’t make a contract with this client in the first place. It’s because I’ve found, over the years, that insisting on a contract before development starts will result either in a delayed start or even a project being shelved."
So, this developer doesn't disclose this to customers who aren't aware that they are screwed when the developer walks away? His tortured analogy of the plumber and his tools is only correct if the plumber is installing pipes, valves, etc. that are 100% proprietary to the plumber and can't be purchased anywhere else. The word slimy leaps to mind for his business ethics (and plumbing in general).
"Powers. I have them."
In California, at least, there's also some tricky sales tax issues to be aware of. If you hand that client a CD-ROM with the product, for them to keep, of your $100K worth of toil, you have made "a transfer of tangible personal property", and sales tax is due on the whole $100K. On the other hand, if you FTP it to their machine, it's just non-taxable services. Or, if they provide you with a blank CD-ROM and you burn your software onto it as a service.
This is why architects retain ownership of the drawings they produce, for instance.
Failing to have a clear contract, means that the one buying, may not be getting what they think. But equally true, is that the seller may be giving up more than they think.
There are basic principles here. And that is "work for hire".
The conflicting stuff, is development of "skills", competition, and squelching a persons ability to make a living.
Fundamentally, one should see a lawyer about this, these two sentences should keep you google happy long enough to grasp the things that you should expect from your lawyer.
Not to start a flame war here, but to give my opinion as IT person who doesn't code (scripts don't count right ;)
I read 8 different versions of who owns the codes, depending on state, and contracts, even sales tax got in there. Reading all this made me think, wow I would go to elance, find a shop in India tell them I own the code and let them at it. Knowing full well they will probably keep it for themselves over there, while I have full rights over here. Done Simple.
Yes it would probably not be as good and would take 2X longer to write (I read slashdot you know), but I don't have the headache that apparently accompanies hiring a local subcontractor.
But, put simply, code is owned by its developer even once the client has paid, unless that developer is legally employed by the client or a contract exists that transfers full ownership (and even then it's far from clear-cut).
Just a point of clarification: You can't write a contract that transfers ownership of a copyright that doesn't (yet) exist. Well, you can but it's unenforceable in the US. You can write a contract to the effect that you *will* transfer ownership of the code you build, but you still own the code until you sign a subsequent document transferring it.
Moderating "-1, Disagree" is simple censorship. Have the guts to post your opinion.
So, if I take a copy of it, then I obviously didn't pirate it. Since I can never own it, I can never steal it.
I've been coding for about 22 years. In that time, I've worked on proprietary code for customers and employers. customers usually understand that they are paying for the final product, not the inner workings to give them the final results. you can use the concept of building a house. they are paying for the house, not my workers, not my tools, not my materials. i do not leave a copy of my dev tools for the customers, nor will i leave them a copy of my proprietary code libraries which i employ regularly to make my coding job easier. if i write a a library which creates a unique object type and use this object in many of my projects, clients are not entitled to this code. although it helps make their final product work, the concept is the same. they are not paying for the code, just the finished product.
if a chef is hired to cook someone a special dish, they are paying for the finished dish, not the recipe.
Many successful contract computer graphics artists 'have' libraries and scripts that they have developed over the years. These are often created or written as 'work for hire' for their previous employers.
When I hire them (as does everybody in the business) they are required to sign an employment agreement that says that anything created on the job is a work for hire. They're working at our facility, under our supervision, with our equipment and toolset -- it could not be more clear what the arrangement is.
Especially among younger artists, though, these rules do not seem clear. They think that the tools they write benefit the company, but that they should be able to take them to their next gig.
Generally speaking the graphic design and of course the content (textual content, photographs you have licensed, etc.) of the site is yours to do with as you please, but the underlying source code (PHP and JavaScript) remain the intellectual property of Company, LLC. You may modify them as needed, but you may not duplicate the software for use on other websites, and you may not distribute derivative works. This license is transferrable as long as Company, LLC is notified in writing of the transfer, and may verify that the transfer has taken place.
I've never had a problem.
I still cannot find the droids I am looking for...
The ownership of work produced on contract depends highly on the terms of the contract but nominally is considered work for hire...
Not it is not! The term "work made for hire" is a legal term defined explicitly and exclusively in federal copyright law. If the work produced on contract does not fit the categories described by that law, then it is not a work made for hire under the law.
So I have prior knowledge of X highly efficient algorithms to do various things that I have come up with in the past, If I happen to have need of them then I instinctively will use that method, to fluff it up with placebo code to make it unique in some way would be wrong, and any half decent coder coming after me would remove placebo code spotting it's uselessness anyway so my original algorithm would be left.
Everyone knows 'new' code is highly rare as it is unless working with a very specific problem.
So how the heck do you explain to ANY company you work for that due to this you can work for them, and give them a product they own they have entirely paid for, but tons of the methods within it you can simply never give them any rights to, as you've used them countless times before for yourself and other paying and non paying clients. And it would be impossible for you to continue to work in the field if you were to not use them elsewhere also.
Also, a software contractor merely plays a part in the social process. Claiming ownership of any component of that process, I'd say, is antisocial.
If I paid someone to make a cake for me, I own the cake. If I paid someone to paint a painting for me, I own the painting. Why do people want to change the rules for software?
As a person who runs an open source company, the first sentence "Why do people think they own code just because they've paid for it?" caught my eye. The reason most companies think they own code is that 99% of the contracts I read have a "work for hire" clause. This means that as a contractor you sign away the same rights that employees do. You come up with a patentable idea on company time? They own it. You write code? They own it. Open source presents an interesting problem. Quite often in the same contracts they have clauses against distribution of the work for hire. I spend quite a bit of time lining out those paragraphs before I sign such a contract. There are no inalienable "developer rights" that need to be asserted. Quite simply this is a case of contract law. If you want to retain the ownership of your code, don't sign a contract that gives it away. Heck, it worked for Bill Gates.
But, put simply, code is owned by its developer even once the client has paid, unless that developer is legally employed by the client or a contract exists that transfers full ownership (and even then it's far from clear-cut).
The gist of that is right. But it could use a couple of clarifications. The developer usually owns the copyright unless the contract explicitly transfers the copyright to the client. If that's the intent, but the contract just specifies transfer of full ownership, then it's not clear-cut because you have a poor contract that does not correctly specify what it needed to in order to legally satisfy the intent of the parties. If it actually transfers the copyright, then it is indeed clear-cut.
Now, the exception to the "developer generally owns it" rule, is when instead of developing a product, the developer is contracted to work on a module that will be incorporated into a larger program. Obviously, there's still room for argument in some cases as to whether the work produced could stand on its own or not, but in many cases it will be clear whether the product stands on its own or is a module of a larger work.
Also, I'd like to address an earlier assertion that it depends on your local and state laws. No it most certainly does not. Copyright is the exclusive jurisdiction of federal law and no state or local law can override or amend it.
Finally, for all the people who want to argue along the lines of:
Before you put any more effort into defending your incorrect assertions please at least let me refer you to information provided by the copyright office. Firstly from the FAQ on definitions:
Although the general rule is that the person who creates the work is its author, there is an exception to that principle; the exception is a work made for hire, which is a work prepared by an employee within the scope of his or her employment; or a work specially ordered or commissioned in certain specified circumstances. When a work qualifies as a work made for hire, the employer, or commissioning party, is considered to be the author.
Please note the "certain specified circumstances" as that is what many people seem to miss. Those specified circumstances are the ones specified in the law, not the ones that you or client think or wish they ought to be, and they are spelled out and discussed here. Seriously, it would be flat-out silly to further argue this point without reading that document.
Finally, I guess I should point out that I'm not a lawyer. Although the misunderstanding of the law put forth in other comments here is so extreme, they make me like a judge by comparison ;-) Especially the (possibly misquote of course) lawyer who apparently led someone to believe that NY has its own version of copyright law. Sheesh. And I bring that up deliberately, because I've seen non-specialist lawyers before give incorrect advice on this subject. Do not ask these questions of a general business attorney--use an attorney who specializes in copyright.
I paid for the development of a web application. It looks like I want it, and it does what I want it to. That's because I thought it up. And now the copyright belongs to the skillful developer who implemented it all? Ignoring that that there is nothing but a verbal agreement and there is no signed document, shouldn't the copyright belong at least in part to me?
While the question of ownership / work-for-hire might exist for proprietary software (MS-Windows, SAP, etc), it most emphatically _does_not_ for software developed for a GPL base.
As derivative works, the software creator is required to accept the GPL to distribute her software. The GPL clearly states that anyone who receives binaries is entitled to source _and_ rights of further modification and distribution. Stallman wrote it this way after frustration with a Xerox printer driver.
Now, the question might arise "What is a derivative work?" "Pure" C code without any OS-specific references obviously is not. IANAL, but I would also suggest that any code that is trivially portable between OSes (simple recompilation with OS flag set) is also not derivative.
But if it runs on Linux/GNU and won't run on *BSD without porting, then it sure looks derivative.
How can you own something that doesn't really exist? Since computer code is essentially electricity and magnetism, do you own both of those as well? How much of it can you own? Owning an abstraction is a pretty impressive feat by any party.
Most of the responses here are arguing legalities. That's nice and all, but most of how business works in the real world doesn't wind up in the court system, but by people just making decisions. So I think it's valuable to present the perspective of a customer.
From my perspective, it MIGHT be acceptable to not get the source code for the work, given one of three possible conditions:
1. I never expect to modify or maintain the application in any way whatsoever during it's lifetime. (We all know this is relatively unlikely)
or
2. I completely trust the contractor to do good work, charge me reasonable competitive rates, and provide some exit strategy should the developer retire, die, etc.
or
3. The program is largely of very limited value, and is highly unlikely to ever be of any great value.
In all other cases, source code is largely a must. Imagine a plumber replacing your old steel pipes with copper, but somehow locking all the pipework down so only HE could work on the pipes. Nobody would stand for that, as pipes are basic infra-structure that survive longer than you or the plumber. Code doesn't always survive that long.. but sometimes it just sits and works for decades (I know I've written code for the short term I never expected to still be used 7 years later).
The case of custom libraries owned by the developer are a special case. Everyone who's done software development for any length of time has bought 3rd party libraries without source code. This case is _mostly_ the same as that, but with some additional risks involved. Contractors aren't in the business of selling 3rd party libraries, so it's likely there's:
No documentation, or at best poor documentation (why write documentation when you're the only one who uses it?)
The API is poor, and not for general usage.
I'd expect the library to be more buggy, since it hasn't gone through testing by multiple different developers trying to do things the author didn't think of.
The above all lead towards greater lock-in to the original author. That's great for the author, but not so great for me, the customer. If the application didn't meet one of my above three cases I'd likely insist on very good documentation of the functions the contractor used from his custom library.
Just for the sake of argument, I'll state that the vast majority of people hiring contractors for software development aren't going to have any clue about any of the above. If you do try to advise them most will not understand how few applications fall into category 1. Not enough people think of code as essentially custom built machines with many many custom built parts inside it. If you told them that, they might start understanding why getting the "design documents" is so important "should the machine ever break down". Then again, most people aren't imaginative enough to understand why they'd ever want to change anything in the application, or how the changing software eco-system will eventually obsolete that program designed 10 years ago to run on Windows 98.
AccountKiller
If I buy a software project from you, I need assurance that I can keep using that project and doing maintenance on it no matter what happens to you or your business. If you die tomorrow, I will need the source code and the ability to modify it as I see fit for the contract to not carry a significant business risk for me. Signing over rights (apart from authorship and other inalienable rights) to your software should be a standard part of any development contract, in case this is not done and you keep ownership, I also expect free maintenance on the code and significantly lower costs(as is common when licensing general use software, such as MS Office, etc). If this piece of software is critical for me, for example part of a contract I made with a client of mine who needs assurance that the software keeps working then it is not possible for me to allow you to keep ownership, sorry.
I've done a significant amount of contract work over the years, "flying solo" so to speak. I've only once had a contention about copyrights, and since then, I've never done work where I don't own what I write!
My explanation goes something like this:
I have years of experience and have developed a standard set of tools that I use to solve different types of problems. I intend to use these tools to cut costs for you, and it's that time savings that makes me worth the money that I'm charging - I'll do a good job in a short time. But I'm writing the software for YOU, not for somebody else, and if I develop a new idea working on your code, I intend to use that same tool elsewhere. So I'll keep the copyrights, leaving me free to do my job elsewhere, and grant you a license letting you use the software as you see fit. You can do what you want to do, I can do what I want to do, and we can both be happy! I will grant you unlimited use license, including access to the sources, and I will make it transferrable - if you sell the business, it's no problem. The only right I won't grant is the right the resell the software, because I don't want to compete with myself!
This has never been a problem - when explained this way, nobody objects and everybody sees what I'm after.
I have no problem with your religion until you decide it's reason to deprive others of the truth.
In other words, he wants to lock them in to using only HI to extend the application. There is no reason he can't deliver it completely unobfuscated, yet still protected by copyright. Explain to them that they have a license to use it, that but they can't give or sell copies to anyone else because of copyright.
This guy should be avoided like the plague. He's like the people how "help" you by registering your domain for you, but put their name as the administrator, so you can't move it somewhere else when you're pissed off with their childish - and VERY UNPROFESSIONAL - tactics.
It's more like if I paid someone to go to IKEA, get me a flat-pack wardrobe & put it together. I would still expect them to give me the allen key which came in the box so I can take it apart & put it back together myself.
He also seems to have confused 'own' with 'right to use'. There's no reason why he can't give his source to his client and still retain the right to use it again himself.
Starting development without a contract sounds like a thoroughly foolish idea, as the terms will be essentially decided by a judge if there's ever a dispute. What the client reasonably expected (a copy of all the source and right to modify it) will be taken into account.
Finally, demanding a large up-front payment is not protecting himself from litigation. You take lots of money up-front and then don't provide the client with what they were expecting (with no contract) you'll end up with no money and lumbered with costs when they sue.
Now I remember why I stopped getting PCPro
FGD 135
While it is technically and legally possible to fully transfer all rights to code you create, I would be very, very careful when doing so. I am currently in exactly this position and pretty much have to sign over the rights to code I create alone, but safeguards have to be put in place or you're pretty much putting yourself out of business over time.
Code, like any "creative" work, follows a style. You have a certain coding style, you have a certain knowledge, you have certain techniques that you know how to use and that you follow. This even transfers through various languages you might use, you will always follow the same style. The same naming conventions (provided you get to choose names and identification pre/suffixes), the order in which certain things are done, the way certain things are done, etc.
If you are not careful, you basically bar yourself from creating the same kind of code later in your life because it will invariably share similarities with your old code which you do not own anymore. Recreating the same functionality will invariably result in similar code which could be easily challenged in court, with a good chance to be identified as plagiarism.
Yes, legally you'd be illegally copying your own works.
We used to have a Bill of Rights. Now, with the rights gone, all we have left is the bill.
It’s not a physical object. It’s information (or an idea). There are different laws in bitspace:
If you give the information to nobody, good luck trying to prove it exists at all.
If you pass it on, there goes your control over it.
Also how can you own something, that can not be taken from you?
It just makes no sense to think of in as a physical object.
The author’s right was meant to be a compensation for the creator, because after all, someone deserves something for it. And indeed, in Germany, you can’t pass it on. Ever. By law. (Urheberrecht.)
Copyright exists as a right for those who copy it. Which made sense in a time when there were media reproduction companies. But it was never meant to protect the original creator. And it still doesn’t.
The thing is: Those laws exist, because people were unable to comprehend the laws of bitspace. And because everything was tied to a physical object, that was no problem.
Nowadays we don’t have that tie anymore. And that’s why we get into trouble.
Luckily, there is a working business model, that acknowledges reality... including the laws of bitspace.
The idea is to completely forget the idea that information would be controllable. And work from that basis.
And what you come up with then, is that if you want money from it, you have to ask for it at the moment you first pass it on. And then stop bitching, since you just gave up control over it. If one client can’t afford that price (e.g. games), you do it like with an investor. Only that all your clients (the gamers) take that place. Like a “If you give me that complete information (e.g. game), I will give you $xx. Signed, $client and $you”
Which is very similar to taking a loan at a bank, based on a solid business model. Having a lot of clients who signed to pay because of your great trailer videos & co, is really the safest bet a bank can make. And if you fail, neither your bank nor your clients will be hurt.
If you succeed, you will take the money, give ONLY your paying clients your work (information), pay your bank, and keep the difference as profits. Rinse and repeat.
The best thing is: It can coexist with the crappy laws and imaginary business models we have now. It doesn’t need any new laws or anything really. You can start using it right now!
Any sufficiently advanced intelligence is indistinguishable from stupidity.
Bullshit. Utter bullshit. You can give the client who wants to switch developers a copy of the source code to allow them to do so, without actually granting them ownership of your supposedly extremely valuable libraries. Write up a contract that says they're only permitted to use them in conjunction with the software you wrote for them (or future modifications thereof), are not permitted to resell, etc. There is a large middle ground between "total transfer of all rights" and "won't even show you the code so you can switch devs", and by presenting such a false dichotomy, you're absolutely trying to blackmail your client into staying with you. It's no wonder they want to leave, and I wish them luck in doing it.
To fight the war on terror, stop being afraid.
As the article says
or a contract exists that transfers full ownership
which almost every contract will stipulate. I'd suggest this guy stops being so precious and realises he's not creating works of art (even these are owned by the client if they were commissioned - well, the copyright is anyway) he's making widgets: be they mechanical, electrical or virtual. The same set of laws and common sense applies.
politicians are like babies' nappies: they should both be changed regularly and for the same reasons
The issue is that of cost and risk. If I am paying for the entirety of the cost of designing the software I expect entirety of ownership. These contracts also typically put the burden of risk on the client since it is usually very difficult to avoid paying at least the majority of the agreed fee regardless of whether the software is up to scratch.
If I was only paying a fraction of the cost of the software, i.e. the cost was being shared between multiple customers, then no I would not expect to control/own it in the same way.
No, but I didn't buy the Lindisfarne Gospels, I bought this bible, I own it and it's my bible. I do whatever I like with it. Tear pages out, glue new ones in, make a lot of paper aeroplanes if I like. But example is only at all comparable if I was paying for finished, mass-produced software. If I pay someone to write a new bible, the default position is that the publisher owns it. They take the cost and risk burden and hence they generally take ownership.
No but I expect him to leave the tap. I expect to be able to pay another plumber to fix the tap, or to do so myself. And by the way, taps do actually come with instructions and use standardised tools so that anyone can fix them. Regardless, again the example is not applicable since the article is talking about creating something new not fixing something old. If a developer is paid to fix an existing piece of software does he expect to own the software?
Technologists aligning their argument with the MPAA, interesting. I'll not bother posting a retort since they're posted here frequently.
Again this is the purchase of a finished, mass produced piece of software, not payment to design a custom piece of software for me. If I pay an architect to design a building, the architect does not continue to have any rights over any use of that building.
"Put simply, code is owned by its developer even once the client has paid, unless that developer is legally employed by the client or a contract exists that transfers full ownership (even then it's far from clear-cut)."
A "work made for hire" is-- (1) a work prepared by an employee within the scope of his or her employment; or (2) a work specially ordered or commissioned for use as a contribution to a collective work, as a part of a motion picture or other audiovisual work, as a translation, as a supplementary work, as a compilation, as an instructional text, as a test, as answer material for a test, or as an atlas, if the parties expressly agree in a written instrument signed by them that the work shall be considered a work made for hire. (17 U.S.C. 101)
And a "work for hire" is considered to be owned by the employer (as author).
So, when engaging people to write code, simply include: "This is to be considered a work made for hire" in the contract.
How confusing is that?
Just another "Cubible(sic) Joe" 2 17 3061
..., then that employer owns the work the employee has done. This is not difficult to understand. If I pay some third-party to do a job for me that requires custom-made coding, then I own the code. If I pay a landscaper to landscape my property, then I own the landscaping and continue to own the property after the job is done.
It is time for everyone to realize that you own nothing that you were paid to do.
In a rush to get the job, the author's company agreed to develop and deliver something to a client without a written contract defining who owns what in the end. Once the work was done, the question of ownership came up. IANAL but I would think that without a contract the law of the land would prevail. In the US the work would probably include the application and if that means the source code also, then so be it.
If the legal niceties of web applications are complicated when there is a written contract, why is this guy surprised when they are even more so without one?
I would think that this is a key point. These are distinct agreements and should be covered by distinct contracts, implied or otherwise. Just because they are handled by the same company in this case doesn't (or shouldn't) tie them together. When the application is completed, the developer delivers it to the client and that part of the deal is done. To throw in a US related car analogy(YMMV), in the US Ford is not allowed to contractually obligate you to buy "Ford gasoline" only as a part of your purchase of the car.
'The tyrant will always find pretext for his tyranny.' - Aesop's Fables
As many have noted, "the rules are what the contract says." So, who owns the contract? What if the plaintive did not have the right to use it? Of course, a usage violation might be a separate issue, but when something is used without the right to use it, the product of that usage can be taken from the abuser. For example, royalties from plagiarized music.
What if a large law firm started copyrighting all sort of boilerplate for new types of contracts, not prior art but forward thinking stuff. Then, like those companies that patent parts of developing standards, they went after everyone who negotiated such contracts in the future. In the case of royalties on intellectual property, they might claim some of that revenue due to the 'power' of the contract that claimed it. This may sound far fetched, but so did process patents.
If you think that is whack, someday, these posts will be taxed. No shit, free speech will not be 'free'.
Books don't have source code.
The "source code" for a book would be the author's imagination and creative ability. The publishing company most certainly doesn't own *that* after they buy the rights to a particular book.
In the software world, if I buy the rights to a program I'm buying the end result of a particular combination of code. I don't get the rights to the individual modules/libraries inside that code.
No sig today...
It all depends on how the programmer does business, and what the terms of the job are.
If I buy a license for Windows 7, or vBulletin, I know I do not own the code to those. Sure, in one of them, windows, I have little/no access to the code, but in vBulletin, I have complete
access to the code. Now based on the terms of the license agreement I agreed to when I purchased it, I am free to modify that code however I want, as long as I abide by the terms of the license, ie only running one instance of the software, and whatever other restrictions they have. This does not mean I own the code, other than any code I added to it while customizing it, nor does it mean I can sell it as my own.
Now, when it comes to freelance coding and the like, it depends on your agreement.
As a freelance coder myself, granted I'm just small time compared to some, if I write a piece of software, and have it up for sale, any buyers get a limited license to use it.
But if I am engaged to do a custom job, I generally turn over all rights to the source code when I am done, and license any of my custom libraries to them. When I do it this way though,
they only get a limited maintenance agreement, such as only one installation, and I will only fix bugs that were in the original code. If the code has been modified at all, I will not touch it.
If they want a more comprehensive maintenance agreement, they can license the code from me, and I will be happy to maintain it, as long as I am the only coder working on it.
I absolutely loathe it when another coder screws up code I have written, then the original customer expects me to fix it.
whether you like it or not, you're in a service industry, and you're only as valuable as your time and materials. If I had software commissioned, and I have, you don't get paid unless I get full ownership. You can bitch and moan about it all you want and try to justify it but I don't pay up front, and I don't pay for things I don't own. No real business person would agree to the terms you guys think you can impose on people.
Newsflash: Ancient work-for-hire rules that have been fought over by writers and photographers for decades hit the software development world. Film at 11.
The author of TFA says it best:
So he isn't clear and up front with his clients and then his business dealings get confused... um.... duh?
I create a Statement of Work for every client that clearly spells out what I'm doing, what they get, how it should work, what they're paying for, and sometimes what they are NOT paying for. I've lost a negligible percentage of projects because I wrote up a SOW and the client didn't go through with it; and to the ones I did lose I say "good riddance". Any client who can't sign a piece of paper to protect both parties is normally the kind of client that knows how to take advantage of a contractor more easily without an agreement in place.
Why are you letting these clowns ruin our country?
If i pay (or not) for software, i should own everything i need to fix or modify it. To use the plumbing example, yes you could ask him to leave his tools, he would probably say no, but either way, you own the work that he did since you own the pipes. If you went out and bought your own tools you could modify, fix, and update his work all you want. Im not really sure the author thought those examples through very well, as far as i know the bible is in the public domain , and as i just explained the plumbing thing doesnt really work. I hope he gets a nasty email from RMS.
... most also have a clause which says if you create code *not* for the company, but while being employed *by* the company at a salary, then anything you write while not at work is also company property, due to you very likely using company time, resources, training, best practices, or something else to do so.
I'm sure this is a widespread practice. It's also highly unethical.
I won't join Slashcott. OTOH, If Beta goes live, I just won't be back until it's fixed. Sorry Dice.
This is why OSS is better. Everyone owns the code. This whole ownership of something intangible is absolute stupidity.
You mention moral rights. Those are very weak in the US. I hypothesize that you live in another country, and what your lawyer told you has no bearing on a large percentage of Slashdot programmers.
I won't join Slashcott. OTOH, If Beta goes live, I just won't be back until it's fixed. Sorry Dice.
"non-exclusive". It should be in all your contracts, and both sides should know what it means. Unless you are working as a salaried employee, or they paid you a HUGE AMMOUNT, then it should always be non-exclusive. Simple.
For all intensive purposes, "whom" is no longer a word. That begs the question, "who cares"?
when i buy a cd i don't expect the _exclusive_ rights on the music on it.
that's the main difference.
Why can't well all just get along and agree on beer-ware transactions in software? http://en.wikipedia.org/wiki/Beerware
Until then, all that Kevin or many are proving in their debate is their ignorance of reading, understanding, and negotiating agreements... ...and why we can't "kill all the lawyers" to whom we delegate by proxy when we refuse to do these simple things.
BTW Kevin, in some legal jurisdictions, I am allowed by law to to reverse engineer even your compiled code unless we have agreed otherwise. QED
Ladies and gentlemen, please. Let me try and *NOT* use a car analogy, but a direct professional parallel. Coders "own their code" after it has been paid for, like an architect owns a building after it's been built/paid for.
Why is this an important distinction/parallel? Easy. The architect passes liability for faults off to the owner after a certain period of time, agreed upon in an initial contract. When the certificate of occupancy (i.e., quality assurance) is issued, and the client takes possession of the building they paid the architect (and engineers, and contractors) to build, it's no longer the architect's liability to maintain that building. That is, unless they are contracted again to do so, for more pay (i.e., a maintenance contract on a piece of software, a la RedHat).
So, do you really want to own that source code, or would you rather treat it like a building that you designed where you document the project, keep all the original source files, learn from the experience, possibly (if not expressly forbidden in your contract) reuse some of the objects of that code in other projects? Oh, don't get me wrong, I am all about "licensing" significant works, like a file system that's new, a new sort of material connection for structure or aesthetics, or something really unique along either of those lines. But, to think that you would want to claim full ownership and responsibility for every bit of code you write could entail a lot more headache than you would care to even think of taking on.
Code is not like a book! Code has utility, function as an executable binary beyond just the lines of text that comprise its source. It is a creative work of form and function, much like a building. Things can go on inside it that, in turn, can also be creative works on their own. Do you presume to own those as well? Would an architect own any ideas conceived within the walls of the buildings he/she designed?
If there is nothing in writing the one with the most lawyers wins.
And if you have enough lawyers it doesn't even matter if it is in writing!
Code is information and like all other creative works that information is not and can never be owned by anyone it is the property of mankind.
It is the commercial rights to a work that can be owned not the work itself. Ther are only 3 kinds of IP ...copyrights, patents and trademarks
Reality:
Copyright is Law.
Break the Law and get sued and lose.
Lose and don't pay, and men with guns come to your house and take your physical stuff.
Therefor, in this reality, non-physical stuff has value as does physical stuff.
Copyright law says I own it.
Copyright law says if you want it, you pay what I say, or you don't get it. (see above about guns)
Market forces says you pay what we agree its worth, not what you think it cost me to develop it.
That is why GPL exists. For example, the GCC toolkit *has* value. That value has "already been paid for". But if you want to modify the toolkit for your own purposes, you agree to give your modifications back to the community. It is a *trade*. Your new value for their "paid for" value. Just because something has already been paid for does not mean it is now free. Quite the opposite.
It is called an *investment*.
Code can't be "owned" as it's not property. If you are in the USA, if you hire someone to write code for you, it would be considered a work-for-hire situation. In that case, the author and the payor would share a non-exclusive copyright on the code (unless they had a contract that specifically transferred the copyright explicitly to the payor). Strictly speaking, copyrighted works are effectively "owned" by the general public, who then offers you a limited exclusive right to making copies of, making derivative works of, or performing the work.
This chap is in the UK, so its a whole different kettle of fish.
In the USA, he owns his own work. Without an explicit contract to the contrary, he still owns it, and even with a contract, he still owns it. As a result, any contract over here where the client really wants the code will include the language along the lines of "even if the law determines that you own the copyright, we the client gets an exclusive, permanent license to use it, and you don't get to give it to anyone else". Its also why my contracts are clear about what they, the client, do get, and what they don't.
On the whole, stuff that we agree that they are going to "own", I keep copyright, and they get permanent, exclusive, right to assign etc. Then there's stuff that I give them a non-exclusive source code license for, and then there's stuff that they only get binary rights to, and for all of that they may or may not have the right to sublicense, redistribute etc etc. There is no excuse not have this clear.
There are memorandums of understanding, and even without paper, there are conversations to be had (and *documented* that I had them if it ever gets ugly which is unlikely if I have them at all). Conversations are an opportunity to explain what they get and why, and why this is a benefit for them. Also, its an opportunity for me to learn if they just want me to do all the hard work and then give it to a script kiddy, or whether they want to establish a relationship. And sometimes the rest of the work will only require a script kiddy, and I'd be bored to tears anyway, even subcontracting it out - and if that's the case, we can work out a price. Its called negotiation.
The other issue in the USA is the IRS. The IRS doesn't care about what a contract says on paper. If I am were to work as an employee would, then I would be an employee as far as the IRS is concerned. So if the client owned what I produce (all of it), that's one big check box on the IRS's duck test. The penalties are significant. For the employer, they would have to pay me as an employee and would owe more tax. As an employee, I would lose the ability to write off my expenses.
I initially thought this was unfair. But after consideration, I think it is quite fair. If a programmer don't have the guts to turn down contracts that basically make them a wage slave, then they don't get to pretend they are an independent business and reap the tax benefits that those of us taking a risk do get. At least be clear that an employer/employee relationship exists, and negotiate accordingly. I could say that pretending otherwise "hurts us all", but while it does to an extent, it *really* hurts those who the IRS look at. I go to great lengths to make sure that what I want to own, I own, and I am taking financial risks to do that. I see it as investment.
The dentist would give you the x-rays because *you paid for them*.
You and the OP may not like reality, but that doesn't change it.
I am going through this now.
A few years ago I was approached by a guy to build an application to handle food processing within restaurants. We agreed that I would be well under my normal rates and that in exchange he would give me a 20% stake in his new company.
He wrote up a basic shareholders agreement that stated things like first right of refusal if I choose to sell my shares etc. However nowhere did the agreement mention copyright assignment of the completed application. I knew that agreement probably should have, but I decided to keep quiet in the event things went south and I could just take my code and walk.
Well, after a couple years things did go south and sure enough I walked. However, my ex partner (who turned out to be your run of the mill crook) was convinced he owned the code since he had paid for the development. This application was pretty cool and had some other potential uses and wasn’t just going to give it away. After consulting a lawyer and spending about 10k in consultations and doing a ton of independent research I learned that he absolutely DOES NOT own the application, more specifically the copyright.
Unless I was an employee or I was making enhancements to an existing application the he already owned (known as a derivative work) he does not own the copyright. The lawyer also explained that being a shareholder is not the same as being an employee and I was free and clear.
Thankfully software does not fall under the “work for hire” concept and that the copyright assignment must be addressed before any work is done using very clear language defining what is being created and that you as the author intend to transfer the copyright once the application is completed. It is usually wise to include language that says you will be retaining your rights to all “background technology”. These are your pre-build libraries all programmers have accumulated over the years.
We've seen this line before in Rand's novels expounding her silly beliefs. The notion that an architect can blow up a building because he does not agree with what the owner has done with the design leaps to mind. These days we consider people who blow up buildings to be terrorists unlike Rand who considered them a hero of capitalism.
How is a photographer's reputation damaged if a married couple make a dodgy print at home for themselves, their parents, or whatever? The public will see the photographer's website and portfolio, which will only contain what he wants.
The only example I can think of is if the couple put dodgy images up on a website, and then said "Taken by such-and-such" - but then I have no problem with that being illegal, that would be a case of false or misleading information. But if they just put up the images, how's that a problem?
a DVD of low resolution images
Wait, all that waffle about reputation, yet they're happy to give out low resolution images for public websites?! Why not high quality ones - both for the benefit of the married couple, and so that the photographer's poor little reputation isn't tarnished?
(I write code for a living. Should I retain copyright, so my "reputation" isn't harmed if my company does something stupid with it?)
Here, are we to feel that the people who paid for the code don't own it and can't do what they want with it? Are developers acting the part of the MPAA now?
Lots of the responses are like "you own what you contractually purchased, according to said contract", which is cool 'cause that's what I think should be the case.
But the tone of the original post is Weird.
Just sayin'
I do admit to typing hastily and badly mangling details. I had company and didn't want to spend long discussing this. Changing the house that you own is perfectly fine, all legal and dandy. Reproducing the house into a blueprint would not be alright, if the blueprint was copyrighted in modern times because of all those Bono and Disney extensions on what a copyright covers. Taking a blueprint that you licensed for a single building and building two would go against your contract, invalidating it and probably causing a copyright violation. Same works if you just measure the work and have someone else recreate it; reproduction of a copyrighted work. You could not photocopy a book, then type from that and claim it was not infringement because the photocopy was not copyrighted.
However, to respond to the 'bullshit', you could have at least read about photography and copyright. There is an exemption for photographing copyrighted (or other) articles if they are out in public. Otherwise, a photographer taking a picture of a recently made statue would be in violation of copyright laws. If you wanted to point out that I misrepresented Title 17, Chapter 1, Section 120 of the Copyright Act, you better damn well get both points right next time. Since that only covers the modification of buildings, and the photographing of them, I would have to dig around to find the exemption for articles of clothing. I seem to remember it relies on the inability for an average viewer of the photo to discern whether the shirt in question belongs to BigNameDesigner or is just a Chinese knock-off. You see this a lot in TV shows where, if a brand name would show up, it is 'greeked' out. My suspicion is that the same legal ruling there is what holds for photographers. But I wouldn't push my luck by trying to photograph a model wearing a one-of-a-kind Dior gown and later using it commercially without a valid model release for the model, and the gown. Possibly an application section 113 C, but I really would need more time to dig around.
blast, still can't get § to show up as the Section character. Oh well, too tired.
"If someone pays you to perform work, they own all rights to that work."
No, it's not so cut and dry.
If you are an independent contractor or have a company that has a contract with the client it depends upon your contact terms with the default being that the person who does the work owning it.
If you're an employee working for the company you do the work for then they own the work.
If you're an employee of company X and do work on your own time for company Y then it could go either way. Again it depends on either your employment contract or if company X and company Y are in the same line of business or not. If they are then company X owns the work and you might get in trouble moonlighting and profiting without them knowing. If they are not in the same business and your employment agreement allows you to own your own work off hours then you own the work and company Y doesn't nor does company X.
It all depends. Consult a lawyer.
Whenever I'm an employee (which I haven't been in more than two decades) I always have a clause and an appendix that excludes all my previous works and their derivatives and certain areas of projects that I'm working on. As long as you're not working on stuff that is the same line of business as your employer then it's likely that they'll likely have no problem with such clauses. If they do then maybe reconsider them as an employer if you have that financial option. Or put your project on hold till the non-compete clauses expire (non-compete clauses are not valid in all jurisdictions).
Again, see a lawyer.
The default owner of the copyright holder is the creator. When that is done by the will of the artist, the default owner is the artist. When the artist is hired by a patron, the patron is the default owner.
Agh. That didn't come out right. It should read as follows:
The default owner of the copyrights is the creator. When the creation is done by the will of the artist, the creator is the artist. When the artist is hired by a patron, the patron is the creator as a matter of law (and the artist merely an agent of the creator).
In other words, as said in my earlier comment, there is no presumption that the artist is the creator when the work is a commissioned one; the presumption is that the commissioner is the creator.