Software Development Agreement – Who Really Owns The Intellectual Property?

By | Copyrights, Intellectual Property, Licensing, Licensing Agreements, Open Source, Software, Software Agreements, Software Lawyer | No Comments

software development agreementWhether you’re a developer or a client, one of the most important things to cover in your software development agreement is who owns what intellectual property (IP) rights.

Surprisingly, most developers and their clients either don’t know or having conflicting views on the subject.

Imagine you’re a client that’s just obtained an advantage in the marketplace with new software. Then you discover your developer now works for one of your biggest competitors on a similar software project.

Or, let’s say you’re a software developer. At the end of a project, the client is happy with your work but makes an off-the-cuff remark about owning the new software lock, stock, and barrel. You wonder if the client understands that’s not the case.

According to Dallas Software Lawyer Mike Young, there are two competing interests at play. “The client wants ownership while preventing the developer from re-selling the software to others,” he said. “On the other hand, the developer wants to keep ownership because some code can be recycled and used on projects for other clients instead of having to reinvent the wheel from scratch.”

So, how do you balance these competing interests in a software development agreement?

get software development legal protectionOne method is to use a combination of licensing with non-competition provisions.

How does this work?

The developer retains IP ownership, licenses the software to the client, and agrees to restrict the purposes for which the code can be recycled. Often, this means the developer is agreeing that for a period of time, the developer will not use the software to compete with the client or recycle the code and sell it to one of the client’s competitors.

What if the developer doesn’t own some of the code used in the software?

The general rule of thumb is you can’t convey what you don’t have.

When it comes to software development, there’s often is some code the developer does not own. For example, a developer’s license has been purchased from a third party, the developer is using open source licensed code (e.g. GNU General Public and Creative Commons licenses), or some of the code has been taken freely from the public domain.

In other words, there may be multiple tiers of intellectual property rights associated with a single piece of software. And if those are not clearly identified in the software development agreement, it’s a recipe for confusion, hard feelings, and litigation.

What if the developer is the company’s employee?

Even if employees are doing software development for an employer, it’s risky to assume the software is the employer’s intellectual property as a work made for hire for two primary reasons.

First, certain criteria must be satisfied before the software is considered a work made for hire.

Second, the employee(s) developing the software may have licensed some of the code, used open source code, or taken code from the public domain.

Employers can reduce these risks by taking preventative steps before development begins. These actions can include written employment agreements that cover works made for hire, implementing employment guidelines to ensure the work-for-hire criteria is satisfied, and establishing a clearly defined project scope of work to identify the coding resources for the project and related intellectual property rights.

IP Ownership Is Negotiable

Whether you’re an independent contractor, client, or an employee involved with a software development project, it’s important to understand the intellectual property rights are frequently negotiable, i.e. there’s no one-size-fits-all standard to apply across all projects.

Before negotiating, work with your software lawyer to identify what you must have, what would be nice to have, and what you can live without. This makes it easier to cut a deal where each party gets what they want from the project.

Google-Oracle: Java Infringement Trial Circus

By | Copyrights, Intellectual Property, Internet Lawsuits, Open Source, Patents, Trademarks | No Comments

There’s one key lesson you can learn from the clash of Oracle and Google in the courtroom over whether Google’s Java use in Android OS has infringed upon Oracle’s intellectual property rights…

The Internet continues to expose current patent, trademark, and copyright law as obsolete because the legal system is ill-equipped to identify and protect your intellectual property in the 21st Century.

It isn’t a matter of copyright infringement, patent infringement, or trademark infringement. The issue is that intellectual property law cannot keep up, which begs the question of whether it should in the first place.

This isn’t some anti-capitalist rant demanding intellectual property be in the public domain or distributed via a copyleft license. Instead, it is a reflection that current IP laws create trolls (Righthaven) who litigate and dinosaurs who abuse the system (RIAA and MPAA) rather than truly serving the rights of intellectual property owners while promoting entrepreneurial creativity.

So who wins in the Google Oracle Java Android dispute? Absolutely no one except the litigators who profit from it. And that’s a shame.

OpenCamp: Death of WordCamp Dallas

By | Blogging, Open Source | 4 Comments

Dallas WordCamp has died an untimely and utterly unnecessary death. Instead of the annual event devoted exclusively to WordPress, this year’s event will be OpenCamp. At OpenCamp, Joomla and Drupal will also be covered.

Frankly, I’m concerned that OpenCamp isn’t inclusive enough.

Why isn’t OpenCamp covering Frog CMS, Umbraco, Mambo, ocPortal, Magnolia, XOOPS, etc. If open source content management systems are now the theme, let’s include everyone.

Why not broaden the camp to include open source operating systems too?

Yes, I’m yanking your chain.

OpenCamp is a bad concept based upon the false premise that it is too costly to run the annual two-day event as WordCamp exclusively for WordPress bloggers and designers.

I understand and appreciate the work involved with coordinating and setting up such an event. Yet there are two fundamentally mistaken assumptions made by the organizers when they made their decision to turn this into a techie Kum ba yah fest.

First, the organizers mistakenly assumed that jacking up ticket prices was the way to raise revenue to meet expenses. In reality, the costs could have easily been met (and exceeded) by sponsorships and running the event like Ken McCarthy’s System Seminar. If you’re unfamiliar with the concept, System Seminar speakers must deliver valuable content to the attendees and at the end are permitted a couple of minutes to make a pitch (some don’t). The event organizer takes a cut of each sale made. This is not a pitchfest. Deliver value. Sell something at the end. Split the profits.

Secondly, there is a mistaken belief that all prior WordCamp expenses were necessary. A speaker’s dinner, bowling party, ASL interpreters, funding for speaker travel, etc. are all nice things to have but they can be cut if it means keeping the event as a WordCamp rather than EverythingCamp.

I’d like to thank the WordCamp organizers for the past two years for providing value to attendees. Your hard work was appreciated. Killing WordCamp and replacing it with this atrocity is nuts. Let the other CMS groupies have their own separate events rather than bastardizing this one.

Let’s hope that Matt Mullenweg and his new WordPress Foundation will host a WordCamp Dallas in the future. If you want to attend a WordCamp in another location, here’s a link to the WordCamp schedule.