PeterIf you've just wandered over to FOSSwire and you're wondering what exactly this 'FOSS' stuff is, or if you're not completely sure about what exactly the free software and open source ideals are, the difference between them, or want a refresher, you've come to the right place.
FOSS stands for Free and Open Source Software. In fact there are many terms for this including OSS (Open Source Software), free software, FLOSS (Free/Libre and Open Source Software). Confused yet?
The ideals behind FOSS basically come down to the following points (I've lifted these straight from the Free Software Definition at gnu.org)
- The freedom to run the program, for any purpose (freedom 0).
- The freedom to study how the program works, and adapt it to your needs (freedom 1). Access to the source code is a precondition for this.
- The freedom to redistribute copies so you can help your neighbor (freedom 2).
- The freedom to improve the program, and release your improvements to the public, so that the whole community benefits (freedom 3). Access to the source code is a precondition for this.
But hold on, to actually 'get' what we're talking about here, I need to introduce a couple of concepts behind programming (please bear with me if you know what source code is, we'll return in a second). Don't worry, they're not hard to understand and I promise I won't drown you in technical language. Continue after the jump...
Generally, to build a software program, you write the software in a programming language. Sure, you have to be geeky to understand it, but it means you don't have to literally sit there writing ones and zeros to write your program. The program written in the programming language is called the program's source code.
Usually we don't run source code on the computer, though. That would be slow, as the computer would have to constantly spend time interpreting our geek-readable instructions. Instead, we put the source code through a stage called compiling. Compiling the source turns the program into a binary - i.e. the ones and zeros that the computer natively understands. Our program now runs really fast - as the computer doesn't have to interpret our instructions constantly.
Humans can't easily read and understand this binary version (only with extreme difficulty).
And this brings us to back to FOSS.
With proprietary software (i.e. anything that isn't FOSS - Microsoft Windows, for example), you generally pay for the software then receive the binary version. This means that you can run the software (the computer understands the binary, you see), but you can't look at the source code, or make improvements. In general, the source code of a proprietary program is a 'trade secret'.
In contrast, with FOSS, you get the binary version so that you can run the software, but you also get the source code. That means you can take a nose at how the program works, or modify it, and you know exactly what that software is doing.
Still don't get it? Try this analogy.
Using proprietary software is like eating food where you don't have the ingredients. It might taste good, but for all you know, there could be anything in that food, because you don't have access to the ingredients. You can only get your good cooked by one company, as only they have the ingredients and have the super secret formula.
With FOSS, however, the ingredients are readily available to everyone. Not only that, but you get the recipe and the exact gas mark you need to cook it on to make it really tasty.
Because you've got the recipe, you are free to improve on it - maybe add some more ingredients, remove those that you don't like and then cook it again to make your own, tastier version.
The only condition is, you have to give the ingredients and recipe back to everyone else so that they are free to do the same.
Well, actually, there are a couple more conditions. Basically, everyone is free to sell, or give away, or do whatever with their cooked version, provided they allow anyone to see the recipe for free.
In the real world, the recipe is the source code, and the cooked, ready-to-eat version is a compiled binary version (sometimes also an executable version). The process of cooking is the process of compiling - turning source code into a compiled binary.
And that's, basically, how it works.
There are a number of free software and open source licences that software developers use when they want to make their software FOSS. Some of the more popular ones are:
- GNU General Public Licence (GPL)
- BSD Licence
- GNU Lesser General Public Licence (LGPL)
- GNU Lesser General Public Licence (LGPL)
I won't get into a lengthy discussion about the pros and cons of each licence now - maybe we'll leave that and a look at a few more licences another day.
One of the first few people to really push the idea of FOSS was Richard Stallman. He founded the GNU project, which was a project to build an operating system which was 100% free software. If you're using a Linux-based OS right now, then many of the GNU tools will be running inside your system (in fact, that could bring us to the GNU/Linux naming argument, but I think we'll save that for another day too).
Nowadays, though, there's a lot more FOSS projects which aren't part of the GNU project. For example, the Firefox web browser is one of the most well-known FOSS projects, and there are also other things like the WordPress blogging software (powering FOSSwire as you read this!)
And that about sums up this quick intro into what FOSS is - be sure to subscribe (feed / email / IM) so you don't miss the upcoming tutorials
