LGPL Terms & Confusion Over Commercial Application Distribution

OK.

First – Sorry for not finishing the Inkscape Cartoonify Tutorial! It is about half-finished and still in progress, but on hold as I work on other pressing tasks! Thanks for your continued patience! ❤

~~~~~~~

Now 

The last week I’ve been feverishly trying to read as much about the LGPL, or Lesser General Public License, documents and rules for compliance with distribution of Open Source Libraries in Commercial Products (not to be confused with GPL, General Public License, which I will not be addressing and don’t know much about except that there appear to be more rules and restrictions).

In a nutshell, this is what the LGPL is: a free and open source (F/OSS) copyleft license program published and supported by the Free Software Foundation (FSF) (please correct me if I misunderstood something!).

Additional note from Wikipedia:

  • “The LGPL places copyleft restrictions on the program governed under it but does not apply these restrictions to other software that merely link with the program. There are, however, certain other restrictions on this software.
  • The LGPL is primarily used for software libraries, although it is also used by some stand-alone applications, most notably Mozilla and OpenOffice.org

*Key words for me are SOFTWARE LIBRARIES, which is exactly what I am looking for, and why I am looking to the LGPL for distribution and compliance guidance.

~~~~~~~

While reading,  you probably noticed this term “Copyleft” – sounds funny right? I’ll put the GNU.org definition here, b/c I had learn it in order to understand anything about LGPL but otherwise won’t delve deep into:

  • Copyleft is a general method for making a program (or other work) free, and requiring all modified and extended versions of the program to be free as well.”

~~~~~~~

At the end of it all, I wanted to blog about this because:

A) I find some of the descriptions and rules to be vague, as well as am, and I suspect others are, confused about WHAT TO DO to be in compliance, and

B) all I am really trying to figure out is how to apply the LGPL to the following situation (which I have been posting ’round the net to see what kind of feedback I get):

1. Can I deliver/distribute a closed source commercial application (ex: android app) using an LGPL unmodified, statically linked, open-source library?

2. If so, how do I interpret LGPL Section 6 (version 2.1) appropriately in order to be certain that I am in compliance?

**From what I have been reading, I CAN do this, and may charge a fee if I choose, but have to follow a very specific set of rules to do so, such as releasing the source code for the library and the mechanism that we program to read/access the data in the library, clearly acknowledging the work and any/all copyrights. I also understand that Statically Linking a library still falls under the category of a Derivative Work, since the library is being incorporated into the software in question, and thus, I would have additional considerations to follow (still working trying to translate the lingo in my non-technical head!).

I’m a big fan of F/OSS, but have never used it as part of commercial work before, and definitely wish to give credit where credit is due.

Thanks for your input!

~~~~~~~

Pineapple Tidbit:

Apparently one can CHOOSE which LGPL version he/she wants to follow – as I now see that there is a version 3, with 2.1 and 3 appearing to be the most commonly used license versions. Curious as to why Version 3 doesn’t 100% supercede 2.1…?

Do you have your library card?

The concept of a software library is almost exactly like a physical library that you might visit.

A software library, as I have come to understand, is a collection of data, instructions, methods, algorithms, and/or set of functions grouped together to fulfill one or more than one specific task or purpose.

I noticed while watching my husband over the years, that whenever he needed to code a function that he knew he would need to use over and over and over again, he would compile this code and store it in one of several libraries he maintains – kind of like writing a book, then shelving it, unshelving it, opening it, reading it, then closing and putting it back on the shelf gain once the knowledge desired was attained. For example, because we are interested in making apps for Android/Google and Apple, we have to have a user interface – .i.e. a screen with buttons on it. Since my husband has already coded several types of ‘buttons’ and functions of buttons before, he then pulls this saved code from his software library, and essentially “copypasta’s” it into the code for the new app, performs tests, etc. He seems to do this for a lot of things we take for granted as nontechnical users – buttons, lines, random number generators, sounds, scroll features, zoom features, and many other things I just don’t think about on a day-to-day basis.

On a professional level, if you’ve got programmers working for you, I would suppose that they are also making and maintaining their own libraries, or adding to and using libraries you may already have as part of your company assets. Although, I would think that also means that you may be employing programmers that may plagiarize others’ code, as that seems to be prevalent with university students; whether that is an intended action or not – all the more reason why a technical person should allowed to interview software developers rather than human resources personnel alone (another topic I would like to expand on later).

~~~~~~~

Break it down!

In order to ask questions 1 and 2 above, I needed to understand what I wanted, and discover that there are actual words and definitions for these things (who knew?)! It might sound dumb to people who are very familiar with F/OSS and programming in general (like my exceptionally patient life partner and eternal nerd husband, who’s eyes brighten when I oh so unknowingly ask questions about things in ‘his world’ that I can only hope to comprehend…thanks love!) but to a business or organization focused person, you might as well be wearing a shirt that says “It’s all greek to me” or my personal favorite: “Huh?” However, if you are going to be employing programmers and potentially using open-source libraries, you bet your whiskers you’ll want to understand some of the legal implications involved of using these in your commercial applications, especially where you charge $$$ for.

With that said, I’ll start with Static Linking and Dynamic Linking and how I figured out which one I would need for the open-source libraries I want to use.

~~~~~~~

Static Vs. Dynamic Linked Libraries

Think about what static and dynamic suggests to you as first, without trying to define these terms above. When I think of static, I think of something that doesn’t move, but otherwise, a static object that by itself doesn’t do anything, and doesn’t change. Dynamic then, may conjure up images of moving energy or parts, and the sense of being ‘of the moment’ or spontaneous. Does that help? Lol, if not, I hope this does!

