1. 2

    Can someone with a better understanding of copyright assignment explain what the implications of this are? What will it mean practically for companies, individuals and users?

    1. 4

      Before, in order to contribute to GCC you had to give the FSF copyright of your change. Now, you don’t.

      This will make it easier to contribute, since the process of assigning copyright to the FSF is (I believe) nontrivial, and just saying “I assign copyright of this patch to the FSF” doesn’t work. In particular, people who work for companies that claim ownership of their employees’ free-time contributions may be more likely to accept a patch if it doesn’t require signing over their copyright.

      The other change is that this means that relicensing GCC would be harder, since now there are multiple copyright holders to the work. But I don’t think that GCC will be relicensed any time soon.

      The FSF also says that copyright assigntment is important for enforcement reasons, since only the owner of a copyright can enforce it and it’s easier if the entire codebase has a single owner. But in practice… when was the last time you saw any GPL enforcement?

      1. 7

        companies that claim ownership of their employees’ free-time contributions

        The fact that this is even legal is mind boggling.

        1. 4

          You can claim anything you want!

          It’s anyone’s guess whether the claim would hold up in court, so it’s basically a game of chicken. You’re a lot more likely to flinch first vs a million-dollar software company.

          1. 1

            In CA, it’s explicitly illegal to claim ownership unless the free-time contribution relates to the employer’s business. But if you work for a megacorp, they very well might take the position of “our business is everything”.

            1. 2

              I guess my point is that even in California, it’s in the company’s best interest to lie and say that they own everything, because the penalties for making a false claim are lesser than the benefits of intimidating employees.

              1. 1

                Yeah. And worst comes to worst, they can always say “give us this or you’re fired”. I dunno if that’s legal, but I also don’t want to find out.

              2. 1

                So that is the sinister side of letting people work on their own stuff at the office.

                Nice!

                1. 2

                  Oh, this isn’t even at the office. If you work on stuff using company resources/on company time, everywhere in the US will just give that to your employer. This is about stuff you do on your own time at home!

                  1. 1

                    If it came to that I’d start writing incredibly offensive stuff and give them full credit.

                    1. 1

                      Well, then you’d get fired.

                      Though, based on a friend’s anecdote, at least one megacorp is definitely way more likely to sign a copyright release for things related to pornography, and will even require you to not mention their name in connection with it…

                      1. 1

                        glad I don’t care anymore. You can only keep someone threatened and scared for so long.

                        funny how they don’t want that attribution when its seemingly not coinvent. At the same time it’s just begging for ‘rm -rf /’ to be attributed to them under the guise of their legal department.

                        I guess doing something a little more involved than changing twitter icons is a bit much for people these days.

        2. 3

          The FSF requires copyright assignment for two reasons:

          • It lets them change the license at will. When LLVM switched from the UIUC license to Apache 2 + GPL exemption, it required a complex process to get permission from all copyright holders (actually, from almost all and then to rewrite the remaining bits).
          • It gives them standing to sue for copyright violation and to settle violations.

          The first is important if you believe that GCC may wish to move to GPLv4 (or AGPLv3 or whatever) in the future. That may be a concern, but it took 20 or so years for the FSF to release GPLv3, so it’s probably not urgent. Note that the FSF could also unilaterally release the current version of GCC under the MIT license or something equally permissive and some of the concerns from contributors over copyright assignment relate to that: If some company managed to lobby / bribe / stage a takeover of the board of the FSF, then they could release all of the FSF-owned code under a permissive license, against the express wishes of the authors.

          The second one is more interesting. Somewhat ironically, the FSF makes (made?) quite a lot of its money as a purveyor of proprietary software. If a company is caught violating the GPL on any GNU projects, the standard policy for the FSF is to send them a cease and desist letter that gives them a time limit to get into compliance and offers them a time-limited proprietary license for the software from their first violation date until the deadline. If they accept, then they pay the FSF for the license and are now not violating anyone’s copyright and so have no legal liability (as long as they become compliant by the deadline). Compare this with Linux: if you’re violating the GPL on Linux, there are hundreds of people and companies who have standing to sue you and no single entity that has the ability to give you immunity from prosecution if you stop. It’s not clear how much of a problem that is these days.

          In terms of corporate contributions, it is generally quite difficult to get approval to contribute to the assign copyright in a lot of companies. This means that the GPL + copyright assignment ends up being the opposite of what a lot of folks here want from a license: it makes it easy for big companies to use the code but hard for them to give back.

          For individuals, it means you don’t need to send a piece of paper international post to be able to contribute. The FSF never paid me the $1 for my copyright assignment, so I don’t regard it as valid since they didn’t act in good faith (you can’t assign copyright without some recompense in the US, so the copyright assignment form says that they will pay you $1 in exchange). I wonder how widespread that is….

          1. 1

            If some company managed to lobby / bribe / stage a takeover of the board of the FSF, then they could release all of the FSF-owned code under a permissive license, against the express wishes of the authors.

            This concern seems unlikely. The copyright assignment papers you sign for the FSF have some wording that says the one of the conditions of assigning copyright is that the FSF won’t do something like completely changing the license.

            But the most important element of the assignment contract is the promise we make to every contributor and community member: We promise to always keep the software free. This promise extends to any successors in the copyright, meaning that even if the FSF were to go away the freedom of all users to share in the contributions wouldn’t.

            https://www.fsf.org/bulletin/2014/spring/copyright-assignment-at-the-fsf

            Since a weak license like MIT could compromise the freedom of a software package, it seems like it could be in violation of this promise.

            The FSF never paid me the $1 for my copyright assignment,

            Nowadays the exchange is usually a sticker. You didn’t get a sticker?

            1. 1

              Since a weak license like MIT could compromise the freedom of a software package, it seems like it could be in violation of this promise.

              The MIT license is on the FSF list of approved Free-Software licenses, so I think they could justify an MIT-licensed release.

              Nowadays the exchange is usually a sticker. You didn’t get a sticker?

              Nope, nothing. This would have been around 2003ish.

            2. 1

              The first is important if you believe that GCC may wish to move to GPLv4 (or AGPLv3 or whatever) in the future.

              This is really strange; most other projects I’ve looked at from GNU already use a “GPL v$LATEST or (at your option) any later version”. Does GCC omit this? If so, they could add it immediately before accepting the first non-assigned contribution, since at that point it’s still within their power to relicense.

              1. 3

                I am not a lawyer, this is not legal advice:

                As I understand it, the ‘or later’ doesn’t allow you to change the license, it just means that you may choose to be bound by only the later conditions. Without copyright assignment, the FSF could have started accepting new code under GPLv3 or later, but would not have been able to release GCC 4.3 with every source file updated to GPLv3 or later. They possibly would not have been able to incorporate GPLv3-or-later patches into GPLv2-or-later files either, though I’m much less sure about that. GPLv2 and GPLv3 were incompatible and so the combination of GPLv2-or-later and GPLv3-or-later is GPLv3-or-later (if you accept GPLv3 for any portion, you cannot accept GPLv2 for any portion).

                Not having to think about this kind of thing except as an intellectual exercise is a big part of the reason that I avoid FSF licenses.

          1. 2

            I’m lucky in that my first contributions to open source were though my job. In particular my job is to port a large number of open source packages to a different platform. As a result I’m spending a lot of time learning new code bases so I can be affective in porting them. Different projects are definitely better or worse w.r.t. their internally facing documentation. Some (gcc for instance) have almost none. That being said there are some places to check:

            1. Check the git logs. Recently I worked on a port of GNU patch. In GNU patch they where keeping an LRU cache of calls to glibc’s openat. There was no explanation at all in the code for why an LRU cache was needed — but that narrative history did exist in the commit which originally created the LRU cache (notably not visible with git blame).
            2. Some projects (Perl for instance) have decent internal documentation which will actually tell a story to the developer about the code. Sometimes it is in a odd format. So check if that exists (inside or outside the code base).
            3. Since my job is mostly porting and not contributing I haven’t had occasion to actually do this; but my understanding is that talking to maintainers on irc and looking for a list of new contributors’s bugs to solve are good ways to get started.
            1. 5

              Go for a long walk. Figure out my taxes. Work on the exercises from logical foundations. Something I’d like to do: write a symbolic executor.

              1. 6

                What is the benefit of adding const to a function? Its surprising to see what feels like a relatively minor change make the release notes.

                1. 17

                  Adding ‘const’ to a rust function makes it possible to execute the function in a “const context”. Const contexts are those which are computed at compile time. A const variable’s initialization is one example of a const context. Having more things computed at compile time can have significant effects on the run time behavior of code, effectively eliminating the run time cost of producing such a value, which mattes a lot when that code may be in a tight loop.

                  The other thing to know is that the const feature was added to rust after much of the standard library was written. In fact the language is in the process of making more and more expressions have the ability to be const. There are even some typically heap allocated values which can be const evaluated. As those features get added the standard library is adding const to functions which can be made const.

                  So although I don’t write the release notes and I don’t know the person who does. My guess would be that they appear there because it’s a way of tracking const’s progress as an important language that has serious runtime benefits.

                  1. 1

                    Hm interesting, so it’s basically constexpr from C++?

                    I started using constexpr recently, and I noticed how it has progressed over C++11, 14, 17, 20. At first you could only use functions with a single return statement. Now they are adding certain STL algorithms, etc.

                    That is, making more and more language features valid in constexpr contexts until the STL itself can run at compile time. And probably recasting the STL itself in terms of newer features that can run in both contexts. (Memory allocation is an issue there too, but I don’t remember the exact mechanisms)

                    Sounds like Rust is undergoing a similar evolution?

                    1. 7

                      Const contexts are those which are computed at compile time.

                      I believe it more that they can be compiled at compile time, but whether they are or aren’t is up to the optimizer. But it allows the optimizer a lot more leeway in how things work; a const function is basically pure, so a lot more reduction can be done.

                      Hm interesting, so it’s basically constexpr from C++?

                      Pretty much exactly that, yes. Rust’s const is currently less powerful than constexpr, but it is kind of slowly creeping up on feature parity.

                      1. 2

                        I think const functions can also be used in types in ways that non const functions cannot. But I don’t remember all the details

                1. 5

                  I’m actually pretty surprised that there doesn’t seem to be a strong backlash against the idea. Perhaps it’s simply because of who the thread participants are? My impression, so far, has been that C programmers tend to be fairly anti-Rust, for one reason or another.

                  1. 9

                    I’m not a fan of Rust at all but it’s a more logical language to add support to the kernel for than many. Indeed I can’t think of a better candidate from currently popular languages. It has the same “compile to efficient code without a massive runtime or any garbage collection” emphasis as C, more so than C++.

                    1. 2

                      Arguably Zig has even more emphasis on “better C” rather than “better C++”, but it also has the same downsides (single main implementation tied to LLVM rather than being a standardized language with multiple independent implementations) while Rust has way more maturity and momentum.

                      1. 3

                        Usually technologies that are same-but-better have difficulty getting adopted, because an incremental benefit doesn’t seem worth a big switching cost.

                        Rust dodges this by being significantly different at the same time. It’s not just C with a borrow checker, but brings new programming style and new idioms into the systems programming niche.

                    2. 4

                      I assume it’s because despite whatever problems the language may have, it seems to be the only safe language that doesn’t require a whole supporting runtime

                      1. 2

                        There’s a great talk from Bryan Cantrill about the whys: https://youtu.be/HgtRAbE1nBM

                        1. 1

                          I have minimal experience in the realm of such low-level programming, but I am very interested in programming languages. As an outsider, I have heard many positive things about Rust, but perhaps my view of the subject is limited. Out of curiosity, what informed your impression that C programmers tend to be anti-Rust? As an outsider and programming language enthusiast, I am always very interested to know how people approach new programming languages.

                          1. 3

                            I don’t know if C programmers are generally anti-rust (I’ve seen some people who do regular work in C and really enjoy Rust. I think Bryan Cantrill is one). But the people I’ve seen negative comments from tend to use C, C++ or Go for lower level programming and not see the point.

                            1. 1

                              FWIW: Bryan Cantrills new company (oxide) is a Rust shop.

                            2. 3

                              I have some experience with OS/low-level C, but not kernel-maintainer level, but I’ll guess anyway:

                              C is at it’s core rather simple. When using the language for real-world applications, you’ll encounter all the concepts pretty quickly. There are a few quirks in the syntax that one might not expect (eg. interleaving a switch-case and a loop is possible), but all in all, the core is clean. Rust, from my experience has more primitives, it changes a lot, quickly (afaik).

                              Another thing that comes to mind is the development environment/tooling. C’ development environment is basically everything and nothing, because a properly setup *nix operating system is basically already a development environment. The system is sort of defined and expanding in terms of itself, with make and such. Rust brings it’s own keychain, for reasons I don’t think are illegitimate, but makes it seem “alien”, not as “native” as C.

                              That’s just my take from someone who still hasn’t finished more than 20% of the Rust Book (though not just because of the points I just mentioned), so my possible misconceptions about the language are intentional.

                              1. 7

                                My impression is that C is only simple if maintaining and debugging the code is someone else’s problem.

                                1. 0

                                  One doesn’t maintain a language, one maintains software. C “the language” is simple. The memory model is transparent, the syntax is clean, but of course too much simplicity can lead to an overcompensation of site-local complexity in larger projects, to make up for concepts you are missing (both from a usability and safety perspective), which is probably what you are referring to – but that’s not the same as to say that C is complicated.

                                  1. 6

                                    The problem is that “simplicity” isn’t worth anything when it creates complexity everywhere else.

                                    You want thread safety? Good luck! You want optimized, reusable containers? Ugh, maybe an include header hack will do? You want memory safety? Better get fuzzing. You want dependencies, portability or cross-compilation? You’ll never stop getting bug reports about your build scripts.

                                    1. 1

                                      Fair enough, but the people who value the simplicity of the language over the environment, as to probably those who prefer C over Rust, would disagree, which is fine.

                                    2. 6

                                      the syntax is clean

                                      https://cdecl.org