NOTE: This is an in-progress document and is posted here for review and comment only.
Commercial
Development, Community Benefit License
Version 1.1
(draft), January 2009
© 2008-2009 by Blue Ninja
Software
http://www.blueninjasoftware.com/cdcbl
This license may be reproduced and/or used
verbatim by anyone, but may not be altered (with the exception of
using your own individual or company name in the actual license
text).
Overview
This license targets small software shops and freelance
developers. It aims to be a pragmatic compromise between the ideals
and philosophy of the Open-Source movement, and the need for many
companies who purchase software development services from software
shops and freelance coders to have additional rights and privileges
to the code they purchased. It also attempts to balance the
proprietary and sometimes confidential nature of custom software
developed for clients against the reality that many parts of even
specialized applications are generic and reusable.
The “short” version of this license agreement is this: The
licensed software is a piece of the overall application, and is
either generic and reusable in non-proprietary scenarios or
implements public or otherwise open APIs or algorithms. Further, the
use of this code by other parties or the public does not diminish the
value of the overall application to the original purchaser. As such,
while the original purchaser has full usage and distribution rights
to the code, they do not (or logically/legally cannot) claim
ownership or control of it.
While developed by and for Blue Ninja Software, this license may
be freely used by anyone, by replacing “Blue Ninja Software” with
their own name or company name in the license text.
Benefits
to the developers
It allows the coders to freely reuse generic code, with the
knowledge and consent of their clients, with less risk of
intellectual property legal action. While it is common practice for
coders to do this – and quite reasonably so – it often runs the
risk of copyright infringement or other IP legal action if one
client were to raise an issue with “their” code being sold to
other clients. This license aims to explicitly protect common, sound
coding practices from the legal threats of those who do not
understand the nature of software development.
It allows the coders to sell the code to multiple clients,
without violating the rights of the first purchaser.
Coders can spend less time developing new applications that
can benefit from pre-existing libraries, which have already been
developed and tested. This allows them to speed up the development
cycle, and offer more competitive pricing to their clients.
In cases where the open-source community contributes testing,
enhancements, or bug fixes to these libraries, this further helps
the coders.
It allows developers who are sympathetic to or wish to be a
part of the Open-Source movement to contribute, without having to
give up or make significant changes to their current means of
income.
Unlike the LGPL, it does NOT allow other for-profit entities
to sell the libraries, in source code or binary form. While everyone
may benefit from your work, only you and your client may profit from
it.
Benefits
to the paying clients
When parts of an application they are purchasing rely on
generic, reusable code, they can get an already-developed,
already-tested library instead of new code that requires time to
implement and test.
With some of the work already done, they can expect to pay
less for an application using these libraries than they would to
have the entire project coded from scratch.
As only the generic, reusable portions of applications they
purchase are re-used, they are not sacrificing control over any
proprietary functionality or knowledge, so there's nothing to lose
and no risk.
Benefits
to the Open-Source community
It opens a new source of professional-grade code to the
community, which may be freely used for educational or Open-Source
projects, with less risk of IP legal action.
Hopefully, it will help companies that purchase coding
services to think more logically about the nature of code
“ownership”, and help differentiate what's truly novel and
proprietary, from what's basic, common functionality.
Why
this license originated
Blue Ninja Software develops applications and libraries for a
number of clients. While it is not unreasonable for a client to
desire exclusive rights to software they pay to have developed, there
are many common modules and libraries that are generic in their use.
Furthermore, the idea of “owning” generic algorithms or methods
seems ridiculous, as these methods are often public, common sense, or
needed for such a wide range of applications that the concept of
exclusive rights to them could only make sense to a deranged IP
attorney.
An example: Blue Ninja Software recently developed several
applications for different clients that required USB HID device
interfacing. The .NET Framework does not provide a USB interface as
of yet, and many libraries and samples people have posted in various
forums and code sites offer limited or specific functionality, or
rely heavily on unmanaged code, filter drivers, or other undesirable
dependencies.
To address this, we developed HIDLib. This library is a
general-purpose library for interfacing with standard HID-class USB
devices. These interfaces and protocols are open standards for anyone
to use, so the notion of one client “owning” the code to access
HID devices is irrational. Furthermore, the idea of re-coding the
entire library again, somehow differently enough to still work while
not violating the copyright of the previous incarnation version, is
ridiculous. So, it makes sense that such general-purpose reusable
libraries fall under a less restrictive license.
While we specifically negotiated the non-ownership of HIDLib with
our clients, we wanted to have a general system in place for dealing
with this type of issue in other applications as well.
The goals of the GPL are admirable, but too many of our clients
wish to “own” the code they buy for the proprietary applications
they wish to sell, and will not agree to making their source code
available. On the other hand, the LGPL allows any 3rd-party to use
and sell applications that use pre-compiled libraries, allowing other
for-profit entities to make money off our hard work.
What we wanted was a compromise: Something that let us do business
with our clients, allowed us to contribute to the community, and also
prevent other entities from profiting from our work. This seems like
a good way to let proprietary companies contribute to the
availability of open-source code, by funding its initial development
and gaining some exclusive rights in exchange (namely the right to
profit from the use and sale of the code).
The
License
The text of the license is as follows:
This code is free, open-source software, and can be used,
modified (derived works must also use the  CDCBL license), and
distributed by anyone, except for commercial purposes (except as
noted below), as per the terms of the “Commercial Development,
Community Benefit License” published by Blue Ninja Software. You
should have received a copy of this license with this code, normally
in a file called “License.txt”. You can also obtain it from:
“http://www.blueninjasoftware.com/cdcbl”.
Commercial Use
The licensed code may not be used in commercial applications by
anyone without permission from Blue Ninja Software, with the
following exceptions:
The original developer (Blue Ninja Software).
The client(s) who funded the original development by Blue
Ninja Software.
Permission for other commercial use is negotiable with Blue
Ninja Software, generally in exchange for development services or a
license fee.
In the above cases, the licensed code may be redistributed as
part of a larger commercial application, but may not be sold
separately. The larger application must use the licensed code as a
functional part of its overall capability, such that the licensed
code does not constitute the substantial majority of the larger
application's functionality.
No Warranty
Unless a specific warranty or service arrangement is made
privately between parties, which applies only to those parties and to
no other party, there is NO WARRANTY, express or implied, of any
kind, including that of merchantability or fitness for a particular
use, associated with this software.
When
to consider applying this license
If some part of a software project is going to incorporate
standard, reusable, or generic code and the use or availability of
that code in other applications or to the general public does not
substantially harm the original purchaser's desire to use or market
their application, then this license may be suitable.
When considering licensing part of the Overall Application
developed for a client, the developer will need to make clear to the
buyer that the purchased application will partly be implemented using
CDCBL-licensed code. The buyer will need to understand and agree
that:
It is understood that the Licensed Code provides generic,
reusable functionality that is not specific to the operation of the
Overall Application, and that use of the Licensed Code by other
entities will not dilute the originality or uniqueness of the
Overall Application. This may be due to any or all of the following
reasons:
The Licensed Code implements a public algorithm, therefore no
single entity may claim ownership rights to it. Examples include
common statistical functions, scientific formulas, etc.
The Licensed Code implements a public interface to other
code, which is designed for use by the general public, and therefore
no single entity may claim ownership rights to it. Examples include
documented Windows APIs, public Web Service APIs, and interfaces to
public software libraries or SDKs (DLLs, .NET assemblies, etc.).
The Licensed Code performs a generic, common function that is
applicable to a wide spectrum of software applications and is in
common use, such as handling the sorting of a list box, parsing an
XML file, or sending a file via FTP.
How
to apply this license to your code
The recommended way to use this license is to ensure that the code
to be covered under this license is logically separated from the
overall project code. For example, encapsulate it in a separate
module, class, assembly, library, etc.
Once the code to be covered by this license is separated from the
rest of the code, place the text of the license in the comment header
on each of the source code files that will fall under this license.
For example:
---------------------------------------------------------------------------
HIDLib: A managed HID device interface library.
Copyright © 2008-2009 by Adam Yarnott, Blue Ninja Software
Website: www.blueninjasoftware.com
E-Mail:
This e-mail address is being protected from spambots. You need JavaScript enabled to view it
This code is free, open-source software, and can be used, modified (derived
works must also use the CDCBL license), and distributed by anyone, except
for commercial purposes (except as noted below), as per the terms of the
"Commercial Development, Community Benefit License" published by Blue Ninja
Software. You should have received a copy of this license with this code,
normally in a file called "License.txt". You can also obtain it from:
http://www.blueninjasoftware.com/cdcbl
Commercial Use
The licensed code may not be used in commercial applications by anyone
without permission from Blue Ninja Software, with the following exceptions:
1.The original developer (Blue Ninja Software).
2.The client(s) who funded the original development by Blue Ninja
Software.
Permission for other commercial use is negotiable with Blue Ninja Software,
generally in exchange for development services or a license fee.
In the above cases, the licensed code may be redistributed as part of a
larger commercial application, but may not be sold separately. The larger
application must use the licensed code as a functional part of its overall
capability, such that the licensed code does not constitute the substantial
majority of the larger application's functionality.
No Warranty
Unless a specific warranty or service arrangement is made privately between
parties, which applies only to those parties and to no other party, there
is NO WARRANTY, express or implied, of any kind, including that of
merchantability or fitness for a particular use, associated with this
software.
---------------------------------------------------------------------------
Of course, you would replace the program name, developer name, etc.
with the information for your project. The URL to the CDCBL license
text must always remain pointing to the canonical source for the
license, http://www.blueninjasoftware.com/cdcbl – this must not be
altered.
If you are a programmer working for another company or school, you
should also get a signed "copyright disclaimer" for the
program, to ensure that rights over it are not claimed by the company
or school. For example:
Big Software Big Prices, Inc., hereby disclaims all copyright and patent
interest in the program "MyProgramName", written by Developer Name.
<Signature of owner or legal rep>, Date: / /
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~ ~~~ ~~~~~~
<Name of signer, Title>
Code
buyers: What this means for you
First off, let it be known that:
You have full usage, distribution, and sale rights to all of
the code you are buying, including the portions covered under this
license.
No other entity may claim rights on any of this code which
would hinder your ability to use, distribute, or sell any of the
code you are buying.
The original developer may use the specific portions of code
covered by this license for other projects, whether commercial or
open-source. Since the portions of the code covered under this
license are generic and non-application-specific, such use of this
code will not infringe upon your rights to any specialized or
proprietary capabilities of the application you are purchasing.
No other entity may sell this code, unless it is an entity
that you explicitly permit to do so (such as if you choose to
sub-license this code).
Many companies who purchase source code insist on owning the
copyrights to the code. While in many ways this makes sense, the
nature of code is different than many other works to which copyright
is applied. For example, an author could certainly be reasonably
expected to be disgruntled if another author copied a chapter from
his book.
However, source code is not just the finished product, but all of
the instructions on how to build that product. An author, most would
agree, would have no right to tell another author that he cannot use
the same process for laying out the text on the pages, cutting them,
and binding them into a book. In other words, the “story” is
copyrighted, but not the methods used to actually produce the book.
Similarly, while the designs for an elegant home may be
copyrighted by the designer, one cannot expect that such minute
details as the wiring of electrical sockets or the placement of a
sink in the kitchen, as part of that home, are also under the
exclusive ownership and control of the designer.
In order for any piece of software to perform, it must communicate
with the computer on which it runs, and perhaps with other devices
attached to the computer. In most cases, the steps needed to perform
these actions are open standards available to the community at large.
For example, if a program uses the mouse to click on buttons, it's
hardly the right of the owner of that application to claim that the
code which processes the movement of the mouse or the clicking of the
button is exclusively theirs, and that no other application may use a
mouse to click buttons.
With software as with books and houses, the overall functionality
or design may be copyrighted or owned, but the underlying fundamental
framework or process of building the finished product is too general
and common to own.
The goal of this license is to clarify the separation of “overall
functionality or design” from the common, generic underlying
framework that applies to software in general. This license is
intended to identify one or more specific capabilities of a larger
piece of software that are generic and common in nature, and which as
such can be re-used by the developers or the community at large.
By placing certain parts of the software source code under this
license, the developers feel confident that you will agree that the
identified capabilities are not specific to the overall application,
and their use in other future applications for other clients or by
the community at large will in no measurable way dilute the value of
the larger project.
In essence, the building designer is asking you to say, “I agree
that I have exclusive rights to the house I have paid you to design
for me, but I also agree that you are freely allowed to design other,
different houses that also utilize the generic idea of having a sink
in the kitchen, and that people in general may use the same common
methods of putting a sink in any kitchens they wish to build or
remodel.”
Frequently
Asked Questions
Note: These FAQs are specific to Blue Ninja Software's use of the
CDCBL license. If another entity uses this license, they may choose
to supply their own FAQ, and these may not apply.
If I modify a CDCBL-licensed
program, can I redistribute or sell it?
You can redistribute it, but the modified code must also be
distributed under the CDCBL license. We request that you notify us of
such a redistribution, so we can keep track and properly direct
support questions we may receive. Also, if the modifications are
deemed suitable for inclusion in our maintained version of the code,
we'd prefer to do that rather than have multiple branches in
distribution. In this case, authors of the modifications will be
fully credited for their work.
Selling modified versions of CDCBL-licensed code is NOT permitted.
This undermines the work of the original authors. However, we are
willing to work out a commission for the sale of a commercial license
for the modified code, based on the extent of the modifications.
Other Questions
For any additional questions, contact
This e-mail address is being protected from spambots. You need JavaScript enabled to view it
or see the CDCBL forums at
http://www.blueninjasoftware.com/support-forums.html
Revision
History
Changes since Version 1 (draft)
|
Libraries & Controls 