Tech Def of Static Linked Lib: 

Wiki Def of Statically Linked Library: “In computer science, a static library or statically-linked library is a set of routines, external functions and variables which are resolved in a caller at compile-time and copied into a target application by a compilerlinker, or binder, producing an object file and a stand-alone executable. This executable and the process of compiling it are both known as a static build of the program.”

My understanding:

A library is in itself a software program. If I want to statically link a library with my own program. I, or -let’s get real- an employee, would have to write code that ‘talks to’ the library, then add this library to my program (simple to say, harder to do I’m sure). In this way, the library no longer exists independently of my program, as it has essentially been ‘absorbed’ into it. Statically linking also makes it much easier for my program to call up information, instructions, etc, from the library for execution, as there is no ‘middle man’ by which you would have to communicate through if the library and the program were to remain separate.

However, even though you didn’t modify the library’s code, the resulting combination of the two produced this “new thing” and is STILL considered a Derivative Work, as defined by the terms in the LGPL via the Free Software Foundation (FSF) —->if I am wrong please correct me!

Tech Def of Dynamic Linked Lib:

Dynamic-link library (also written unhyphenated), or DLL, is Microsoft‘s implementation of the shared library concept in the Microsoft Windows and OS/2 operating systems. These libraries usually have the file extension DLLOCX (for libraries containing ActiveX controls), or DRV (for legacy system drivers). The file formats for DLLs are the same as for WindowsEXE files — that is, Portable Executable (PE) for 32-bit and 64-bit Windows, and New Executable (NE) for 16-bit Windows. As with EXEs, DLLs can contain codedata, and resources, in any combination.

 In the broader sense of the term, any data file with the same file format can be called a resource DLL. Examples of such DLLs include icon libraries, sometimes having the extension ICL, and font files, having the extensions FON andFOT.[citation needed]”

 My Understanding:

Ummm, sooo….yeah, that definition makes little sense to me – what I do recognize though is all those DLL, or dynamic linked library, files I had to download to play Diablo 3 (tastiest present game ever btw).

From what I understood, dynamically linking a library to your application still requires the programmer to code the methods and instructions for talking to the library, but with some key differences.

The unmodified library REMAINS separate from your application. This also allows for OTHER programs to access the DLL  (assuming they have been programmed to do so) as well. In the husband example about making and using libraries, it was explained to me that because so many applications use the same features, functions, similar instructions, etc, having DLL files can be a very efficient way of managing multiple program functions and executions. If you think about it, if Software A uses a button,  Software B uses a button, and Software C uses a button, all on the same computer system or device, why would you then add the same button function THREE times for each Software package? If you did, you would consume more hard drive space and time to process each instruction from each different place over and over again. By using a DLL that executes the function called “button”, you could save both hard drive space and processing time and power.

**However, it does appear to be less efficient in the case where you may have only one program requiring the use of one library. In this case, the program having to call upon the DLL to execute functions and instructions may take up MORE time because of the ‘middle man’ concept – i.e. in order to talk to a DLL the program might have to rely on another mechanism, hardware, or other software to ‘deliver the message’ each time the program needs to execute a task. Here then, it would make more sense to go with a Statically Linked Library.

(Oh whew! I don’t think that explanation was as successful for DLL – if anyone can explain this in simpler words, please do!)

What this means for LGPL Compliance?

I believe this means that under the LGPL you CAN distribute your closed source application using the statically linked, unmodified library, as long as the you still release the library’s already open-sourced code, acknowledge copyrights, provide copy of lgpl, etc. Not sure if that means I would still have to release the part of my program coded for talking to the library, which I would guess is probably a good idea.

OR: release the program with the methods and instructions for talking to the library but don’t link or use the library itself – this way lets users provide the libraries under LGPL compliance, but you, the company/programmer doesn’t have to since you didn’t use, modify, or plagiarize any LGPL libraries (My guess is that there are some severe ethical implications here).

*Unfortunately, if we were to try to dynamically link libraries for future smartphone apps – we would then have to somehow deliver the both the app and the library separately to users right? It doesn’t seem like this would be an efficient way to do business and attract/retain customers and I don’t how you could distribute both independent parts as one download. If anyone has done this, I would love to hear about your experience.

~~~~~~~

End of the Road: 

Well , this is how far I’ve been able to get, but I know I’m not all the way there yet. Unfh – haven’t even really talked about what’s IN the LGPL! It seems like I better figure out what ‘object code’ and ‘executable form’ are before I blab any further.

TL/DR?:

I want to understand if and how I can distribute a closed source commercial application (as closed as I can at least) using an open source, unmodified, statically linked library while fully complying with the Lesser General Public License.

~~~~~~~

Whew!

Thanks for reading folks and I’ll write more on this topic once I’ve learned and understood a bit more.

Happy Memorial Day! ^_^

~~~~~~~

**disclaimer:

If any one comes here by accident thinking I’m an expert on the LGPL (HA!) please do NOT take these words to be some kind of gospel truth, get yourself in trouble with the FSF, and piss off open-source developers everywhere.

**Love our open-source developers!

Without them, many of us couldn’t do what we want and/or need to do function in this computer-oriented society! Many companies wouldn’t so easily be able to turn a profit if they had to design and code everything from scratch themselves (cause then you’d actually have to pay a software engineer and programmer what they are worth and keep them employed for a very long time), and shame on any companies that are illegitimately and illegally distributing F/OSS for profit, claiming it as their own spark of genius. :::hands jar of doodoo butter::: lol!

another resource:

http://answers.google.com/answers/threadview/id/439136.html

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s