1. 5

    I saw “Eclipse” and immediately felt a wave of sadness, but then I looked at the screenshots and it appears that they’ve done a good job of reproducing the overall UI from version 1. So nice work, probably the least-ugly Eclipse-based application I’ve ever seen!

    1. 11

      Eclipse Theia is a fork of Visual Studio Code.

      1.  

        Oh I see, so that’s why! Thanks, I had no idea that existed!

    1. 10

      First they ignore you, then they ridicule you, then they make clumsy imitations of your features while claiming they came up with them.

      1. 14

        I don’t think they’ll ever again miss the point so spectacularly as when they added Option tho.

        1. 4

          Same question as I have for the parent: for someone not following what happens in Java and hasn’t come across any articles about this: what’s wrong with Java’s Option?

          1. 9

            My interpretation: Option is what you use when you have non-nullable references, but you want a Nothing value. But in Java, all references are nullable per default, so what does the Option provide? Now you have two Null values: null and Nothing. Ok, then you use NonNull<Option<A>> in concert with your IDE. But that is clumsy.

            The proper solution would probably involve a new binding syntax, which would be non-nullable by default.

            1. 6

              The solution would be to add a type specifier or operator which creates explicitly non-nullable types and support that at language level because we can’t go back in time to make non-nullable a language default.

              1. 7

                I think C# is making good progress in that regard. Expect a badly copied version of that in Java 34, I guess.

              2. 5

                People always bring this up in discussions about Optional, it’s not a problem in practice. I’ve never seen someone try to return null on a method that returns an Optional and if I did it wouldn’t pass code review.

                The proper solution, which is planned, is to change it to a “primitive object” that has no identity and cannot be null. This seems to be coming relatively soon considering Valhalla has been in the works for a while and this JEP popped up recently.

                1. 3

                  primitive object

                  I wonder what will be the final name of this.

                  has no identity

                  I always found this Java-self-invented lingo pretty weird – if it’s possible to ask “is this identical to that”, it has identity. I think Java devs mixing up “same reference” with “identical” caused this confusion.

                  1. 2

                    Primitive object seems to be the final name, they started with value objects, moved to inline object, and then settled on primitive object. I’m not a huge fan of it but there was some rationalization on the mailing lists.

                    I always found this Java-self-invented lingo pretty weird – if it’s possible to ask “is this identical to that”, it has identity. I think Java devs mixing up “same reference” with “identical” caused this confusion.

                    This isn’t unique to Java, C# and Python use identity in the same fashion: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/objects#object-identity-vs-value-equality https://docs.python.org/3/reference/expressions.html#is-not

                    1. 1

                      I guess it’s no coincidence that all those languages have problems with identity/equality around floating points.

                      (Which is not about floating points in particular, but they serve as a nice canary to indicate that their approach to equality/identity is broken.)

              3. 5

                Multiple methods are implemented incorrectly and violate monad laws, causing weird behavior around null. But that is “works as intended”, because Java is “pragmatic”.

                A minor nitpick is that Optional is not marked Serializable, making everyone’s life a bit more miserable than it had to be. (The explanation they gave for that was bullshit for various reasons.)

                1. 3

                  I believe they forgot to make Optional be iterable, which breaks a lot of the properties it has in other languages.

                  1. 4

                    You can use Optional.stream(), which you can iterate.

              4. 1

                For those not following along, what are the issues with Java records?

              1. 13

                I remember when generics were being added to Java in 2004. All the why on earth do we need this, etc. At that point there weren’t many mainstream languages with true generics, you had C++ which had templates but wasn’t the same, then there was Ada and Eiffel, more niche…

                It totally revolutionized Java as a language for the better. C# added generics as well a year later and I would bet that having generics is what made them such popular languages.

                Go will significantly improve due to this, it will not be the same after that. Generic data structures, higher order functions, oh my! I will definitely return to Go after a long hiatus after this is out :)

                1. 4

                  Eh, this is something I’ve always wondered: if I release software under the AGPL/GPLV3, does that bind only the licensees and not me, given that I own the copyright? I could develop proprietary enterprise features and not be obliged to release their sources, right, but not be bound by the license. This is allowed, right? So in theory I could have the following business model:

                  1. The software is free software under AGPL
                  2. I register a trademark for the software, so others can’t redistribute the software under the same name without explicit permissions
                  3. I offer closed source proprietary “enterprise features” that don’t really respect the AGPL, but I don’t have to
                  4. I can also offer commercial proprietary licenses to users that don’t want to license under the AGPL

                  Right, this is a bit lawful evil, and it wouldn’t be my ideal business model. I would prefer offering services and support (hosted SaaS offerings etc.) instead of this but the model above is definitely easier to make money with, if it’s legal.

                  1. 10

                    Eh, this is something I’ve always wondered: if I release software under the AGPL/GPLV3, does that bind only the licensees and not me, given that I own the copyright? I could develop proprietary enterprise features and not be obliged to release their sources, right, but not be bound by the license. This is allowed, right?

                    Yes, but there’s a big catch: if you have accepted contributions from third parties who licensed their changes under the GPL and retain copyright, those changes virally “infect” your own code within the project, too. So you can distribute a project under a GPL-family license and change the license terms at your pleasure, if and only if you never accept outside contributions. And that’s a good thing IMO.

                    1. 1

                      Yes, right, that’s the caveat. Suppose I get contributors to sign some sort of CLA granting me the copyright? Again, lawful evil, but that would be the way around it?

                      For this very reason, CLAs are evil incarnate, because such contributors would essentially be working for me for free.

                      The only “CLAs” I’ve ever signed are the FSF ones. The FSF is probably the only entity in the world to which I’d gladly transfer my copyright.

                  1. 20

                    The compsci tag probably covers this, I think?

                    1. 0

                      I don’t really see “CompSci” as covering an article about the polynomial time algorithm for identifying whether a number is prime, but maybe that view is coloured by being a PhD in math who has ended up doing a lot of computing.

                      1. 13

                        If that isn’t computer science, I don’t know what is. Granted, that’s closer to maths than most of it, but it’s still stereotypically computer science.

                        1. 3

                          That sounds very much like computer science to me.

                          1. 3

                            IMHO as soon as you’re determining the time or space an algorithm requires, you’re in the realm of CompSci. After all, those metrics only work in a framework where you compute :-)

                            (but that may be my German-colored view of CompSci, which is rooted in math and depending on the department, in math only, unlike other regions where CompSci has a closer relationship to electrical engineering)

                        1. 5

                          This article nicely illustrates how easy the git email flow is for developers/contributors, but how about for maintainers?

                          For instance, how do I easily apply a patch sent to me, if I use the gmail/fastmail web interface? If web-mail is frowned upon, does it work if I use thunderbird/outlook/something-else? Or does it basically require me to use mutt?

                          How about managing different patches from different sources at the same time? Github conveniently suggests you create a local copy of the PR’ed branch, meaning you can easily change between different PRs. How does this work with git email flow? Do I just create those branches myself, or is there an easier way to do it?

                          What about very large patches? I recently applied a code formatter to a project I contribute to, resulting in a 4MB diff. Not all email clients/servers handle arbitrarily large files well.

                          I’ve seen enough descriptions about how git-send-email works from a contributors perspective, but I would really appreciate it, if someone would write down how they then receive and review patches in this flow.

                          1. 6

                            Although his workflow is obviously not representative of most maintainers, Greg K-H’s writeup was nonetheless fascinating.

                            1. 1

                              That does indeed look fascinating, and like it addresses some of my questions. Will take a closer look later.

                            2. 6

                              As long as your e-mail client/interface doesn’t somehow mangle the original message, the simplest solution would probably be to simply copy the message as a whole and then run something like xsel -ob | git am in the repository. I’d reckon this is much easier than setting up some more UNIX-like e-mail client.

                              1. 3

                                For instance, how do I easily apply a patch sent to me, if I use the gmail/fastmail web interface? If web-mail is frowned upon, does it work if I use thunderbird/outlook/something-else? Or does it basically require me to use mutt?

                                You can certainly use mutt or Gnus if you want. Most projects using git-by-email use mailing lists, some are fancy with download buttons to get the patches. Most of the time you can pass the output of curl fetching the mailing list page directly to patch. Quoting the manual

                                patch tries to skip any leading garbage, apply the diff, and then skip any trailing garbage. Thus you could feed an article or message containing a diff listing to patch, and it should work.

                                I’ve done this as recently as this week, when I found an interesting patch to u-boot.

                                If a mailing list or other web view isn’t available, then you can either set one up (patchwork is the defacto standard) or find a client that doesn’t break plaintext emails. Last I checked, receiving patches via Gmail’s web interface was difficult (but sometimes possible if you hunt down the “raw message” link), I haven’t checked Fastmail. If you don’t want to use a TUI or GUI email client, you can configure getmail to only fetch emails from specific folders or labels, and that will create mbox files you can use with git am.

                                How about managing different patches from different sources at the same time? Github conveniently suggests you create a local copy of the PR’ed branch, meaning you can easily change between different PRs. How does this work with git email flow? Do I just create those branches myself, or is there an easier way to do it?

                                Branches are lightweight, create them for however many things you want to work on at the same time. I usually don’t use branches at all, instead using stgit, and just import patches and push and pop them as needed.

                                What about very large patches? I recently applied a code formatter to a project I contribute to, resulting in a 4MB diff. Not all email clients/servers handle arbitrarily large files well.

                                You can breakup that work into smaller chunks, to avoid too much disruption to other patches that might be in flight. Nothing stops you from linking to an external patch, though I would probably prefer instructions on how to run the tool myself, and just forgo the patch in that case.

                                1. 3

                                  What about very large patches?

                                  git request-pull can be used for this purpose, it generates emails with a URL from which the reviewer can pull the changes. It’s generally used for subsystem maintainers in large projects to merge their (independent) histories upstream, but it can also be used to handle large changes which would be unwieldly in patch form.

                                  1. 2
                                    1. 1

                                      I wondered about the same thing. After a very long unfruitful search on the internet, @fkooman pointed me to git am - Apply a series of patches from a mailbox, which pretty much takes care of everything. It would have been helpful if git-send-email.io had a pointer to that, or maybe I missed it..

                                    1. 12

                                      Ah, of course, in Emacs one would just do C-x v d to open VC Directory Mode, go to the first removed file, hit M to mark (i.e. select) all files with the similar status to mark all files that have been deleted. Then C-x v u (vc-revert) to undelete those files.

                                      edit: the joke

                                      1. 3

                                        I think this guide is otherwise good, but I think it should start at the package-initialize section, anything else before that are just matters of taste and are tangential to the point of the guide, i.e. configuring a Common Lisp editing environment. Not to mention it refers the user to enable displaying line numbers, which is an Emacs anti-pattern.

                                        I bet people are going to ask why it is an anti-pattern, so here goes. Disclaimer: I know many people are used to have line numbers visible in other editors, and such a preference is usually deeply personal, so I’m trying my best to not sound patronizing here.

                                        In Emacs, you usually shouldn’t need to navigate by line number, because Emacs should be able to take you to those places automatically. For instance, compilation errors, Emacs has the built-in compile-mode which will automatically create a global keybinding to next-error (which would be M-g g), and that takes you directly to the offending line. Similarly, if you’re used to jumping to a function you see at a point before the position of the cursor, you should use functions like beginning-of-defun (bound to C-M-a). See the relevant section in the GNU Emacs FAQ.

                                        Besides, line numbers can occupy significant horizontal space. So by not using them, you gain lots of needed horizontal space, and can keep more buffers open side-by-side.

                                        1. 1

                                          Sorry, the keybinding for next-error is actually M-g M-n. M-g g is goto-line.

                                          1. 1

                                            Plus, at least last time I used them, line numbers slow Emacs down significantly. That’s what made me originally stop using them and before long I didn’t miss them at all.

                                          1. 14

                                            The growing bloat on the web really kills websites for me. One recent example is the new reddit design, which made me quit it altogether (among other reasons).

                                            Why does it always need to be lazyloading Ajax-crap? JS-generated transitions are always horrible and clunky. Let’s hope there will be a move towards a more sustainable and suckless direction at some point in the future.

                                            You don’t need Javascript in many many cases, and if you do, a few kB will do just fine. And you don’t especially need it for overloaded UI-orchestration past the UI-model the browser provides and is optimized for.

                                            1. 6

                                              old.reddit.com still works fine; say about the new UI what you want, but at least they’re not forcing it upon you.

                                              1. 3

                                                The new Reddit redesign is such a disaster. After clicking on a post, I frequently find myself scrolling the background (the list of posts) rather than scrolling through comments in the post itself. It frequently takes many seconds for the website to respond to clicks on ridiculously powerful hardware. Scrolling through subreddits with many image posts bogs down the site completely, probably because infinite scrolling + lots of images and gifs + no technical competence is a predictable disaster. Searching in subreddits literally doesn’t work; when I search something, more often than not, the site will just say ‘No results found for “”’.

                                                I obviously mostly use the old website (which is also a design disaster in many ways, but at least it works). I just don’t understand how a team could see the result that is the redesigned website and be happy with it.

                                                1. 6

                                                  You bring up really good points and explained the problem well! It’s especially shocking when you browse the modern web with an older computer. I booted my old Mac mini from 2008 and was really sad to see that it was impossible to browse the web without massive lag and problems (text-only and light sites were just fine). Do we really want to waste all our advances by just keeping up with more and more useless cruft that brings essentially zero benefit to the end-user?

                                                  A good case is YouTube: They’ve stuffed their video pages with megabytes of Javascript, Canvases, AJAX-magic and whatnot, and even though it’s probably 4 orders of magnitude heavier than the video page from 10-13 years ago, it essentially does the same thing, while actually being worse at it, because it’s often unbearably sluggish and clunky. I often press the “back” button in my browser to return to the previous video, only to find out that their “history-emulation” in Javascript failed to keep up.

                                                  1. 6

                                                    I just don’t understand how a team could see the result that is the redesigned website and be happy with it.

                                                    There are millions of web programmers in the world. I doubt 95-99% of them would ever be an engineer if not for the current job market offering good career prospects, rather than being an engineer at heart.

                                                    The rush and the satisfaction of doing a good piece of engineering just doesn’t resonate with these people. Working in a company with hip factor, perks, following js-trend-du-jour because it’s trendy rather than for its technical merits, and a pay check. This is what the majority of the developers (specialy web developers due to lower entry barrier) care about. Never do they stop 5 minutes and think: “why are we doing this? what value does this provide to society? What are the advantages and disadvantages of switching a legacy product with a new flashy one with a material design UI, even if 1000 times slower?”. These essential questions don’t matter for the bulk of web developers. What matters is a pay check and a quasi-religious sense of belonging to the users of this or that stack, preferably one generous handing out t-shirts (see hacktober fest fiasco) and/or stickers.

                                                    Why writing a clean, elegant piece of software in C or pascal, well though with strong theoretchical foundations, if you can hack together a buggy, yet flashy version with deno and get thousands of github stars? Who cares about code elegance… pfff… github stars man! That’s where is at!

                                                    1. 9

                                                      I can replace the word “web” with “C” and substitute the relevant misgivings with those from a 80’s die-hard assembler/ALGOL/Lisp programmer to make it sound like it was from 1991. Your comment would still be just as ridiculous as it is now.

                                                      1. 5

                                                        s/ridiculous/true/

                                                        :-P

                                                        1. 2

                                                          I strongly disagree with you there. C vs assembly actually provides a lot of benefits with minimal losses in regard to performance, and back in the 90’s, we didn’t have this hipster-culture around it that we see today with web-development. @pm is spot-on with his analysis, in my opinion.

                                                  1. 1

                                                    w.r.t the lack of package management for Guile, have you looked at akku.scm?

                                                    1. 2

                                                      Yeah. And guild hall as well. Akku is the more promising one, but I think the problem is it will take some years it gains the momentum of something like Quicklisp. That’s probably a never though. For Guile I think Guix is the best option since with it you can combine C builds effortlessly, but for scheme in general Akku seems very, very promising.

                                                      Huh, I totally forgot to mention in the blog entry that CHICKEN is also a fantastic scheme implementation. Guile is a bit easier on the developer, but if you look close enough, they both are very practical though CHICKEN is more standalone, and I think there are some German companies actually using it in production.

                                                      1. 1

                                                        I love CHICKEN as a Scheme implementation. The package manager there feels quite a bit more like Quicklisp than, say, Akku. Gerbil/Gambit is another Scheme I’m fond of, though it lacks the community aspect I associate with CHICKEN.

                                                    1. 4

                                                      Small error in this: It says the latest Scheme version is R6RS, when R7RS-small has been finished for years. Not intending to bring up the R6RS/R7RS debate, just wondering if it was a typo or such.

                                                      1. 4

                                                        Yeah I totally forgot about R7RS, I was just trying to compare specification sizes in terms of pages. R7RS is even smaller at 20-somrthing pages, but the point was the two orders of magnitude in page count.

                                                      1. 3
                                                        1. 18

                                                          IMO, give up on the bizarrely macho idea that hjkl is uniquely amazing and use the arrow keys.

                                                          1. 18

                                                            To me the advantage of using hjkl instead of the arrow keys is that I don’t have to move my fingers away from the home row to move the cursor around. I don’t see how that is a “bizarrely macho idea”.

                                                            1. 1

                                                              I cannot imagine how that helps. Can you explain?

                                                              1. 7

                                                                You can keep your fingers in the middle of the typing area (home row) instead of going over to the cursors.

                                                                1. 0

                                                                  Oh, hi ane!

                                                                  You can keep your fingers in the middle of the typing area (home row) instead of going over to the cursors.

                                                                  I cannot imagine how that helps. Can you explain?

                                                                  1. 4

                                                                    Hi!

                                                                    I cannot imagine how that helps. Can you explain?

                                                                    You… move around less? It saves time. Like a keyboard shortcut or macro does, basically. It depends on the form factor of the keyboard, but usually the arrow keys are further away from the regular text input keys.

                                                                    1. 1

                                                                      Perhaps 10 years of active piano practice makes this a moot point for me but not so much for others. Or I’m just being an asshole. Could be both ;)

                                                                    2. 2

                                                                      What I find helpful about it, is that I don’t have to look away from the screen to see where the arrow keys are, and likewise when going back to the home row. If there’s a lot going on on your screen it’s easy to lose your place, especially when reading lots of text.

                                                                      Also it avoids the physical motion of moving your hand, it just feels more comfortable I think.

                                                              2. 16

                                                                I use a 60% keyboard without arrow keys

                                                                1. 1

                                                                  By choice, though?

                                                                  1. 2

                                                                    Yes, it’s more portable and means i don’t have to reach as far for my mouse

                                                                2. 10

                                                                  I used to think this way. Then I learned hjkl. Now I am in the cult of the ancient keyboard warriors

                                                                  1. 2

                                                                    Ancient keyboard warriors who didn’t have arrow keys? I used arrow keys, learned hjkl, thought it was nice, moved to dvorak, ditched hjkl for arrow keys. Nothing is magic about it. Why contort yourself to use hjkl on non-qwerty? Would hjkl be dhtn if the standard were dvorak at the time? Probably, but you can’t just remap dhtn now.

                                                                    1. 5

                                                                      There was once a really good reddit thread of a guy playing counter-strike with zqsd movement keys on a qwerty keyboard cause he copied a French (AZERTY) player’s keybinds. He did not realize this and posted about how much better these movement keys made him.

                                                                      1. 5

                                                                        Pedantic note: ScreaM is a Belgian, not French, player. The keyboard layout is still French though

                                                                      2. 1

                                                                        Would hjkl be dhtn if the standard were dvorak at the time? Probably, but you can’t just remap dhtn now.

                                                                        If you’re using Dvorak in the “suggested sense”, even dhtn would be awkward since you’d be using your right index finger for both d and h. Maybe htns (or QWERTY jkl;) would be better.

                                                                    2. 9

                                                                      How did you come to the conclusion hjkl is “bizarrely macho”?

                                                                      1. 8

                                                                        Why is that macho?

                                                                        I mean some people tried it, liked it and share the good experience of how great it feels when you get used to it.

                                                                        1. 3

                                                                          I used to use hjkl. Then I started getting RSI. Now I appreciate the break my fingers naturally get every time I have to move my hands to the arrow keys.

                                                                          I can still use hjkl at a pinch, and probably use them many times a day without noticing. But yeah, it’s not worth getting worked up about.

                                                                          1. 8

                                                                            I can see this being the case, but I think it’s worth noting that RSI covers a large number of distinct problems, and that most RSI would only get worse by more frequently moving your hands away from the home position.

                                                                        1. 17

                                                                          TBH, a bit of up front research would have found all of those issues in the beginning.

                                                                          As somebody who’s pretty dedicated to working with an obscure language (Common Lisp), my advice is that if you’re not able (or not willing) to help write the missing libraries and tools that you need then you’re almost certainly better off using a language that already has them.

                                                                          1. 2

                                                                            If you look at some of the other posts related to async and performance, they do seem to re-learn things.

                                                                            1. 2

                                                                              Although Common Lisp is not mainstream, but I wouldn’t say it’s obscure. There’s plenty of libraries, the developer experience is very good (ASDF, Quicklisp, etc). And there’s quite a lot of deep production use of CL.

                                                                            1. 1

                                                                              https://ane.github.io

                                                                              Actually few of the sites already mentioned in this thread have been an inspiration, but can you guess which?

                                                                              1. 1

                                                                                Clean, I like it. Maybe I just don’t see the need for both “about” and “home”, they seem to have the same purpose.

                                                                              1. 8

                                                                                I see some constant trend to compare stuff in Emacs with external packages (e.g. Magit vs vc, Flycheck vs Flymake, Projectile vs project.el), which I find slightly bizarre given the trend in Emacs to move as many built-in packages as possible to GNU ELPA,

                                                                                Flymake and project.el are both ELPA packages, actually. vc has been around for three decades and it predates package.el.

                                                                                • drop the contributor agreement

                                                                                The FSF legal counsel has declared that they cannot enforce the GPL unless the copyright belongs entirely to the FSF. This is why the contributor agreement is needed, and anyway, it’s just one email to the FSF, sign a paper, email a scan of the paper (you can get away with using your smartphone).

                                                                                • discuss ideas in an (modern) issue tracker, instead of on a mailing list

                                                                                What’s wrong with mailing lists? Issue trackers like Github are quite bad for discussion, which is why you always need something like Gitter or IRC to provide a discussion forum. A mailing list can be used for both development (patches) and discussion.

                                                                                • apply less political activism and more pragmatism in the conversation around new ideas/features

                                                                                Being free software and adhering to the free software principles is an important aspect of Emacs. It is a good idea to consider the impact of ideas on user freedoms. It’s not done whimsically, freedom is important.

                                                                                1. 4

                                                                                  What’s wrong with mailing lists?

                                                                                  I think my main problem with mailing lists is the lack of tracability in the history. It’s not a logical consequence of mailing lists (you can certainly do it), but it doesn’t seem to happen.

                                                                                  I spend a fair amount of time digging through GCC’s history and when I find a patch touching code that matters to what I’m looking at, the commit message is not enlightening. Why was the change made? Is this associated with a bug? What was the design discussion around it? (But ooo - Changelog was updated! “Ditto!”) Rarely are those anwered and even rarer is an identifer or link to a bug report or a mailing list discussion. I have to go digging through mailing list posts (with a really substandard search mechanism) to find some background. Even then, there might not be any.

                                                                                  Say what you want about issue trackers, but having every commit associated with some background knowledge is really, really useful in the long run.

                                                                                  1. 2

                                                                                    Oh, issue trackers are absolutely essential. You definitely need one, a mailing list isn’t enough. The kind of discussion I was talking about and the way in which mailing lists make most sense is in informal, meta discussion. Places like github don’t have anything for that and its issue tracker is not good as a forum.

                                                                                    1. 2

                                                                                      Places like github don’t have anything for that

                                                                                      They do, its called discussions.

                                                                                      https://docs.github.com/en/free-pro-team@latest/github/building-a-strong-community/about-team-discussions

                                                                                      But I agree that the flat comment hierarchy is not ideal for discussions that tend to branch out.

                                                                                  2. 3

                                                                                    Flymake and project.el are both ELPA packages, actually. vc has been around for three decades and it predates package.el.

                                                                                    I’m not sure if you’re trying to contradict me here, because you’re just repeating what I said. I’m well aware they are not ELPA packages, even if this wasn’t always the case. That’s part of the trend to I mentioned that you actually quoted.

                                                                                    The FSF legal counsel has declared that they cannot enforce the GPL unless the copyright belongs entirely to the FSF. This is why the contributor agreement is needed, and anyway, it’s just one email to the FSF, sign a paper, email a scan of the paper (you can get away with using your smartphone).

                                                                                    Well, I’m not a legal expert but I do wonder what does mean for every other GPL project that doesn’t have an explicit copyright assignment agreement. I did sign the agreement a long time ago and I recall I waited so long for the confirmation that by the end I didn’t remember I had done it. Very few people are going to waste so much time to contribute to a project, unless they are really invested it in. At the very least the FSF that switch to instant digital signatures or something like that.

                                                                                    What’s wrong with mailing lists? Issue trackers like Github are quite bad for discussion, which is why you always need something like Gitter or IRC to provide a discussion forum. A mailing list can be used for both development (patches) and discussion.

                                                                                    Mailing lists provide no structure and people who branch out different threads from the main one create a total mess. You don’t need a chat to have a conversation - you can just use an issue’s comments (as one example). A lot of huge projects are doing this and it works fine for them. I’m not saying “drop email completely”, I’m saying “don’t use them for things they are not optimal for”.

                                                                                    Being free software and adhering to the free software principles is an important aspect of Emacs. It is a good idea to consider the impact of ideas on user freedoms. It’s not done whimsically, freedom is important.

                                                                                    True. But in the end of the day you also have to remember that you’re building software that is meant to solve certain real-world problems. Your political agenda will mean nothing if it drives an excellent piece of software into the ground. I used to be a big believer in RMS and FSF 20 years ago, but seeing how his leadership style and hardline vision affected negatively a lot of GNU projects, I’m not 100% that this is not the way to go. Great software needs users, it needs mindshare and it needs traction. It cannot exist on top of a political agenda alone.

                                                                                    1. 3

                                                                                      I’m not sure if you’re trying to contradict me here, because you’re just repeating what I said. I’m well aware they are not ELPA packages, even if this wasn’t always the case. That’s part of the trend to I mentioned that you actually quoted.

                                                                                      You mean they are ELPA packages? I see now what you meant, but given the previous sentence I was under the assumption that you didn’t think they were ELPA packages.

                                                                                      At the very least the FSF that switch to instant digital signatures or something like that.

                                                                                      I think you can get away by just using PDF digital signatures. No need to print anything.

                                                                                      Mailing lists provide no structure and people who branch out different threads from the main one create a total mess. You don’t need a chat to have a conversation - you can just use an issue’s comments (as one example). A lot of huge projects are doing this and it works fine for them. I’m not saying “drop email completely”, I’m saying “don’t use them for things they are not optimal for”.

                                                                                      Well, that depends on your email client. Email supports threading just fine. A nice alternative is to use NNTP (news) via Gmane, because then you can just fetch the entire thread of a single message. You can do this in Emacs right now, hit M-x gnus RET B nntp RET news.gmane.io and pick emacs.devel from the list.

                                                                                      You can also use sourcehut’s lists which provide an excellent web user interface for mailing lists, with support for threads, and replying on the web. It’s still just email underneath.

                                                                                      True. But in the end of the day you also have to remember that you’re building software that is meant to solve certain real-world problems. Your political agenda will mean nothing if it drives an excellent piece of software into the ground. I used to be a big believer in RMS and FSF 20 years ago, but seeing how his leadership style and hardline vision affected negatively a lot of GNU projects, I’m not 100% that this is not the way to go. Great software needs users, it needs mindshare and it needs traction. It cannot exist on top of a political agenda alone.

                                                                                      I would argue that GNU Emacs has survived close to 40 years (and Emacs itself close to 50 years) because it is free software. In the grand scheme of things adding support for LSP or native JSONRPC—although right now they are very welcome additions—will be yet another changelog entry and a historical footnote.

                                                                                      Free software matters — a large chunk of the world relies on GNU technology (GCC, coreutils, autotools, etc.) to do their computing. They did not survive on technical merit alone, they survived because they were free software first, and good software second.

                                                                                      I predict in 10 years things like Atom or Sublime Text will have fallen into obscurity, but Emacs, Vim, other free software will live on, and prosper.

                                                                                      1. 2

                                                                                        I’m sure that Emacs will be around for a very long time, but it’s already a niche editor (unlike vim) and with the way the project is stewarded that’s not going to change any time soon. There’s a big difference between surviving and thriving and my preference for Emacs would be the latter. As noted here VS Code is winning the hearts of most developers these days, and Emacs has been stuck at 5% for ages. That’s not going to get any better unless something fundamentally changes. Microsoft might have been an evil enterprise in the past, but today they are stewarding their open-source projects better than the FSF hands down. It’s really not all about money and resources - it’s about having the right mindset and the right attitude.

                                                                                        1. 2

                                                                                          I generally agree, though vscode is not my favorite thing.

                                                                                          I’m reminded more of things like RMS wanting to not pull lldb support into gud because (I’m paraphrasing only slightly) “llvm was trying to undermine the gpl”. The FSF can do whatever it wants, and I generally am ok with things, but the past 20 years haven’t impressed me much with their ability to reflect upon their processes and attempt to bring more into the fold.

                                                                                          I predict that GPL and even the FSF will take a back seat to more MIT/BSD/related licensed things due to their having more implicit freedom and less overall ideology drama to direct users of the code (programmers). Think like embedding llvm+clang into lldb kinda stuff. Things that gcc/gpl/fsf literally won’t allow for technically due to ideals. Imagine emacs with a builtin compiler for c/c++/rust/etc….

                                                                                          Prosper? I can’t see it happening given the current mentality of the FSF. Its too extremist in its ideals. They may even be “right” for whatever definition of right that is. But it seems to me to be a case of winning the battle but losing the war with their current path.

                                                                                          It used to be GPL/GNU software wasn’t good software “second”, it used to connote an air of quality on its own. Now however…. it just seems like being read into some ecclesial cult with some of the rituals involved.

                                                                                          1. 1

                                                                                            Emacs is not a popular editor by any means, but the goal of Emacs as the flagship editor of the GNU project is to be the best free software editor. That is its first goal, everything else is secondary. Once you understand Emacs is not going to sacrifice the respect of user freedoms in pursuit of popularity or technical superiority it makes sense how the project is governed. When it comes to good features Emacs does not usually reject them if they do not conflict with its free software ideals, e.g. see the recent development of native compilation of Elisp, native JSON-RPC etc.

                                                                                            Emacs has been forked in the past in pursuit of technical or practical superiority, see XEmacs, SXEmacs, etc. Those projects are no longer alive.

                                                                                            To me Emacs should stay in its pursuit of being free software first. I don’t think it’s particularly beneficial for Emacs to try to be the most popular editor if it means letting go of its founding principles: respecting user freedom.

                                                                                    1. 3

                                                                                      I’m actually looking forward Non-GNU Elpa, and hope it obsoletes MELPA. Having more packages installable, without having to find out about MELPA, find out how to use it and set it up seems like a plus. Really the only thing MELPA will be useful after that is to host packages that promote propitiatory software, which is just what RMS takes issue with.

                                                                                      1. 6

                                                                                        The Emacs developers could have just as easily enabled MELPA/MELPA Stable by default if they wanted to, so I think they’re not exactly constructive in their approach to the issue. I also assume they’ll force people to use their (inferior/legacy) development toolchain for Non-GNU Elpa, which will likely be off-putting for many package authors. As a package developer I’d rather focus on doing some meaningful work for the end users, rather than deal with rules and regulations of little value. Obviously, that’s a matter of perspective - I love the MELPA approach of doing things and I dislike how Emacs is being stewarded (although things have been slowly improving there over the past decade).

                                                                                        1. 3

                                                                                          Even if the GNU project would disregard their commitment to avoid propitiatory software, I still think MELPA shouldn’t be used. Regular MELPA publishes whatever the last commit was in the repository being used. That would required a more advanced approach with Git branches, but nothing along those lines is enforced. MELPA stable at the same time is disregarded, and often forgotten, leading to broken packages and packages that cannot even be installed because they have non-stable dependencies.

                                                                                          I also assume they’ll force people to use their (inferior/legacy) development toolchain for Non-GNU Elpa, which will likely be off-putting for many package authors.

                                                                                          What do you mean? Mailing lists? It’s always a trade-off. Maybe you won’t have a fancy web interface like GitHub (thought Guix issue tracker comes close), but then again, you won’t have to use GitHub.

                                                                                          1. 3

                                                                                            I also assume they’ll force people to use their (inferior/legacy) development toolchain for Non-GNU Elpa, which will likely be off-putting for many package authors.

                                                                                            What’s so bad about it? You email emacs-devel saying here’s my package, please have a look. Then you get someone to apply your patch for elpa.git.

                                                                                            I completely understand this is not what people are used to with Github pull requests et al, but I don’t see anything fundamentally bad about this - you can use sourcehut to prepare patches over a web interface. The ability to use git send-email with a web interface is one of the really amazing innovations at sourcehut, mad props to @ddevault.

                                                                                            1. 3

                                                                                              What’s so bad about it? You email emacs-devel saying here’s my package, please have a look. Then you get someone to apply your patch for elpa.git.

                                                                                              Ah, yeah - I’ll wait for something else to apply patches for my package. :-) A recipe for productivity. But even assuming that everyone can just apply whatever changes are needed for their package, why go through the trouble of maintaining two instances of your package (as le’ts be real - almost all Emacs packages are hosted on GitHub/GitLab these days). You can’t afford not to be on GitHub/GitLab as this limit the potential collaborators for your package a lot, so in effect to be on GNU/non-GNU ELPA you have to do additional work. How is this a good idea for anyone? And that’s a lot of the beauty of MELPA - it spares the maintainers from having to deal with additional work for package distribution. That’s really important IMO! If GNU non-ELPA replicates the same approach, however, this will make the rationale for their repo pointless, though, so I guess they’ll want the code to be copied to a repo that supposedly will be vetted and what not.

                                                                                              I completely understand this is not what people are used to with Github pull requests et al, but I don’t see anything fundamentally bad about this - you can use sourcehut to prepare patches over a web interface. The ability to use git send-email with a web interface is one of the really amazing innovations at sourcehut, mad props to @ddevault.

                                                                                              And code reviews over email are so much fun, right? Seriously, even before GitHub sending lots of patches over email and discussing improvements there was both annoying and inefficient. Being able to do something in a certain way, doesn’t make it the optimal way. While I do like GitHub and maintain lots of projects there, I’m fine with any approach to work that provides enough structure and doesn’t results in wasted efforts.

                                                                                              1. 3

                                                                                                Ah, yeah - I’ll wait for something else to apply patches for my package. :-) A recipe for productivity. But even assuming that everyone can just apply whatever changes are needed for their package, why go through the trouble of maintaining two instances of your package (as le’ts be real - almost all Emacs packages are hosted on GitHub/GitLab these days). You can’t afford not to be on GitHub/GitLab as this limit the potential collaborators for your package a lot, so in effect to be on GNU/non-GNU ELPA you have to do additional work. How is this a good idea for anyone? And that’s a lot of the beauty of MELPA - it spares the maintainers from having to deal with additional work for package distribution. That’s really important IMO! If GNU non-ELPA replicates the same approach, however, this will make the rationale for their repo pointless, though, so I guess they’ll want the code to be copied to a repo that supposedly will be vetted and what not.

                                                                                                With ELPA, you can actually maintain your package as an out-of-tree remote ref. Just do

                                                                                                git push elpa master:refs/heads/externals/yourpackage
                                                                                                

                                                                                                and the next nightly build will have it updated. You just need push rights to elpa.git which you can request from emacs-devel. This way you don’t have to maintain separate instances.

                                                                                                I think one of MELPA’s worst aspects is the fact that it just builds on every commit. There are lots of quality regressions! Many times after updating packages I’ve had to erase my ~/.emacs.d/elpa directory and start over, pinning stuff to melpa stable or something. This often happens because breakage in transitive dependencies.

                                                                                                What I would like to see is MELPA distributions like Quicklisp, which does monthly releases of packages that have been tested to work together. MELPA Stable has no end to end tests, you can just tag any commit you like.

                                                                                                And code reviews over email are so much fun, right? Seriously, even before GitHub sending lots of patches over email and discussing improvements there was both annoying and inefficient. Being able to do something in a certain way, doesn’t make it the optimal way. While I do like GitHub and maintain lots of projects there, I’m fine with any approach to work that provides enough structure and doesn’t results in wasted efforts.

                                                                                                Well, I just think Github issues are not good for structured conversation, it’s really just a flat list. Email threads are superior in this regard, but you need an email client that supports them (or just use a newsreader with Gmane).

                                                                                                1. 1

                                                                                                  I think one of MELPA’s worst aspects is the fact that it just builds on every commit. There are lots of quality regressions! Many times after updating packages I’ve had to erase my ~/.emacs.d/elpa directory and start over, pinning stuff to melpa stable or something. This often happens because breakage in transitive dependencies.

                                                                                                  That’s why there is MELPA Stable. Personally I use MELPA for years and faced problem only once but I exactly for those reasons there is MELPA Stable. As package author I find MELPA approach far more better then ELPA.

                                                                                                  Well, I just think Github issues are not good for structured conversation, it’s really just a flat list. Email threads are superior in this regard, but you need an email client that supports them (or just use a newsreader with Gmane).

                                                                                                  I think code reviews should be bound to code not to maili. Even though GitHub issues might not be the best solution from threaded point of view it still keeps all comments regarding code in one place which I find much better.

                                                                                                  1. 3

                                                                                                    That’s why there is MELPA Stable. Personally I use MELPA for years and faced problem only once but I exactly for those reasons there is MELPA Stable. As package author I find MELPA approach far more better then ELPA.

                                                                                                    The stability guarantee isn’t in any sense a real guarantee. If the package author feels like pushing a tag, it gets published to MELPA Stable.

                                                                                                    In general we should see that there is a distinction between distributions (sets of working packages) and development builds. I think we should try to get something cohesive for MELPA stable, and especially for NonGNU ELPA.

                                                                                                    1. 2

                                                                                                      I get your point, but I’ve used MELPA since day 1 and I’ve encountered only a handful of issues with the snapshot builds. (and I was fully aware what I had signed up for, so that was fine) The notion of distributions is nice, but I’m not quite sure how you’ll reliably infer that all packages play nicely with each other, as I don’t think the fact that a package can be loaded is enough of a criteria.

                                                                                                      I also wonder why I’d be tagging as a release, something that’s not a release but that’s a different topic I guess. What I’m trying to say is that often developers are trying to solve issues that are not that big of issues to begin with.

                                                                                                      1. 1

                                                                                                        The stability guarantee isn’t in any sense a real guarantee. If the package author feels like pushing a tag, it gets published to MELPA Stable.

                                                                                                        That’s absolutely true but that is general rule not related to MELPA in any way. Otherwise we wouldn’t have sections in changelogs named “Fixed bugs” ;)

                                                                                              2. 3

                                                                                                The Emacs developers could have just as easily enabled MELPA/MELPA Stable by default

                                                                                                Melpa has a history of making very bad decisions around security, so I’m glad they didn’t do this. It’s better nowadays but I still don’t trust their judgement after it took them three years to disable distribution of packages that were publicly editable on a wiki.

                                                                                                1. 4

                                                                                                  Well, I think they were mostly forced there, but the package development/maintenance culture that was common a few years back. In really, MELPA and GitHub/GitLab were the major reasons why hosting packages on EmacsWiki was finally (mostly) abandoned. I had never installed anything from wiki sources, for obvious reasons, but I know that many people considered this a feature. :-) MELPA also addressed another big problem back in the day - virtually no one was cutting releases and many projects would go on for years and years without a “stable” release. Back that a repo for “stable” packages would have never worked simply because there were so few of those of they were often incompatible with one another.

                                                                                                  1. 1

                                                                                                    I think they were mostly forced there, but the package development/maintenance culture that was common a few years back.

                                                                                                    This does very little to inspire confidence in their decision-making ability.

                                                                                                    I had never installed anything from wiki sources, for obvious reasons

                                                                                                    How do you know this for sure? The wiki-backed packages were not clearly marked, and non-wiki-backed packages could easily declare a dependency on a wiki-backed package. A big part of why this was such a disaster is that everything got tossed into one big pile, and there was no way to say “give me the stuff from github but not the stuff from the wiki”.

                                                                                                    MELPA also addressed another big problem back in the day - virtually no one was cutting releases and many projects would go on for years and years without a “stable” release.

                                                                                                    All the more reason guix-style repeatable packaging is needed rather than just tossing everything in a big pile and saying “here just have… I dunno; whatever version is newest; it’ll be fine probably”.

                                                                                                    1. 1

                                                                                                      How do you know this for sure?

                                                                                                      Fair point about the deps. I’m generally very careful with the packages that I use and I don’t install anything before skimming over the package source to acertain its general quality, but package deps can, of course, change, so you’re right.

                                                                                                      I do believe, however, that in MELPA’s web UI the source of each package was clearly visible. Sadly, you can’t have such additional data in Emacs’s own UI.

                                                                                                      All the more reason guix-style repeatable packaging is needed rather than just tossing everything in a big pile and saying “here just have… I dunno; whatever version is newest; it’ll be fine probably”.

                                                                                                      True, but time has made me quite practical and I’ll take any reasonable solution that solves my problem over waitng for a great/perfect solution. In theory MELPA sounds like a recipe for trouble, but I’ve used it since day one and I had very few issues with it (and none of them were serious). When I compare that to vendoring packages manually beforehand, it seems like a massive improvement to me. :-) No to mention all the efforts of the MELPA team to clean up some packages so they could be distributed with package.el in the first place.

                                                                                            1. 1

                                                                                              While it is easy to migrate the site to a new server, it is not effortless to update the contents of the site, because you can’t re-generate a Jekyll-driven site if you don’t have Jekyll installed on the computer.

                                                                                              You can setup Jekyll to run in CI. Though that’s not exactly trivial, then all you need is Git and SSH really.

                                                                                              1. 25

                                                                                                I would love to see some examples where a company changed the license of their codebase to comply with a dependency. I have never seen this happen in my entire career, even though they are obligated to. I have seen countless examples of people rewriting code to rid of a dependency with an incompatible license, I have even done it myself.

                                                                                                I understand and respect the pure ideology of strong copyleft licenses (that in a perfect world, everything would be open source), but I don’t believe that it actually yields more open source in the world. In practice, people simply avoid it and it yields more duplicated work that ends up either proprietary (more common worst case) or more permissive (best case).

                                                                                                It is difficult to prove, but I feel that the “leading by example” ideology of permissive licenses is responsible for far more code being made open source in practice (though I acknowledge this is not everyone’s goal).

                                                                                                1. 16

                                                                                                  I think OpenWRT exists because linksys had to do this.

                                                                                                  I was just looking into this question myself today and have this history of openwrt on my reading list if that helps.

                                                                                                  1. 5

                                                                                                    Linksys did that, and then stopped maintaining the code, and switched to another OS for most of its hardware. Was that VMX, perhaps? I don’t remember. Some commercial OS. They stated that the reason was that linux needed too much RAM, which I find difficult to believe. Slimming down a linux kernel is IMO likely to be simpler than porting a code base to a new OS, so I tend to believe that Linksys’ stated reason was a polite lie. They did release a single model that ran linux, and I bought that model.

                                                                                                    1. 4

                                                                                                      I believe it was VxWorks

                                                                                                      1. 1

                                                                                                        All the vendors do a fantastically bad job.

                                                                                                        https://www.youtube.com/watch?v=PLXmPgN6wVs

                                                                                                        1. 1

                                                                                                          When you say that everyone in a specific field does a fantastically bad job, you should also consider the possibility that your assessment might be off, and why that might be the case.

                                                                                                      2. 2

                                                                                                        Queued that up as well! I also had a WRT54G(L) for a very long time, excellent device.

                                                                                                      3. 12

                                                                                                        I have seen countless examples of people rewriting code to rid of a dependency with an incompatible license

                                                                                                        This is a very good case, IMO, and is my primary motivator for using (A)GPL on most of my newer work. I would much rather force the big bads to rewrite my code than simply profit off my work, and we have some evidence that they will do that to avoid (A)GPL sometimes.

                                                                                                        I would love to see some examples where a company changed the license of their codebase to comply with a dependency.

                                                                                                        I think to be fair on this one you have to also include all the code that started or stayed freedomware because of the requirement. This would include the example from the OP of the same downstream hosting the other project in compliance.

                                                                                                        1. 13

                                                                                                          I would much rather force the big bads to rewrite my code than simply profit off my work, …

                                                                                                          I don’t know who you imagine is “the big bads”, but in reality it’s a lot of people like me who release all their projects under permissive licenses like MIT.

                                                                                                          1. 11

                                                                                                            You can use an (A)GPL’d dependency on an MIT’d project, just the resulting “combined work” is effectively (A)GPL’d. Some projects even have build flags to choose to build in “GPL mode” or not depending on which dependencies you use. It’s all about goals.

                                                                                                            If you want your software to be used to build nonfree products so badly that you reimplement something under the GPL to use as a dependency for your otherwise MIT’d project… I mean, more power to you, right? It’s your choice.

                                                                                                            We have examples of Apple, Google, VMWare, Linksys, and others doing rewrites to avoid using GPL’d code, and I would say that is the point, for me.

                                                                                                            1. 15

                                                                                                              I wrote before:

                                                                                                              It is difficult to prove, but I feel that the “leading by example” ideology of permissive licenses is responsible for far more code being made open source in practice (though I acknowledge this is not everyone’s goal).

                                                                                                              My goal is to provide as much value to the society as possible through each unit of my effort. I want people to use my code, I want people to profit from my code even if I get nothing for it, I want people to build things they otherwise wouldn’t have built because my code enables it. I am going to make the effort to make my code as accessible and permissive as possible, this often means avoiding (A)GPL dependencies and often duplicating effort in the process.

                                                                                                              I recognize that your goal is not the same, and that’s fine. I just hope that you also recognize the reality that Apple/Google/VMWare/Linksys etc don’t care at all, they’ll simply not even look at AGPL code and move on. If they find AGPL code in their stack by accident, they will purge it. If they’re caught in a situation where they are in legal trouble, they will do the absolute minimum to comply with that version and purge it moving forward.

                                                                                                              Overall, my bet is that choosing strong copyleft licenses has more of a net-negative effect on people who share my goal than any measurable effect on “the big bads”.

                                                                                                              1. 9

                                                                                                                Apple/Google/VMWare/Linksys etc don’t care at all, they’ll simply not even look at AGPL code and move on

                                                                                                                again, I consider that a win for me

                                                                                                                1. 6

                                                                                                                  It sounds as if your primary aim is to prevent some some people from using your code, without blocking access for too many other people. As opposed to the BSD/MIT/Apache licenes, whose primary aim is to make software available for all to use, without any attempt at dividing the world into us and them.

                                                                                                                  1. 5

                                                                                                                    Close. The goal is to prevent some uses which in this world tends to leave out some users.

                                                                                                                    1. 1

                                                                                                                      The goal is to prevent some uses

                                                                                                                      It is obligatory at this point to remind everyone that the AGPL should not be considered a Free Software license, as it does not grant Freedom 0. In fact, its entire purpose is to withhold Freedom 0 from recipients of the software in order to try to gain leverage over them.

                                                                                                                      1. 8

                                                                                                                        The AGPL only triggers if you modify the software (since otherwise no copyright is in play and no license would be relevant). So if you just run unmodified software (freedom 0) the AGPL does not apply or restrict you.

                                                                                                                        1. 5

                                                                                                                          It is obligatory to point out that the people who defined Freedom Zero, and in doing so defined Free Software, also explicitly state that the AGPL is absolutely a Free Software license.

                                                                                                                          Your point is mooted.

                                                                                                                          1. 3

                                                                                                                            The FSF’s stance on freedom is that you shouldn’t be allowed to have too much of it, lest you use it to do things the FSF disapproves of.

                                                                                                                            The AGPL was simply a reaction to the discovery that there were more things of which the FSF disapproved and which had not been foreclosed by prior licenses, so a new license was concocted to ensure that dangerous freedom wouldn’t get around too much.

                                                                                                                            1. 3

                                                                                                                              The logical gymnastics of both using the FSF’s definition of Free Software while rejecting their definition of Free Software is awesome to behold, and honestly would put Simone Biles to shame.

                                                                                                                              1. 2

                                                                                                                                I would flip that around and suggest that the rhetorical gymnastics the FSF uses to try to trick people into thinking their positions are coherent are something to see.

                                                                                                                                Essentially, they want to bludgeon everyone else with an absolutist position, while never being held to that same absolutism in their own actions. Or, more succinctly, they want to be able to compromise “freedom” when they think doing so will achieve a higher/larger goal. But woe to anyone else who tries doing that – then they’ll tell you that compromising freedom is never acceptable, no matter how good or great the thing you’d achieve by doing it!

                                                                                                                                Their adoption of the AGPL, which does not conform to their own original definition of Free Software and on those grounds never should have been accepted as a Free Software license, is just one especially obvious proof of that.

                                                                                                                  2. 6

                                                                                                                    My goal is to provide as much value to the society as possible through each unit of my effort.

                                                                                                                    I want freedom for users to educate themselves and contribute as opposed to becoming mindless consumers.

                                                                                                                    That’s why I believe AGPL is a good license for applications.

                                                                                                                    I also believe that for libraries and frameworks MIT, APL or MPL work better to achieve that goal.

                                                                                                                    Having more educated people - in my opinion - is better than having more usable code in the long-term.

                                                                                                                    1. 3

                                                                                                                      Overall, my bet is that choosing strong copyleft licenses has more of a net-negative effect on people who share my goal than any measurable effect on “the big bads”.

                                                                                                                      As someone who also prefers to release under permissive licenses: this, a million times. Big companies will always have a way to work around copylefted software, so it literally is not cutting them off from being able to do things the FSF disapproves of. Like, it’s not causing them to angrily shake their fists and yell “I would have gotten away with it, if not for you meddling Free Software kids!” It’s just causing them to use alternatives that aren’t under the FSF’s licensing regime.

                                                                                                                      Meanwhile, as the FSF gets ever more paranoid about ever more arcane “loopholes” in its licenses, the worries of small-time open-source developers go up as we juggle increasingly large transitive dependency trees that might have anything lurking in them. Not to mention whatever “loophole closure” the FSF might roll out next with brand-new extensions of what is or isn’t a derivative work.

                                                                                                              2. 9

                                                                                                                I think the NcFtp client famously changed its licence to the GPL so it could use Readline… then in 1999 or so it switched licences again. The copyright.h file included in ncftp 1.9.5 says:

                                                                                                                static char copyright[] = "@(#) Copyright (c) 1992, 1993, 1994, 1995 by NCEMRSoft and Copyright (c) 1985, 1989 Regents of the University of California.\n All rights reserved.\n";
                                                                                                                

                                                                                                                …but the comment at the top of that file says “All rights reserved” and:

                                                                                                                Redistribution and use in source and binary forms are permitted provided that: (1) source distributions retain this entire copyright notice and comment, and (2) distributions may not be sold for profit on physical media such as disks, tapes, and CD-ROMS, without expressed written permission.

                                                                                                                …which is granting some rights so clearly they’re not all reserved.

                                                                                                                Meanwhile, Wikipedia cites a Common Lisp implementation named “CLISP” as having switched to the GPL but I’m not sure what licence it switched from.

                                                                                                                As perhaps a more famous example, the Objective C system that Mac OS X used at least during the PPC era was GPL’d because back in the day NeXT wanted to use GCC as their compiler, and the FSF said they couldn’t use GCC and keep the Objective C bits proprietary. Of course, as soon as Mac OS X got serious momentum behind it, Apple poured resources into LLVM and Clang…

                                                                                                                1. 4

                                                                                                                  That is a fascinating journey, thank you for sharing!!

                                                                                                                  Wonder if there’s anything more recent? Mid-90s certainly predates my career. I feel I am more in tune with modern open source culture, also I remember reading somewhere that more permissive licenses like MIT really took off in the era of Github.

                                                                                                                2. 8

                                                                                                                  At a previous employer we wanted to use an AGPL-licensed library as part of our SaaS offering. We wrote the extensions that directly linked to it into its own microservice and licensed that as AGPL and put it on GitHub. Rest of the SaaS product stayed proprietary since calling the AGPL parts over HTTP does not trigger the AGPL. Well, the legalities on that are very unclear, since “intimate enough” on the GPL FAQ. Not sure if we did the right thing legally, and morally I’m even less sure.

                                                                                                                  Last I heard the library in question was relicensed as BSD, so the issue is moot and nobody is using the old one anymore.

                                                                                                                  1. 8

                                                                                                                    I promise you that Apple did not want to LGPL webkit, but they did really want to use KHTML in it. Google may or may not have open-sourced Blink if webkit hadn’t been copyleft, but they almost certainly wouldn’t have used a copyleft license.

                                                                                                                    1. 7

                                                                                                                      The place I work at builds tools that help other companies stay compliant with open source licenses. A lot of our bigger and most risk-averse customers (e.g. hardware manufacturers) actually take the stance that once GPL is brought into their first-party code, that code is “tainted” (i.e. you can’t make it compliant again just by removing the GPL dependency, because the commits where the GPL dependency were integrated are forever tainted by GPL and are forever in the commit history of any subsequent commits). Their default action is actually to publish “tainted” parts of their code base as open source to stay compliant - they feel that they’d rather publish some maybe-not-super-important parts of their IP rather than risk the trouble of a lawsuit.

                                                                                                                      1. 4

                                                                                                                        Place I used to work had a codebase under GPLv2 (containing lots and lots of GPLv2 source by other people), decided it would be convenient if their stuff was AGPL instead, got told “no that’s impermissible” (I can’t remember if they actually tried it out they got told no before actually trying it) and went with GPLv2 instead of making a huge mess out of it. Dunno if that’s close enough to count.

                                                                                                                        Replacing all the GPLv2 code in there would’ve cost about the company’s yearly turnover times two, prolly, so doing anything other than just complying with the license as written was a non starter.

                                                                                                                        1. 2

                                                                                                                          I know of several cases where the licensing was changed from foo to “either foo or gpl, your choice”, but I don’t think that’s what you really had in mind, right? You had in mind a change that grants users substantial additional rights?

                                                                                                                          So I agree with your intuition that the permissive licenses have achieved more, even if not quite the same.

                                                                                                                          1. 3

                                                                                                                            Right, what I had in mind is more going from “we have a proprietary/commercial license/closed source codebase” to “we open sourced it under AGPL/GPL to comply with the requirements of a dependency we just added or had all along and didn’t realize.”

                                                                                                                            1. 3

                                                                                                                              Yes, and I think that if that were a significant effect, then I would have noticed it by now.

                                                                                                                              FWIW I worked at Trolltech until 2001; the team members’ reactions to the mail we got from GNU fans from 1994 until I left weren’t in the least favourable. At the time I thought I was special, we were special, but maybe we weren’t. Maybe most people who are, uhm, educated by GNU fans react negatively to the experience.

                                                                                                                              1. 1

                                                                                                                                Curious to hear more, what kind of mail did you get? Do you mean regarding most of the stack being GPL licensed?

                                                                                                                                1. 1

                                                                                                                                  What stack being GPL? Libc and libX11 wasn’t, etc.

                                                                                                                                  GNU fans sent us a lot of mail that might be described, somewhat uncharitably, as walls of text written by people who had much spare time and little salesmanship talent. For someone who has code to write and customers to help, dealing with yet another clueless wall of text is unappealing or worse.

                                                                                                                          2. 1

                                                                                                                            I would love to see some examples where a company changed the license of their codebase to comply with a dependency.

                                                                                                                            I think this is a weird standard. Alternatively: examples where existing reciprocally licensed codebases were built upon instead of started from scratch?

                                                                                                                            • GCC and its myriad of backends including …
                                                                                                                              • Objective-C
                                                                                                                            • Linux
                                                                                                                            • Webkit / Blink
                                                                                                                            • MySQL
                                                                                                                            • Heaps of emulators
                                                                                                                            • Git
                                                                                                                            • ffmpeg
                                                                                                                            • Blender
                                                                                                                            • VLC

                                                                                                                            I feel like this is a target rich environment. What domains do you care about?

                                                                                                                            (* why is it always a company?)

                                                                                                                            1. 1

                                                                                                                              Consider it a focus group.

                                                                                                                              The viral clause affects two groups: People who want to the viral clause to bind others, and people who are bound by the clause and wouldn’t have chosen the GPL otherwise. If you want to know about the viral clause of the GPL, then it makes sense to look at the reactions of a focus group inside each group. GP’s question is a nice way to find some in the latter group.

                                                                                                                              1. 1

                                                                                                                                The viral clause

                                                                                                                                The use of “viral” makes me worry this isn’t a good faith response…

                                                                                                                                The viral clause affects two groups: People who want to the viral clause to bind others, and people who are bound by the clause and wouldn’t have chosen the GPL otherwise.

                                                                                                                                GPL code has no agency. That latter group chose to use GPL code. I see no complaints of “we pirated Oracle and now we have to pay a licensing fee” or “we pirated Oracle to get traction, and now we’re forced to rewrite.”

                                                                                                                                And I think there are more than two groups. e.g. people who specifically choose to work on the GPL projects.

                                                                                                                                1. 1

                                                                                                                                  “Viral” was common parlance when I learned about the GPL, in the early nineties. I agree that it has acquired more negative connotations since then.

                                                                                                                                  More unaffected groups don’t matter. Unless you want to argue that the pool of people who’ll work on, say, GPL’d code but not APL’d code or closed-source code is so large that it will affect companies’ strategy for theiir implementation work?

                                                                                                                                  1. 1

                                                                                                                                    I think most license selection is driven more by the authors and less by their lawyers, yes.

                                                                                                                                    P.S. https://en.wikipedia.org/wiki/Viral_license#History

                                                                                                                          1. 7

                                                                                                                            I think the coolest aspect of Emacs is that it’s its own interpreter. It’s a customizable Lisp interpreter for editing text! The power of its extensions like Org is not in not just their existence, but the fact that they could be built. You don’t really write Emacs extensions or plugins. You just write more Emacs.

                                                                                                                            1. 3

                                                                                                                              Yes, this. It is a model of how I wish more of modern computing worked; Emacs is inspectable right down to the primitives, without having to exit Emacs.