
Please re-add original author to docs and license - selexin
https://github.com/Guake/guake/issues/1703
======
gfalcao
Hello, I'm Gabriel, the original author of Guake.

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](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

    
    
        patch came from svn
    

commit 8973af85108c889f7dc16af2d8443d0f8ff3ec05 Author: guake_root
<guake_root> Date: Wed Aug 1 02:35:20 2007 +0000

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.

~~~
chrisseaton
> I'd have to install libqt on my Debian? No way!

Why are you so firmly opposed to libqt?

~~~
asveikau
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.

------
bigiain
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?

~~~
VBprogrammer
This strikes me as a very old question.

[https://en.wikipedia.org/wiki/Ship_of_Theseus](https://en.wikipedia.org/wiki/Ship_of_Theseus)

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.

~~~
SamBam
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.)

~~~
VBprogrammer
You could equally argue that Gail's law is applicable. Without someone
creating something simple but working it may never have existed.

~~~
benji-york
I suspect you mean "Gall's Law" (see
[https://en.wikipedia.org/wiki/John_Gall_(author)#Gall's_law](https://en.wikipedia.org/wiki/John_Gall_\(author\)#Gall's_law)).

------
Aachen
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...

~~~
tastroder
The license file does not seem changed
[https://github.com/Guake/guake/blob/master/COPYING](https://github.com/Guake/guake/blob/master/COPYING)
but it did not contain his copyright notice in the first place.

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:

[https://github.com/Guake/guake/commit/089d72aab3c1708ed3476e...](https://github.com/Guake/guake/commit/089d72aab3c1708ed3476e42fad7659d8b25fdb7)

Before that he was included in the AUTHORS file as "\- Gabriel Falcão
<gabriel@guake-terminal.org>, 2007", his name still appears in a bunch of
places in the code
[https://github.com/Guake/guake/search?q=Gabriel+Falc%C3%A3o&...](https://github.com/Guake/guake/search?q=Gabriel+Falc%C3%A3o&unscoped_q=Gabriel+Falc%C3%A3o)

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.

~~~
Anthony-G
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.

~~~
Anthony-G
From the most recent response to this issue, it seems that the file was
removed with the intention that the list of authors could be programmatically
generated:
[https://github.com/Guake/guake/issues/1703#issuecomment-5965...](https://github.com/Guake/guake/issues/1703#issuecomment-596500947)

I also see that Gabriel has now been credited in the project’s `README.rst`.

------
thom
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).

~~~
gfalcao
Yakuake is what inspired Guake. I wanted to use Yakuake without needing to
install libqt in my machine.

~~~
singlow
Maybe, but the original inspiration was the tilde shortcut for opening the
console in the Quake game, hence the names.

~~~
jawr
I think he knows why it’s called that :)

~~~
singlow
Ha - first time I read it I didn't pick up that he was the author :P

------
mikekchar
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.

~~~
chmod775
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.

The original project lived here: [https://sourceforge.net/p/guake-gnome-
vte/code/commit_browse...](https://sourceforge.net/p/guake-gnome-
vte/code/commit_browser)

He explained that and linked to that in his his issue though.

Edit: Linking to the full commit history instead.

~~~
mikekchar
My bad! Indeed, he does seem to be the original Author. Thanks for pointing me
to the correct spot! I'm not sure how I missed that.

------
sequoia
This seems like a non-story. Original author says "please add my name back,"
current maintainers say "OK will do." What am I missing?

~~~
scarejunba
Well, I got that little piece of history from the Gabriel Falcao about how it
was all formed which is really neat so that makes it worthwhile.

I think we usually expect these to be someone's cry for help but here it's
just an interesting tale. I liked it.

EDIT: Responding here due to rate-limit, I think you're right (on reflection)
and I don't like what that means.

~~~
sequoia
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.

------
jkh1
Credit should always be given where credit is due. I believe this is good
etiquette. This might also be required by the original license.

~~~
anilakar
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.

~~~
gsemet
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 !

------
selexin
Was browsing the Guake issue list for another reason and came across this. I'm
genuinely interested to hear what people think of this situation..

~~~
hannob
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.

------
teekert
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]

[0]
[https://github.com/Guake/guake/issues/1591](https://github.com/Guake/guake/issues/1591)

------
segfaultbuserr
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.

For example, the copyright notice of Python is,

> Copyright (c) 2001-2019 Python Software Foundation.

> All Rights Reserved.

> Copyright (c) 2000 BeOpen.com.

> All Rights Reserved.

> Copyright (c) 1995-2001 Corporation for National Research Initiatives.

> All Rights Reserved.

> Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.

> All Rights Reserved.

~~~
bluesign
I think the situation here is accidental removal of AUTHORS file only. (With
accidental .gitignore config)

I think legally, (also ethically)

Copyright (C) 2007-2013 Guake authors

Should be fine as long as they keep his name in authors file.

Edit: Actually they switched to pbr [1] , so AUTHORS file is generated on
build. Not tracked on git. Original author is in AUTHORS file

[1]
[https://github.com/Guake/guake/issues/1703#issuecomment-5965...](https://github.com/Guake/guake/issues/1703#issuecomment-596500947)

------
chrisan
Looks like they wanted to auto generate instead of maintain by hand the
AUTHORS file.

------
mixmastamyk
Interesting to see this here, I just started using guake a few weeks ago since
it supports hyperlinks in the terminal where mate-terminal does not.

------
jghjghjgh
On the other hand he hadn't commit anything in last decade and he would get
credit for others work

On the other hand he's an author...

mixed feelings, I'd say

Autor: {name} Contributed in years: 2007-2009.

~~~
Freak_NL
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).

His request is not unreasonable at all.

