Airbag is a new cross-platform crash-reporting tool intended to have the same functionality as Talkback, which the Mozilla project currently uses. At the initial launch, they were planning to use the Apache License 2.0 but, after discussions with the Mozilla Foundation, I’m pleased to say they are now using a BSD-like licence which is compatible with all three Mozilla licenses.
A replacement for talkback has long been on my list of things to make happen. It never made it to the top, so I’m very glad that someone is taking up the banner. Kudos to Google, Mark Mentovai and friends. This could really make a massive difference to the quality of free software.
I’ve always been wondering why you don’t use bug-buddy on unix/gnome systems ?
Two reasons why we wouldn’t want to use bug buddy:
1) We really want to distinguish aggregate crash data and bug reports. Bug buddy doesn’t. We want a lot more reports than we’d want in our bugzilla.
(That said, I think we should really make it clearer to users of talkback/airbag that they’re not filing a bug report, and that if they have clear steps to reproduce and are willing to search for duplicates, they should file one.)
2) Bug buddy depends on debugging symbols on the client, which we don’t ship; talkback and airbag use debugging symbols on the server.
I don’t know why this is a good thing … i recommend you to read http://www.dwheeler.com/blog/2006/09/01/#gpl-bsd
> I don’t know why this is a good thing
Because it provides more people with more freedom to use the software in more contexts.
I’ve heard all the arguments for the GPL, and I still say it provides less freedom than a BSD-like license.
Now, that’s the authors’ right. Under copyright law, if the authors want to provide others with less freedom (or even *no* freedom) to use their work, they can do that. So if the authors of GPL software want to say, “We don’t want anyone to be able to use our code _unless_ they’re willing to abide by these terms”, they’re allowed to do that. The BSD license also does that, but it has fewer and easier terms to abide by. Proprietary source licenses (e.g., Microsoft’s Shared Source initiative) do the same thing, but they have rather *more* terms to abide by. (Proprietary binary-only licenses are another matter; freedoms provided by the license are pretty well moot if you don’t even get to see the source.)
So there’s nothing per se inherently wrong with providing fewer freedoms. You’re allowed to do that, and there are cases in which you would want to do that. For instance, this isn’t a source code example, but if I write Bible School materials for my church, and I want to let other churches use them, I might want to limit what kinds of changes can be redistributed, because I might not want liberal groups to remove all the Biblical content I worked so hard to include and then redistribute their theologically castrated versions to the world. So I might write a license that allows them to make whatever changes they want for their own use in their local church but only allow redistribution of copies with no substantial modifications to the text of the lessons, or modified versions with the author’s approval. I’m sure there are examples where you’d want to limit how your source code can be used, too.
But providing more freedoms allows the software to be used in ways that otherwise might not be possible, so if you’re willing to do that, it can provide more value to the world, at least in certain situations.
The best example I like to use is the example of a code library that serves as a reference implementation for a file format or protocol. If you want your file format or protocol to be as widely used as possible, then you want as many systems (or applications) as possible to implement it. So you put your code library in the public domain or at least under a BSD-like license, so that everyone can use it. SVG would be a good example of this: a good quality BSD-licensed SVG renderer would go a long way toward encouraging adoption of the format, which would be good for web content creators everywhere, because we’re all really tired of trying to included fixed-pixel-sized images in layouts that have to scale to all sizes.
For an application, e.g., a web browser (or, perhaps more relevant to this discussion, a tracking system like Bugzilla), the considerations are less one-sided; there is less need for other applications to include the code, so a license that gives out fewer freedoms can still work. Bugzilla is free enough for anybody to use, including a proprietary software house, and it would be even if it were licensed exclusively under the GPL. So the freedoms given by the GPL are adequate for that case.
A crash-feedback mechanism is somewhere in between, I think. There’s little “network effect” to be gained from having lots of applications use it, so even if only a few apps use it it would still provide real value to those applications. Nonetheless, putting it under a BSD-like license does allow more applications to use it, so if that is a desired result, it can be beneficial.
> examples where you’d want to limit how your source code can be used
I just thought of a good one. The njudge software, which is an adjudicator for play-by-email Diplomacy, is licensed under a no-commercial-use license, and has to be so for good reasons, having to do with an informal agreement between the hobby community and the company that owns the rights to the board game.
It’s pointless to argue about which has “more” or “less” freedom, because that is not the point at issue; the point at issue is what your definition of freedom is.
If your definition of freedom is “anyone can do anything they like at all with the code, including taking it proprietary and not sharing their changes”, then a BSD-like licence is the most free.
If your definition of freedom is “there are a certain set of freedoms which everyone should have, and no-one can take them away”, then a copyleft licence like the GPL is the most free.
So people who hold the two different definitions of freedom can shout at each other “no, my licence is most free” and both be right – in their own terms.
In a situation like this, what that really amounts to is that fewer projects are free to use the code at all. It does not in practice mean more freedom, at least not usually, because what those projects will actually do, generally, is just use (or create) a different solution, perhaps one that’s not as good. I’m sure there have been a handful of cases where people have opened up and shared because of the GPL, but it’s not the usual outcome unless they were inclined to do so anyway. If Airbag had been released under the GPL, would Mozilla.org have adopted it and relicensed all their code under the GPL? (If they did, I hope the community would have the good sense to fork the codebase and proceed from the last tri-licensed release. I’m not a big fan of forks, but in some cases they are warranted, and adding license restrictions is one such situation.)
The GPL has been successful not because of freedoms it provides (although it does provide certain important ones), but because of *assurances* it provides the authors (programmers), assurances that their work will not be used in certain ways they don’t approve.
It is also arguable that the GPL got a big popularity boost *because* it was used for Linux. (By “Linux” I mean Linux proper, i.e., the kernel.) Linux was in the right place at the right time (right when BSD was encumbered with a lawsuit, the outcome of which would have been difficult to predict) and so gained a critical mass of contributors that drove it to success. Although the GPL may also have contributed to the number of people willing to contribute, I am not convinced that it was the only factor as some have painted it, or even necessarily the most important factor. (Yes, the popularity of the GPL was also partly due to the success of certain parts of the Gnu toolset, most especially gcc and Emacs, and of course because RMS is so well respected for his contributions. These days, of course, the GPL is practically an institution.)
Bear in mind that I have nowhere said that the GPL is bad, nor that it is per se worse than a BSD-like license. (Indeed, it is my position that no single license is right for all projects.) It does, however, undeniably contain more restrictions than the BSD license and therefore provide fewer — enumerably fewer — freedoms to the recipient.
But you haven’t actually engaged with my point; you are just shouting louder that your definition of freedom (which is the freedom of anyone to do anything they like with the code) is the only valid one.
If I receive BSD-licensed code in binary form only, I receive very few freedoms indeed.
Anyone assuming GPL is bad is mistaken although GPL did get a popularity boost for using Linux
I am not convinced that it was the only factor as some have painted it, or even necessarily the most important factor. (Yes, the popularity of the GPL was also partly due to the success of certain parts of the Gnu toolset
If you want your file format or protocol to be as widely used as possible, then you want as many systems (or applications) as possible to implement it.
If airbags had been released under the GPL, would Mozilla.org have adopted it and relicensed all their code under the GPL