In 2006 I had just gotten into college and was learning Python by myself, my English skills (also self-taught) were pretty low and I had to rely a lot on whatever material was available in Portuguese (I'm from Brazil).
In 2007 I had an amazing college teacher, the "drop of water in the desert" kind of teacher. He was trying to convince everyone that they could move from MS Windows to GNU/Linux and that the available desktop software was pretty decent.
The only catch is that he used KDE2 and all the "cool" desktop apps he was showing were built on QT, like a good pupil I always tried to pair up an equivalent GTK option to every QT app my teacher showed to the class.
That worked well for everything: Music Players, Photo Viewers, etc.
But then I did not have a good alternative for GTK if I wanted to press F12 to get a drop-down terminal I'd have to install libqt on my Debian?
No way!
I set out to write an equivalent of Yakuake for GTK+ (hence the name Guake, with "G" for GTK), at the time I did not know exactly how D-Bus worked and had no idea of how to write Python extensions in C.
The very first working version of Guake was a Gnome Applet that used GTK bindings to libvte to make a terminal always available.
Was still not good enough for me.
The next step was to write a regular GTK Window application and try to make it disappear, but I was having a lot of trouble binding F12 globally, it only worked well on Metacity which was the default window manager for GNOME2 at the time.
Guake's user experience was not great, it only worked well on Metacity but was good enough for me to show to my teacher, I was so excited I was able to create my very first GPL software and publish on source forge. I was ahead of everyone in my class at the time, I was learning on my own the things that would be taught only in the next semester and many things that we would never learn in class (such as Python programming).
Some months go by and Guake-Gnome-VTE (the original name) gets some visibility, and this guy Lincoln de Sousa reaches out to me, he told me he had fixed the global keybinding problem by writing a Python extension in C, also he refactored the whole code and even applied GNOME Human Interface Guidelines to it.
It sounded great to me, I was so excited that someone else was interested in Guake, and made improvements to it, I was in awe with open source.
Except for one thing: Lincoln rewrote a lot of things that were working, just for the sake of cleaning up the Python code the aesthetics of it (actually he was applying PEP8 which I had no idea what was before this)
I had these mixed feelings: in one Guake had become what I wanted it to be, the global keybinding worked anywhere, the UI looked even better and the code was a lot easier to understand.
On the other a lot of the code I had written was deleted, I was not a skilled python developer when I wrote the first version of Guake, so I had spent several hours reading, coding and trying things out.
Anyways, the whole thing was a win-win, yay open source, now Guake had 2 maintainers putting a lot of time and love into it.
After some time Lincoln proposed that we moved the code off of Sourceforge to a git repository, self-hosted (we had a very "purist" mentality regarding FOSS and were terrified of having our code hosted by a proprietary software such as Github), he had way more experience than me on pretty much everything and he took reins: the code was hosted in one of his servers and all I did was pay for the domain.
In retrospect, I wish I had just pushed the code to Github at the time, so no the commit history would be lost.
The irony in having a purist FOSS mentality: the code was hosted on a server that I eventually lost access to.
Also, instead of importing all the commit history from Sourceforge we just pushed the code to git.
You can look at the first commits on github:
commit 4f4ab35d5cb2363dd464e6b252d1c798bd01c2fb
Author: Lincoln de Sousa <lincoln@minaslivre.org>
Date: Sat Oct 6 13:56:50 2007 -0300
The "guake_root" commit swallowed all the history of the original code I had done.
In 2008 I moved out of my city to work for a big corporation in Rio de Janeiro, there my FOSS purism slowly evolved into tolerance for proprietary software, eventually, I even got an iPhone and a MacBook.
That's when I stopped contributing to Guake: I had moved to MacOSX and the project had been taken over by other maintainers.
But even the icon is still the one I design on Inkscape, Guake was my first open-source software, I put a lot of time and love into it.
Today 14 years later I seldom use Guake because I seldom use a Linux Desktop, but I must confess that seeing my original authorship vanish from the project is very sad.
Hi. I am Gaetan, the current maintainer of Guake ! I am so sorry to see you find your "authorship" having disappeared from the Guake history, there was no intent from my part to remove it ! I only discussed with the maintainer back in 2013 from Pierre Yves, there has been many maintainers over the years I do not even know !
This history would have indeed a very place in the HISTORY page in the documentation, do not hesitate to write it, or with your permission, I copy/paste most of your comment.
Do not hesite to reach me in order to find a good way to put satisfying credits in the history.
Hello Gaetan, thank you so much for adding the authorship back.
Please don't get me wrong, I know you're not responsible for it disappearing and I'm not looking to blame anyone.
I'm happy that Guake is still being active maintained.
cool ! If only we could take a beer together ! But, at least, I hope, this will end up in a nice story and blog posts about opensource software development. We are all humans, mistakes can be made. The project lived a lot actually, and many files has been changed, the "chain" of maintainers made some of them not knowing the others !
If you still have the SVN repo, there should be a way to actually import all the commits to a Git repo (git-svn). Then, you could rebase the entire master branch of the current GitHub repo. That might show more of your contributions if many of them are hidden by the "guake_root" commit.
I only have a working knowledge of git but wouldn't that be equivalent to re-writing the whole history of the repo? Rebasing would give all of the commits a new commit ID and would cause conflicts everywhere.
Unless of course you just meant as an interesting way of being able to see the full history rather than suggesting the project adopt it.
Personally I'm impressed that you remember details of the development after this time. I usually suppress the memories of all the frustration in a few months with the help of unhinged hedonism and nonstop entertainment.
I'm Max @ulidtko, I took over Guake maintenance from Lincoln, did a dozen patches, l10n merges and maybe one release... Together with Pierre we welcomed Gaetan years later.
I'm still using Guake pretty much every day.
It was amazing to contribute, and having burned out from it -- to see the project live on with people continuing contributions & maintenance; and even reaping BountySource rewards for new features!
https://github.com/Guake/guake/pull/1415
Really sorry for this situation. It somehow slipped through, I honestly didn't notice it happening. I don't think anyone wished you anything bad, it's just generic inexperience (per the Hanlon's razor).
I, too, remember myself fiddling with copyright lines in translation files. I just had the single goal, to iron out inconsistencies and make adding new l10n's as smooth as possible. Never had intentions to take away credit from noone.
Glad to see you living full life. Sorry again; I'd be among those whose should've noticed and reverted that change. Hope you got a good enough resolution of this issue!
Gabe! Good for you, hope this works out for you. Had fun working with you in Miami Beach years back :D I can personally attest to @gfalcao's competency here ^^
> Except for one thing: Lincoln rewrote a lot of things that were working, just for the sake of cleaning up the Python code the aesthetics of it (actually he was applying PEP8 which I had no idea what was before this)
People shouldn't do this. At least not without prior agreement from the original author.
The issue I might still have today in 2020 is disk space, and extra time downloading updates to those packages at the next update. Even today I'd be reluctant to want to pull in large libraries that amount to an entire UI or desktop framework just for one application, unless I have a really good justification to use that application.
I am also a tad displeased today at how many optional dependencies I don't use get pulled in by package managers on my systems.
At the time it was a big deal, you went all GTK or all KDE/QT and your desktop looked ugly if you didn't. Also everyone was obsessed with 'bloat' and KDE had that rep.
As another kid who got into Linux at the time, KDE and Qt had a reputation at the time for poor performance on low-cost hardware.
To give you an idea, my computer at the time was a used machine that was duct taped together and any fancy desktop would cut my battery life to about an hour. So out of necessity I was driven towards lighter weight software
Interestingly (to me at least), I was just reading he memcached website (from another HN submission), and even though it's been completely rewritten in a different language, they still credit Brad Fitzpatrick as the original author.
No reason not to. Anyone arguing otherwise is being petty and mean in my opinion. Sure, a bunch of new people have written some/most/all of the current codebase. But they built on top of the project founder's code. Why _wouldn't_ you give them the credit for that?
In this specific case there seems to be no argument that the original author is who he says he is and he has given specific reasons why it would be in his advantage to be credited as the original author I can't imagine many people denying him that.
Ship of Theseus is a great argument for crediting the original author, even if it's been 100% re-written over time: The ship would have started from one (or more) expert ship builders, while the continual patching could be done by comparatively-unskilled hands.
(Not that this is the case in software, but merely saying that that parable would lend itself to an easy answer as to whether to credit the original or not.)
Thanks for the link. I hadn’t ever heard of the Ship of Theseus – though I’ve referred to Trigger’s Broom from Only Fools and Horses when discussing this concept with others: the character worked as a street-sweeper and claimed to have had the same broom for the past 20 years (however, he had changed both the handle and the head multiple times during this time).
Yeh I agree with this. Licensing and possible legalities aside, I think it’s just the right thing to do.
The issue seems to be getting a bit of attention now (when I posted there was 9 thumbs up, now there is 173 and a PR on the readme), so hopefully the current maintainers (re)visit the issue and give him his slice of credit.
I actually not seen the issue opened 2 months ago :( I do not have many times on it and I read around half of tickets people opens, sadly this one did not :(
My recollection is that the original prototype was written in Perl, but the oldest commit on github[1] is in C, which is still the language it uses today. The original C version had big contributions from someone other than Brad starting from the third commit (search the git commit log for 'avva'). Definitely still Brad's baby though.
(Disclaimer: I was an early, minor, contributor. It looks like the second commit mentioning me was to fix a bug introduced by my first one, whoops.)
One reason I can think of: Egos. "Why should this guy get credit after having left the project years ago while I still work full-time on it and all I get is an entry in a generated contributors file? No fair!"
I mean the OP (Gabriel) hints at wanting to use it in his CV (proverbially); wouldn't anyone that made a significant contribution? Then of course, how would you define significant?
It's a can of worms and one of the ways around it is to reduce all contributors to "you are not special" status.
To be fair though, that's kind of life. The originators of any given thing always get remembered as the originators, despite how long they worked on it compared to anyone else since. This isn't just code. I mean, 30 years from now, George Lucas will still be remembered as the creator of Star Wars, even though by then I'm sure the writers at Disney will have produced 20x more stories around it, and Stan Lee/Jack Kirby will still be remembered as the creators of the characters others have already built upon and adapted since then. Even the USA has had far more people build and mold the country into what it is since the founding fathers. It's just one of the hallmarks of our society I think to romanticize and glorify the original creators of works.
I think reducing everyone to "you are not special" status is a pretty weak solution that probably wrongs more people than it rights. And I think egos are a pretty weak reason to do it.
Assuming the license hasn't changed, under GPL it was illegal for them to remove the license. Apparently it's still in the "about" window, so maybe that is sufficient for the license, but I'm not sure about removing copyright banners in a bunch of other places...
They seem to have had an AUTHORS file in there that according to git blame was deleted in this commit 2 years ago, possibly by erroneously including AUTHORS in .gitinclude:
I'm not really sure how to find the diff that switched from explicit copyright headers in source files to "Guake authors", maybe that was just done as the default while the code was growing.
Couldn't really hurt to just include some attribution imho, not only for him but other contributors as well. It's kind of odd looking to me that one of the two original authors raised an issue on an active looking project and seemingly nobody even bothered to respond there.
> I'm not really sure how to find the diff that switched from explicit copyright headers in source files to "Guake authors", maybe that was just done as the default while the code was growing.
The git commit you linked would have required the committer to explicitly remove the `AUTHORS` file from the code-base. If a file is already being tracked, it won’t stop being tracked if a corresponding pattern is added to `.gitignore`. Removing the file in this way was most likely intentional and not erroneous.
If anybody reads this and decides it sounds like a nice way to summon a terminal, be aware that if you're a non-Gnome user you can use Yukuake in KDE, and the --drop-down option to the XFCE terminal.
I usually have it bound to Ctrl-` and find it very convenient (also someone satisfying to just show and hide for no reason other than I like the animation).
Well, as far as I can tell, the Authors file was removed completely. In all of the files that I could find that are old enough for him to have contributed to, his copyright notice remains.
In his own branch, the first commit is October 2007 and the vast majority of commits after that are from Lincoln de Sousa. So I don't think anyone was doing anything untoward here. I'm not really familiar with the project, but it doesn't appear to me that he was ever the original author. If anything, it appears as though Lincoln de Sousa did most of the heavy lifting and he was a regular contributor. I could easily be wrong, but that's my impression.
Still, acknowledgement as being an original contributor in the README seems completely reasonable and the issue has 14 thumbs up.
The first commit on github is a 77k lines commit that appears to be a migration of the project from svn to git. So you're looking only at later commit history.
Agreed; it was quite interesting. I only posted my above comment because calling this thread to the attention of hackernews seemed a bit like trying to stir up controversy.
As far as I know, attribution rights are unalienable at least in my jurisdiction. What that means in practice in larger software projects is unclear, but removing attribution for some people while keeping it for others would be against the spirit of the law.
There were no indent in removing or altering the history. Just a project that evolves over time, files are renamed, splitted, etc, and the list of copyright at the beginning of the file is no more relevant.
The real truth is inside the git history, sadly part of this truth has been lost by the origian import, and even myself, the current maintainer, does not know it !
It's pretty clearcut: The GPL requires to keep copyright notices and author's names. They should re-add him and removing names from free software code without the consent of the original author is absolutely not okay.
We may argue that with licenses that allow this (CC0, Unlicense) it would be okay, but even there I'd say credit where credit is due.
I wonder how active the Guake maintainers really are. If you use it on Wayland, you get an error that it can't claim f12 as a key binding. This is because they use some X11 foo for their keybinding. It's easy to set a custom keybinding via Gnome which will allow you to use Guake, however, they have been ignoring requests to just allow Guake to have no binding (as far as it is aware) for some time now. A short time ago they started enforcing a keybinding, strangely. [0]
Most FOSS licenses don't require attribution (although ethically it's better to do so), however, almost all requires the preservation of copyright notices, and the name of the author is always part of the notice. For example,
> Copyright (C) $years $author
> Permission is hereby granted, free of charge, to any person [...] subject to the following conditions:
> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
And usually, the copyright notices appear in the beginning of all files for clarity.
Although some projects with too many developers may agree to use alternative attribution and copyright identification methods, such as git "Sign-Off", an author file, or SPDX machine-readable license notice. In these cases, it's considered a common practice to use a collective name in the copyright notice, such as
> // Copyright 2019 The Chromium Authors. All rights reserved.
But in most cases, it's a bad idea to remove any name from the header.
---
In the Guake's case, the copyright notice is changed to,
> Copyright (C) 2007-2013 Guake authors
with the original name removed. On one hand, the use of a collective name is common, it's not too different from Chromium, or other major projects. In a sense, it's acceptable, as long as the method of author identification is clearly defined (e.g. git sign-off). Anyone contributes the project is assumed to have accepted how attribution is done implicitly.
However, the problem is that the original name is removed - changing the notice retroactively should be done with the permission of the author, which is clearly not obtained here. A common practice in such circumstance is leaving the original copyright year and author in place, and appending new copyright information below (or above) the original notice, so it should be something like this,
> Copyright (C) 2007 Gabriel Falcão
> Copyright (C) 2008-2013 Guake authors
This example is generally considered "good" since (1) credit is given where credit is due, (2) it also shows the copyright holders responsible for the project in different period of time.
That's the usual way of doing it. When a project grows and gains more contributions you can have the AUTHORS file have a list of former major contributors and project founders, current major contributors, and a note acknowledging the dozens of occasional and drive-by contributors (who get full credit for their patches in the revision logs).
Let me clarify the whole story:
In 2006 I had just gotten into college and was learning Python by myself, my English skills (also self-taught) were pretty low and I had to rely a lot on whatever material was available in Portuguese (I'm from Brazil).
In 2007 I had an amazing college teacher, the "drop of water in the desert" kind of teacher. He was trying to convince everyone that they could move from MS Windows to GNU/Linux and that the available desktop software was pretty decent.
The only catch is that he used KDE2 and all the "cool" desktop apps he was showing were built on QT, like a good pupil I always tried to pair up an equivalent GTK option to every QT app my teacher showed to the class.
That worked well for everything: Music Players, Photo Viewers, etc.
One day he showed Yakuake (https://kde.org/applications/system/org.kde.yakuake) to the class and everyone went bananas, this was such an amazing tool.
But then I did not have a good alternative for GTK if I wanted to press F12 to get a drop-down terminal I'd have to install libqt on my Debian? No way!
I set out to write an equivalent of Yakuake for GTK+ (hence the name Guake, with "G" for GTK), at the time I did not know exactly how D-Bus worked and had no idea of how to write Python extensions in C.
The very first working version of Guake was a Gnome Applet that used GTK bindings to libvte to make a terminal always available. Was still not good enough for me.
The next step was to write a regular GTK Window application and try to make it disappear, but I was having a lot of trouble binding F12 globally, it only worked well on Metacity which was the default window manager for GNOME2 at the time.
Guake's user experience was not great, it only worked well on Metacity but was good enough for me to show to my teacher, I was so excited I was able to create my very first GPL software and publish on source forge. I was ahead of everyone in my class at the time, I was learning on my own the things that would be taught only in the next semester and many things that we would never learn in class (such as Python programming).
Some months go by and Guake-Gnome-VTE (the original name) gets some visibility, and this guy Lincoln de Sousa reaches out to me, he told me he had fixed the global keybinding problem by writing a Python extension in C, also he refactored the whole code and even applied GNOME Human Interface Guidelines to it.
It sounded great to me, I was so excited that someone else was interested in Guake, and made improvements to it, I was in awe with open source.
Except for one thing: Lincoln rewrote a lot of things that were working, just for the sake of cleaning up the Python code the aesthetics of it (actually he was applying PEP8 which I had no idea what was before this)
I had these mixed feelings: in one Guake had become what I wanted it to be, the global keybinding worked anywhere, the UI looked even better and the code was a lot easier to understand.
On the other a lot of the code I had written was deleted, I was not a skilled python developer when I wrote the first version of Guake, so I had spent several hours reading, coding and trying things out.
Anyways, the whole thing was a win-win, yay open source, now Guake had 2 maintainers putting a lot of time and love into it.
After some time Lincoln proposed that we moved the code off of Sourceforge to a git repository, self-hosted (we had a very "purist" mentality regarding FOSS and were terrified of having our code hosted by a proprietary software such as Github), he had way more experience than me on pretty much everything and he took reins: the code was hosted in one of his servers and all I did was pay for the domain.
In retrospect, I wish I had just pushed the code to Github at the time, so no the commit history would be lost. The irony in having a purist FOSS mentality: the code was hosted on a server that I eventually lost access to.
Also, instead of importing all the commit history from Sourceforge we just pushed the code to git.
You can look at the first commits on github:
commit 4f4ab35d5cb2363dd464e6b252d1c798bd01c2fb Author: Lincoln de Sousa <lincoln@minaslivre.org> Date: Sat Oct 6 13:56:50 2007 -0300
commit 8973af85108c889f7dc16af2d8443d0f8ff3ec05 Author: guake_root <guake_root> Date: Wed Aug 1 02:35:20 2007 +0000The "guake_root" commit swallowed all the history of the original code I had done.
In 2008 I moved out of my city to work for a big corporation in Rio de Janeiro, there my FOSS purism slowly evolved into tolerance for proprietary software, eventually, I even got an iPhone and a MacBook.
That's when I stopped contributing to Guake: I had moved to MacOSX and the project had been taken over by other maintainers. But even the icon is still the one I design on Inkscape, Guake was my first open-source software, I put a lot of time and love into it.
Today 14 years later I seldom use Guake because I seldom use a Linux Desktop, but I must confess that seeing my original authorship vanish from the project is very sad.