1. 22

  2. 6

    It may be the late hour, but I’m having trouble synthesizing the information presented here. It seems that Giacomo contributed some code to Harvey, a Plan9 fork, but then forked Harvey at some point to create Jehanne. He stopped paying attention to Harvey at some point after focusing efforts on Jehanne. A friend pointed out that Harvey’s attributions no longer included his name. He verified this and then posted an issue about it. The Harvey folks said something along the lines of “no big deal” and after some discussion, the Harvey folks decided that it would be better to remove all of his contributions than to attribute them to him. He pointed out that their rework didn’t really remove his contributions but rather reimplemented them minorly. Then he posted a blog post about it.

    Does the Harvey team still have work to do if they want to actually mitigate a need to attribute to Giacomo?

    1. 12

      He laid it out cleanly in the end. Instead of respecting him and his contributions, they bitterly removed them. He feels the Free Software people respect contributors, while big corporate open source folks dont. I agree with his conclusion. It’s a cautionary tale.

      1. 8

        It’s a cautionary tale.

        Exactly. But note that it’s not just a matter of Free Software’s ethics.

        As I tried to explain them, if you use somebody else code without proper copyright statements, you pose a threat to their own right to use their code elsewhere.

        1. 1

          It sucks a lot but I think it’s something that we as contributors have to accept. Code changes. When our contributions are no longer present, there’s no longer a need to actively recognize those contributions. At least, that seems to be the terms of the license.

          1. 10

            except thats not what seems to have happened. They actively removed and reimplemented so the name isnt on the project. Thats some nasty stuff.

            1. 4

              They actively removed and reimplemented so the name isnt on the project. Thats some nasty stuff

              Umm, no, that’s not nasty. It happens, sometimes for good reasons: https://marc.info/?l=openbsd-cvs&m=99118918928072&w=2

              1. 3

                The point @stsp is not that they reimplemented my stuff. Surely they can!
                But their new implementation can be obtained by trivial, non recursive, modifications of my patches (that is: you can do that with notepad, you don’t even need for a regular expression).
                And, accidentally, their reimplementation work went mixed in few huge commits that were a squash of several commits from several authors.

                Now, I wont bore them anymore. But I really learned a lesson there.

                1. 1

                  And if the parts of your patches they kept could be obtained by trivial, non recursive, modifications of their original code, what then?

                  Your statement shows that you are applying the derivative work concept, but only where it favours your own cause.

                  1. 4

                    And if the parts of your patches they kept could be obtained by trivial, non recursive, modifications of their original code, what then?

                    If you think that my patches can be obtained by trivial, non recursive, modifications of their original code, you didn’t look at the code at all…

                    1. 1

                      This is about parts of patches, not the patches as a whole.

            2. 3

              I cannot agree @colindean: I didn’t complain for the code they removed or replaced.
              For example I ported zlib to Harvey and wrote a console filesystem in user space, and they properly removed them together with the copyright statements, here and here.
              I’m fine with this: it’s their project, they are many different people, they can always choose better approaches.

              What I cannot accept, is people using my code and patches (that I’m using elsewhere) without any attribution.
              SCO teaches that things can get hairy in the long term.
              And they are backed by Software Freedom Conservancy.

        2. 5

          My comment in another thread (sorry @Shamar, didn’t realize you had also submitted your blog post as a separate story): https://lobste.rs/s/yz7npb/gpl_enforcement_update#c_fdcggi

          1. 1

            Following up on the above: So @Shamar, my take would be that the test code you added in this commit is copyrightable, but s/uint32_t/uint64_t/ is not.

            And I would also hope that adding ‘const’ to function parameters does not make the result a derivative work. You could probably find a lawyer who would support this claim though, as long as that laywer doesn’t know C.

            1. 2

              You could probably find a lawyer who would support this claim though, as long as that laywer doesn’t know C.

              Well, the lawyer I consulted knows enough about these stuffs to suggest me to record the issue evolution in the WaybackMachine when I told him that they where using git rebase to remove me from the repository.

              He is pretty smart, actually. ;-)

              As for the const matter: are you sure you know the modifier’s semantic deeply enough? ;-)

              The modifier enables several optimizations (they can vary depending on the compiler).
              It was not supported by Ken-C.

              My patch enabled these optimizations not only for the functions you can find in the ISO C standard (that btw was not supported, in any way, by the Harvey’s libc), but also for others that were specific for Harvey, such as all the rune related ones.

              Now, I agree that my patch is the simplest possible way to enable such optimizations.
              But not the only one!

              If you barely know C, you know that there are several other ways to do the same. In a word: macros.
              But if they really wanted to support ISO C, they had several other alternatives to address the optimization problem without using a patch that conflicted with mine. They have an ISO C library in APEX after all!

              1. 2

                Whatever the semantics of const are in various implementations of C, this question boils down to whether your change is a copyrightable “derivative work” or not. I suspect you can only determine the legal answer in a long court case. Do you really wanna go there, after they’ve already removed all code that everyone already agrees consitutes a derivative work? I think you’re blowing this out of proportion.

                1. 1

                  No no no! As I said otherwhere, I wont bore them anymore.

                  According to my lawyer, my github fork (frozen before the rebase) and the archive on the WaybackMachine should be enough to defeat in court any pretension on my code.

                  The medium post is, as it has been defined by @mempko, just “a cautionary tale”.
                  For younger devs pondering to contribute to Open Source Software.

                  1. 3

                    I don’t think what you’re doing is encouraging younger devs to contribute to open source :(

                    1. 5

                      Indeed! I strongly suggest them to contribute to Free Software, instead!

                      1. 9

                        You had one problem with one project. Generalizing this experience to an entire class of communities doesn’t seem appropriate.

                        1. 2

                          Please, read more carefully.
                          I wrote:

                          Free Software feels proud of each person that contributes.
                          Whatever the license, a Free Software community will be very happy to add your name to their code base. Because you studied and changed the code.
                          You made it useful. You are a sign of honor.
                          They trust you. And respect you.

                          On the other hand, Open Source managers are eager to take your code.
                          But while your code becomes their asset, your copyright is a liability.

                          I’m not generalizing to “an entire class of communities”.

                          I’m saying that, whatever the license, you should not assume that you are working for a Free Software community that will trust and respect you.

                          And, that you should really know what you are doing before contributing to Open Source Software leaded by big firms, because there you will probably be just another minion to use.

              2. 1

                Ah.. yes… since you cited the scheduling issue, please try to get their change with s/uint32_t/uint64_t/! ;-)

                I don’t want to be a jerk, but as I wrote, I do not play poker. I try to back my statements with facts.

                1. 1

                  please try to get their change with s/uint32_t/uint64_t/! ;-)

                  Well, what other change in that diff do you mean? This one?

                  -uint32_t tk2ms(uint32_t);

                  +#define tk2ms(x) ((x)*(1000/HZ))

                  Are you convinced that change must carry your copyright?

                  I don’t mean to be confrontational, I’m just trying to help you find a perspective on the matter that doesn’t leave you in a bad mood.

                  1. 1

                    No, problem.

                    What I mean is: open one the file modified files in that commit, eg sys/src/9/amd64pv/devarch.c or sys/src/9/k10/dat.h, at the state before the change and try to use s/uint32_t/uint64_t/ all over it.

                    You will notice that you had just broken the system.

                    Finding the right type to change was not trivial.
                    And I had to do some iterations, testing manually that everything was working in kernel and user space.
                    That’s why I wrote the test you cited.

                    Do you really think that work does not constitute a derivative work? Are you sure it was a trivial change not deserving any authorship?

                    1. 0

                      Yes, so copyright your test. Doesn’t that solve the problem?