Threads for xyproto

  1. 14
    • 3D printing a flipflop
    1. 4

      This is a great goal! But just one?

      1. 2

        Could just be a portrait of the moment a politician flip-flopped? :)

        1. 2

          What else do you do when you find one?

          1. 2

            Just one, and if successful, the other…

            1.  

              I believe in you! Please post photos of the maiden flight.

          2. 2

            JK, SR, or D?

          1. 1
            • Water plants.
            • Polish my little editor/IDE named just o.
            • Try to reach the rank of 2k in the game of Go, at the KGS server.
            • Plan the summer vacation.
            • Update some Arch Linux packages once archlinux-keyring sees a new release.
            • Take the kids to the beach to swim in the ocean, and then play some Mario Kart.
            • Finally start reading the “Artificial Intelligence in Finance” and “Linux device drivers” books I have on my desk.
            • Make a track on the Octatrack, using only self made samples.
            • Do one hangup.
            • Work.
            1.  
            1. 6

              There are multiple points here I disagree with:

              1. Go’s and Zig’s defer are rather different beasts Go runs defered statements at the end of the function, Zig at the end of scope. ant to lock a mutex insife a loop? Can’t use Go defer for that..
              2. destructors can’t take arguments or return values While most destructions only release acquired resources, passing an argument to a defered call can be very useful in many cases
              3. hidden code all defer code is visible in the scope. Look for all lines starting with defer in the current scope and you have all the calls. Looking for destructors means looking how drop is implemented for all the types in the scopes.
              1. 11

                Go’s and Zig’s defer are rather different beasts Go runs defered statements at the end of the function, Zig at the end of scope. ant to lock a mutex insife a loop? Can’t use Go defer for that..

                This distinction doesn’t really matter in a language with first-class lambdas. If you want to unlock a mutex at the end of a loop iteration with Go, create and call a lambda in the loop that uses defer internally.

                destructors can’t take arguments or return values

                But constructors can. If you implement a Defer class to use RAII, it takes a lambda in the constructor and calls it in the destructor.

                hidden code all defer code is visible in the scope

                I’m not sure I buy that argument, given that the code in defer is almost always calling another function. The code inside the constructor for the object whose cleanup you are defering is also not visible in the calling function.

                1. 4

                  hidden code all defer code is visible in the scope

                  I’m not sure I buy that argument, given that the code in defer is almost always calling another function. The code inside the constructor for the object whose cleanup you are defering is also not visible in the calling function.

                  The point is that as a reader of zig, you can look at the function and see all the code which can be executed. You can see the call and breakpoint that line. As a reader of c++, it’s a bit more convoluted to breakpoint on destructors.

                  1. 2

                    you can look at the function and see all the code which can be executed.

                    As someone that works daily with several hundred lines functions, that sounds like a con way more than a pro.

                  2. 1

                    But constructors can.

                    This can work sometimes, but other times packing pointers in a struct just so you can drop it later is wasteful. This happens a lot with for example the Vulkan API where a lot of the vkDestroy* functions take multiple arguments. I’m a big fan of RAII but it’s not strictly better.

                    1. 1

                      At least in C++, most of this all goes away after inlining. First the constructor and destructor are both inlined in the enclosing scope. This turns the capture of the arguments in the constructor into local assignments in a structure in the current stack frame. Then scalar replacement of aggregates runs and splits the structure into individual allocas in the first phase and then into SSA values in the second. At this point, the ‘captured’ values are just propagated directly into the code from the destructor.

                    2. 1

                      If you want to unlock a mutex at the end of a loop iteration with Go, create and call a lambda in the loop that uses defer internally.

                      Note that Go uses function scope for defer. So this will actually acquire locks slowly then release them all at the end of function. This is very likely not what you want and can even risk deadlocks.

                      1. 1

                        Is a lambda not a function in Go? I wouldn’t expect defer in a lambda to release the lock at the end of the enclosing scope, because what happens if the lambda outlives the function?

                        1. 1

                          Sorry, I misread what you said. I was thinking defer func() { ... }() not func() { defer ... }().

                          1. 2

                            Sorry, I should have put some code - it’s much clearer what I meant from your post.

                    3. 5

                      The first point is minor, and not really changing the overall picture of leaking by default.

                      Destruction with arguments is sometimes useful indeed, but there are workarounds. Sometimes you can take arguments when constructing the object. In the worst case you can require an explicit function call to drop with arguments (just like defer does), but still use the default drop to either catch bugs (log or panic when the right drop has been forgotten) or provide a sensible default, e.g. delete a temporary file if temp_file.keep() hasn’t been called.

                      Automatic drop code is indeed implicit and can’t be grepped for, but you have to consider the trade-off: a forgotten defer is also invisible and can’t be grepped for either. This is the change in default: by default there may be drop code you may not be aware of, instead of by default there may be a leak you may not be aware of.

                      1. 3

                        destructors can’t take arguments or return values. While most destructions only release acquired resources, passing an argument to a deferred call can be very useful in many cases.

                        Yes, more than useful:

                        • Zero-cost abstraction in terms of state: A deferred call doesn’t artificially require objects to contain all state needed by their destructors. State is generally bad, especially references, and especially long lived objects that secretly know about each other.
                        • Dependencies are better when they are explicit: If one function needs to run before another, letting it show (in terms of what arguments they require) is a good thing: It makes wrong code look wrong (yes, destruction order is a common problem in C++) and prevents it from compiling if you have lifetimes like Rust.
                        • Expressiveness: In the harsh reality we live in, destructors can fail.

                        I think the right solution is explicit destructors: Instead of the compiler inserting invisible destructor calls, the compiler fails if you don’t. This would be a natural extension to an explicit language like C – it would only add safety. Not only that: It fits well with defer too – syntactic sugar doesn’t matter, because it just solves the «wrong default» problem. But more than anything, I think it would shine in a language with lifetimes, like Rust, where long lived references are precisely what you don’t want to mess with.

                        1. 2

                          You could run an anonymous function within a loop in Go, just to get the per-loop defer. Returning a value in a defer is also possible.

                          func main() (retval int) {
                              for {
                                  func() {
                                      // do stuff per loop
                                      defer func() {
                                          // per loop cleanup
                                      }()
                                  }()
                              }
                              defer func() {
                                  retval = 42
                              }()
                              return
                          }
                          
                        1. 7

                          When I first started building i_solated, I never could have predicted this current situation. This experience is a reminder that proprietary things come and go. I have already started the long journey towards future-proofing projects that I work on.

                          To me, this is one of the best arguments for open source software.

                          1. 4

                            I agree, but the claim that the author never could have predicted the current situation is … come on! What did you think was going to happen? This was the most obvious outcome from the very start.

                            1. 2

                              Maybe not Free Software that is tied to a specific platform, but it definitely is an argument towards Free libraries and development kits. That’s why projects that I make are always GPL for applications and LGPL for libraries (with the occasional BSD where the platform does not allow for replacing parts of the program i.e. JS bundlers).

                              1. 1

                                What was the open source equivalent of Flash in its heyday and why didn’t it catch on?

                                1. 1

                                  Java applets was an alternative, but they were heavy and slow to load and cumbersome to write.

                                  SMILE / SVG flopped for the same uses as Flash.

                                2. 1

                                  Open source is no guarantee either. How many projects depend on abandoned libraries, let alone ecosystems? Good luck getting say, XMMS to build today.

                                  1. 1

                                    A very niche use-case I’ve been getting into is ripping local subtitles off DVDs that I upgraded to BD/UHD, which usually have English subtitles only.

                                    Everything I could find, starting with an old enough version of Avidemux, which hadn’t dropped support for ripping subtitles, was completely unbuildable.

                                    Solution: use Windows software in Wine and work from there.

                                    Open-source lost this one, but maybe the use-case simply is so niche no-one wants to maintain the packages.

                                    1. 1

                                      That is true, but there is little interest in XMMS1, since there are such a wealth of good alternatives.

                                      Open source software that there is interest in keeping alive is pretty much guaranteed to live on for as long as there is interest.

                                      At the height of the Flash player popularity, if there had been an open source version of it, it would maybe not have died as abruptly as it did.

                                  1. 2

                                    Yawn another sans-serif.

                                    Sure, Go Mono is the one true serif monospaced typeface, but it would be nice to see some competition.

                                    1. 3

                                      I’ve used and liked Verily Serif Mono as well

                                      1. 2

                                        The Triplicate font by Matthew Butterick is both monospace and a true serif.

                                        1. 2

                                          JetBrains Mono NL is an excellent alternative.

                                        1. 15

                                          I personally think it’s sheer madness to create a new language with a C compiler already built into it… but I have to admit it seems to be working out decently for Zig in practice.

                                          1. 21

                                            Even if Zig-the-Language never makes it big, Zig-the-Toolchain is already providing an immense amount of value.

                                            1. 14

                                              Zig-the-Language is also better at using C libraries than C is.

                                              1. 3

                                                It’s safer, but it’s unclear if total developer productivity is higher than in C, depending on how you measure it.

                                              2. 13

                                                Seriously, it’s the cross-compile toolchain that should have existed for decades.

                                              3. 1

                                                It solves a problem of getting from here to there. We have a big C world. Trying to replace it results in xkcd standards. Embracing it, however, lowers the barrier to entry. When the tooling is as good and easy to use and build as Zig’s, that barrier to entry gets low enough to give the language a fighting chance.

                                              1. 2

                                                Learning Davinci Resolve and participating in the Jamuary 2022 challenge of the week.

                                                  1. 6

                                                    Just have to look at the thing and it says PC LOAD LETTER

                                                    1. 3

                                                      what the fuck does that mean?

                                                        1. 1

                                                          My best guess is that it’s a printer meant to be used with PC’s, and it also wants you to insert paper of the “Letter” size.

                                                          1. 7

                                                            “Load letter size paper into the paper cassette (PC)”

                                                            1. 1

                                                              Ah right, makes sense.

                                                    1. 4

                                                      I wonder if we won’t be seeing more of this. I feel like the whole systemd debacle but perhaps more importantly the philosophical, financial and organizational changes that caused it speak to a real problem in Linux-space where a small number of large-ish companies are determining the future of the platform based on their best interests that may not actually intersect with those of the community.

                                                      Like, systemd actually DOES seem to bring some value to the desktop, but to the server? The value it brings is much less clear, and the harm it causes by violating decades old interface contracts is non trivial.

                                                      1. 16

                                                        Like, systemd actually DOES seem to bring some value to the desktop, but to the server? The value it brings is much less clear, and the harm it causes by violating decades old interface contracts is non trivial.

                                                        The decades old interfaces were a crufty hack put together by grad students. All the commercial unix variants ditched it long ago. Yes, BSD’s user space is stable, but it’s also awful. It was awful in the 1990’s when I started in on Linux and BSD, and it’s awful today.

                                                        I only use Linux on servers these days, and I love systemd. If I never have to write another SysV init script again, I will be a happier person. Add things like eBPF? And finally we’re getting btrfs on root with SuSE and getting some of the nice stuff that Solaris had (snapshot before upgrade for trivial rollback). It’s not traditional BSD, and it’s better.

                                                        1. 5

                                                          systemd is the main thing I’m missing on FreeBSD. BSD rc is an improvement over System V init, but not by much.

                                                          1. 3

                                                            Comparing Linux style SysV init to systemd I get your point, but that’s not how rc.d typically works on a modern BSD.

                                                            Take Consul on OpenBSD for example.

                                                            It mainly contains:

                                                            #!/bin/ksh
                                                            daemon="/usr/bin/consul agent"
                                                            daemon_flags="-config-dir /etc/consul.d"
                                                            daemon_user="_consul"
                                                            
                                                            . /etc/rc.d/rc.subr
                                                            
                                                            rc_bg=YES
                                                            rc_stop_signal=INT
                                                            
                                                            rc_cmd $1
                                                            
                                                            

                                                            Then I can add consul_flags="whatever" in /etc/rc.local which describes all my services, what runs and how it is configured. I can add comments, etc.

                                                            The equivalent in systemd, after removing everything not needed:

                                                            [Unit]
                                                            Requires=network-online.target
                                                            After=network-online.target
                                                            
                                                            [Service]
                                                            ExecStart=/usr/local/sbin/consul agent $OPTIONS -config-dir=/etc/consul.d
                                                            ExecReload=/bin/kill -HUP $MAINPID
                                                            KillSignal=SIGINT
                                                            
                                                            [Install]
                                                            WantedBy=multi-user.target
                                                            

                                                            And harder to just change some flags and get an overview about how the system is configured.

                                                            FreeBSD also has daemon which is a simple tool that takes care of everything you might need for running a daemon. Logging, automatic restarts, managing subproceses, chaining user, forking into background, creating a pid file.

                                                            I don’t disagree that systemd is better than what many distributions had before. It’s actually a reason of why I got interested in the BSDs. Some systems, like Gentoo or Arch Linux in the past did a better job as well. Especially Gentoo’s OpenRC (also used by some others) comes pretty close to a perfect init in my opinion.

                                                            Sorry, I don’t wanna talk about systemd or init systems. There is enough about that elsewhere, but the notion that things on the BSDs are as bad as they were on SysV init based Linux distributions is simply wrong.

                                                            About eBPF. dtrace is there and has great integration from Python to Postgres. And btrfs feels like a never ending story and I think even on Linux it’s largely obsoleted by ZFS which just like dtrace has been used in production in very large setups for many years.

                                                            See, that’s the thing with Linux though. Things tend to be considered obsolete when they finally manage to stabilize. See Pulseaudio and Primusrun. I don’t think that’s necessarily bad. In fact it’s good that bad stuff gets replaced, but often it’s not about the better option but the newer one it seems and RedHat certainly has interest in pushing their products.

                                                            And then you have to hire huge DevOps/SRE-Teams just to keep things compatible with whatever is still supported. Of course that leads to the idea that you need to be able to pull things off Dockerhub and don’t actually manage the system, but outsource things to EKS or GKE.

                                                            And I say that as someone whose main source income is consulting helping companies with DevOps related issues, Docker, Kubernetes, etc. It’s a mess, which is why companies throw large sums of money at people like us blowing out the fires.

                                                            Whatever it is, being the “cool new thing” managers read in their magazines and “Google uses it” will always win. There’s no shortage of work in the industry if you jump on what’s hot. ;)

                                                            1. 2

                                                              And harder to just change some flags and get an overview about how the system is configured.

                                                              “systemctl edit consul” and listing .override files should be the equivalent in systemd world.

                                                              1. 1

                                                                Which I would is more involved than having a central config file often with additional specific options. Not by much, but having an rc.conf often with not just flags, but actually specifying listen address or in case of network adapter even which device is configured how is certainly nicer than doing the same in systemd. Saying that as someone who does both at a semi-daily basis.

                                                                It’s because at one point I feel more as a user and on the other more as a the designer. I think it scales very well with how involved the service is compared, to Unit files, where I have to know both how the service works and how Unit Files work.

                                                                Listing override files to get an overview of a system isn’t exactly a nice workflow in my opinion. I feel spoiled when I have things groups, commented, etc. It’s a bit of that terraform feel where in a well written config you see everything grouped together at first glance, have useful comments where necessary.

                                                                Anyways, that’s not even what I tried to argue about. I just wanted to support the statement that the BSDs rc.d isn’t Linux SysV init. And while I understand people have different tastes, switching to BSD isn’t going to bring that back nor is using one of the many other options out there bringing that back. I know my way around with systemd (and the slur of related tools and services), since I have to work with it on a daily basis, because it’s currently the dominant init system, yet I still wished something like OpenRC would be adapted more widely. Aside from some small distributions with Alpine and Gentoo there seem to be two more widely used ones, for which it appears to works just fine.

                                                            2. 3

                                                              Glad you’re happy with systemd.

                                                              The issue here is not the change, but an unwillingness to actually COMMUNICATE that change so sysadmins managing production systems in the field have to find out the hard way that their expectations have not been met.

                                                              This is most emphatically NOT the way to develop a very complex software stack.

                                                              1. 6

                                                                What type of communication, and from whom, would be good enough?

                                                                Does this count? https://github.com/systemd/systemd/blob/main/NEWS

                                                                1. 5

                                                                  I’m looking forward to the communication SysV init has. Oh wait, it doesn’t and every distribution was just doing its own thing?

                                                                  1. 1

                                                                    Honestly? No.

                                                                    As a UNIX administrator I expect man pages to document the interfaces necessary to operate the system.

                                                                    1. 3

                                                                      What’s lacking in the systemd man pages?

                                                                      https://man7.org/linux/man-pages/man1/systemd.1.html

                                                                  2. 5

                                                                    Can you provide examples of what you feel was not communicated? I’m not sure I understand the complaint.

                                                                    1. 1

                                                                      When I want to change some detail around DNS resolution, I go to modify /etc/resolv.conf, but that’s not actually the correct mechanism anymore, but I can’t find what the right mechanism IS in the man pages or anywhere else I know to look.

                                                                      1. 3

                                                                        And in which man page do you spot that /etc/resolv.conf was the right place to look, apart from the man page for resolv.conf?

                                                                        Discovering /etc/resolv.conf is not the most intuitive thing in the world either.

                                                                        1. 2

                                                                          There are two important issues in good UI design (okay, more, but two that are relevant here):

                                                                          • Discoverability
                                                                          • Consistency

                                                                          *NIX systems are typically terrible at the first of these. FreeBSD isn’t actually too bad in the first order here because you can add nameservers by running bsdconfig and going to the network settings part. This isn’t great though because it doesn’t tell you what it’s editing and so the only thing that you learn is that you can edit the settings via that UI, not what the underlying service is. RedHat has a similar tool whose name I’ve forgotten. I don’t know what the Debian / Ubuntu equivalent is but I assume there is one.

                                                                          I learned about resolv.conf on Linux around 2000. For consistency, I’d expect to go and edit it today. Trying this on a FreeBSD and Ubuntu system, I learn quite similar things: it’s not the right thing to do anymore. Both then do well on discoverability: On Ubuntu, it tells me that the file was created by systemd-resolved, on FreeBSD is tells me that it was created by resolvconf. In both cases, I can go to the relevant man page and find out what the new thing is. Whether I prefer systemd-resolved or resolvconf is largely a matter of personal preference (I do enjoy the fact that there’s now a file, complete with man page, on FreeBSD called resolvconf.conf, because what problem isn’t made better by adding an extra layer of indirection?).

                                                                          1. 1

                                                                            Can we please stop this back and forth? I realize I was being un-necessarily incendiary by using the word ‘debacle’ and if you contribute to the systemd project and I hurt your feeling I sincerely apologize.

                                                                    2. 3

                                                                      If I never have to write another SysV init script again, I will be a happier person

                                                                      Were you writing these yourself before? Serious question: why?

                                                                      1. 14

                                                                        Because I wrote daemons and they had to have init scripts.

                                                                  1. 7

                                                                    Docker images has become like an executable format for Linux server applications.

                                                                    Not being able to support docker images is comparable to not being able to support ELF executables, IMO.

                                                                    1. 2

                                                                      Relying on dockerhub images is a major security risk. You don’t receive any message whenever the image author stop updating their image. I am sad however how i can’t use docker images built by nix on freebsd.

                                                                      1. 2

                                                                        …Or just use Nix without Docker. Except I don’t think Nix runs on BSDs either (expect if you count nix-darwin)

                                                                        1. 1

                                                                          “except”?

                                                                        2. 1

                                                                          You are right. Outdated docker images from docker hub can be a problem. However, there are tools available that scan docker images for security issues. Google Cloud uses this, for instance.

                                                                        3. 2

                                                                          Sorry, but that’s just pure marketing talk, especially at times where Kubernetes and others move away from Docker

                                                                          Aside from that you can run Docker (and Kubernetes btw.) on FreeBSD.

                                                                          I heard the ELF comparison before but for any technical purpose it’s simply wrong/marketing talk.

                                                                          Oh and I have to admit that I actually said something similar before and I’m ashamed for it.

                                                                          I think the thing coming closest is the Dockerfile (and alike) being a way of executing software that is somewhat dominant. It feels a bit like the procfile that came slightly before, but it’s easy more associated with Docker, Docker images, etc. than what matters for actual real life production setups. It’s part of why do many “docker clones” exist out there allowing devs to write Dockerfiles even though no Docker runs when the instructions are executed.

                                                                          Yes, Docker did a great job defining an interface between who writes software and who executes it where the great part is simply that it’s not too complex and that it got popular. So that’s why people like to compare it with ELF.

                                                                          But that’s really the. Dockerfile as well as the fact that certain ways for configuration are used/preferred, that huge installation processes were simplified and that there is no random state holding directories anymore.

                                                                          Parts of this also became necessary for cloud computing taking over and hard boundaries were defined for software making deployment a lot easier.

                                                                          But that doesn’t just work when executing on the could or actually using Docker.

                                                                          1. 5

                                                                            Sorry, but that’s just pure marketing talk, especially at times where Kubernetes and others move away from Docker

                                                                            This is true, but misleading. Docker (Moby) is finishing a transition to be built on top of the OCI stack. Docker is a tool that uses containerd to build OCI containers. Kubernetes is a tool for managing containerd instances and using them to run OCI containers.

                                                                            Aside from that you can run Docker (and Kubernetes btw.) on FreeBSD.

                                                                            Kind of. You can run containerd and it can use runj to manage jails for deployment, but runj is still alpha quality code. It’s easy to get into a situation where it can’t shut down a jail. You can also build Moby for FreeBSD, but it can also wedge in the same way and require a reboot to clean up the stale state.

                                                                            1. 1

                                                                              According to https://wiki.freebsd.org/Docker, this is the current status of Docker on FreeBSD:

                                                                              Docker’s currently broken. We are working on a current, executable version. Help is welcome. Current status: https://reviews.freebsd.org/D21570

                                                                          1. 5

                                                                            Once you’re willing to accept a global GC, you open up a much larger space of languages that you might use. .NET languages can be AOT compiled and statically linked with Mono (not sure what the status of this is in the MS implementations, it seems to come and go), Go supports only statically linking.

                                                                            If you are happy with lower performance then embedded Lua or JavaScript implementations exist and with something like Sol3 it’s easy to expose a few performance-critical bits from C++ and write the application logic in Lua.

                                                                            I had a look at D a while ago and it seems like it’s a better C++ than C++98 but it wasn’t clear that it was a better C++ than C++11.

                                                                            1. 3

                                                                              I’ve used C++ professionally six years and D six too (have known both for the last 12 years..) and there is no contest, D is much simpler, more effective, and has much lower mental friction. I’m struggling to think about the kind of projects where I’d use C++, perhaps with some exotic hardware.

                                                                              1. 2

                                                                                I think that’s the kind of dichotomy that I have a problem with for D. If I’m in a scenario where I need to be able to escape from the type system and write low-level code, for example writing a memory allocator, a scheduler, or a language runtime, I definitely don’t want a language with a global GC. If I don’t have these constraints, I have the option of languages like TypeScript, F# / C#, Go, Lua, and so on. From what I’ve read about D, I don’t think I’d be more productive in D than in TypeScript or C# (especially factoring in the ecosystems of those languages).

                                                                                1. 2

                                                                                  Well if you don’t need native, then of course you have more choices. In my field, it’s all native languages.

                                                                                  If I’m in a scenario where I need to be able to escape from the type system and write low-level code, for example writing a memory allocator, a scheduler, or a language runtime

                                                                                  D can do all of those.

                                                                              2. 2

                                                                                there is also AoT compilation for java

                                                                                1. 1

                                                                                  Both gccgo and the Go compiler from Google supports dynamic linking, and several other build modes:

                                                                                  go build -buildmode=pie
                                                                                  
                                                                                1. 2

                                                                                  This looks useful!

                                                                                  1. 5

                                                                                    This has inspired me to give it a try. I learned Go last year, it’s a great language but some aspects of it are less than ideal for some use cases I have in mind (large binary size being one), and CGO is horribly slow.

                                                                                    Zig/rust have their own issues. And drew++ (whatever ddevault’s thing is called) is nowhere to be seen yet… so D seems like it might scratch some itches for me.

                                                                                    edit: I guess D is statically linked too, like Go. So I guess there’s less of a benefit for me using it.

                                                                                    1. 4

                                                                                      I’ve played with Jonathan Blow’s new programming language and that looks very good also. Walter Bright had some good remarks about it at one point.

                                                                                      It has very good compile speed and resulting binary size (higher than zig, but way lower than Go) and it has first class introspection mechanisms that don’t introduce too much of an overhead.

                                                                                      It’s paradigm is not very OOP friendly, but it feels pretty close to Go in ease of writing ease and understandability.

                                                                                      1. 3

                                                                                        edit: I guess D is statically linked too, like Go. So I guess there’s less of a benefit for me using it.

                                                                                        Well, it depends how you do your build. The default is static D parts for convenience but you can also do dynamic link builds, especially with ldc nowadays, even the runtime as a dll works on Windows now (it was buggy for ages, finally fixed in 2021!)

                                                                                        1. 1

                                                                                          Both C and Go are not statically linked when compiling with gcc and gccgo, respectively.

                                                                                          Go is statically linked by default when compiling with the go compiler, but it’s just the default setting.

                                                                                        1. 3

                                                                                          Thank you! But also

                                                                                          (setq backup-by-copying t)
                                                                                          (setq sentence-end-double-space nil)
                                                                                          (global-set-key [(control h)] 'delete-backward-char)
                                                                                          (keyboard-translate ?\C-h ?\C-?)
                                                                                          
                                                                                          1. 2

                                                                                            I feel like I’m the only person who has sentence-end-double-space set to t — I like it because it allows me to easily navigate sentences, and it doesn’t matter because when I export the document to another format the spaces get properly minimized.

                                                                                            1. 7

                                                                                              Hi acdw!♥

                                                                                              I felt like setting it to nil (which I didn’t realize until after a few years) unlocked super powers of Emacs I had only dreamt of before, M-a, M-k, transposing sentences etc, even in text I didn’t originally author, and it does a really good job.

                                                                                              Also, with this set to nil, it works with one or two spaces; with it set to t it can’t find sentence boundaries if there’s only one space. I can’t believe that’s the default.

                                                                                              1. 2

                                                                                                Hi there :) Nice to see you on lobsters!

                                                                                                Oh my god, you’ve actually convinced me to turn sentence-end-double-space to nil … I honestly did not realize that it’s telling Emacs to recognize single-spaced sentences, which honestly makes so much sense.

                                                                                                I think the only place I want to set it is when filling paragraphs, so it fills the “proper” (to my eyes anyway) two-spaced sentences, which of course I can just add some advice to to fix. Thanks for the mind-changer, snan!

                                                                                                1. 1

                                                                                                  PS. I’ve made a small dumb package to correctly fill even with sentence-end-double-space set to nil:

                                                                                                  https://github.com/duckwork/fill-sentences-correctly.el

                                                                                                  I hope it’s okay I quoted you.

                                                                                                  1. 2

                                                                                                    🧕 I wouldn’t exactly call it “correctly” since I favor the single spaced style. I don’t mind the quotes ofc.

                                                                                                    1. 1

                                                                                                      hahahahah I’ll make sure to mention you’re not in favor :P

                                                                                                    2. 2

                                                                                                      So if you can make it clear that I’m not an advocate for double-spacing, that’d be great ♥

                                                                                                  2. 4

                                                                                                    Can not sentences be recognized without double space? If some text starts with a capital letter and ends with punctuation followed by a space or the end of the line, then that should do the job, right?

                                                                                                    1. 8

                                                                                                      Dr. Spock might want to have a word with you. Mr. Smith might also chime in.

                                                                                                      1. 1

                                                                                                        In all seriousness, I’ve never heard about them. Is this something local to the US?

                                                                                                        1. 2

                                                                                                          I was giving an example of a sentence that would be mis-parsed by assuming all sentances end with a period followed by a single space.

                                                                                                          As for the names, Dr. Spock was a rather famous medical doctor in the U.S. and wrote a popular book about having babies (I think in the 60s?). There was also a character on a science fiction TV show (Star Trek) where there was a character named “Spock.” As for Mr. Smith, the last name “Smith” is one of the most popular (if not the most popular) last name in the English speaking world.

                                                                                                          1. 2

                                                                                                            Yes, it’s an US thing. They even use period as a decimal marker (!).

                                                                                                            1. 1

                                                                                                              That’s crazy talk right there!

                                                                                                        2. 4

                                                                                                          Yeah. Setting it to nil, it can recognize sentences either way. Leaving it in t means it only recognizes double spaces.

                                                                                                        3. 2

                                                                                                          I’d be a lot more likely to enable this if everyone else had it enabled, but when I’m working on documentation it’s more important for my style to match the project itself than for me to have it work the way I like personally.

                                                                                                          1. 1

                                                                                                            I think I was able to get away with it because I generally only write for myself, but you’re right that most people are single-spacers. grumble :P

                                                                                                          2. 2

                                                                                                            You’re not. Even vi does it. ;)

                                                                                                          3. 2

                                                                                                            Disabling the help shortcuts seems like a real bad idea to me?

                                                                                                            1. 1

                                                                                                              F1 ftw!

                                                                                                              Having a homerow key combo that’s delete-backwards-char in almost any other app split the window and pop up help stuff is pretty cumbersome. I do F1 m, F1 k, F1 f all the time. Pretty great.

                                                                                                              1. 2

                                                                                                                Hm; I guess if I didn’t have a keyboard that put backspace on the thumbs that’d be more appealing. I use C-M-h a lot more than backspace in Emacs tho.

                                                                                                                1. 3

                                                                                                                  You made my keyboard ♥

                                                                                                                  But

                                                                                                                  1. I hate using my thumbs (other than space) so I didn’t put any important keys there.
                                                                                                                  2. It’s also not just about adding access to backspace but about decreasing the “minefield factor” of having a help popup.
                                                                                                                  3. On the Atreus specifically, I have a layer switcher in the outer lower corners, which + h sends literal backspace so I don’t need change in my .emacs anymore. + works in other apps too.
                                                                                                                  1. 1

                                                                                                                    I have a layer switcher in the outer lower corners, which + h sends literal backspace so I don’t need change in my .emacs anymore. + works in other apps too.

                                                                                                                    I have a similar thing but in my WM instead; if I press C-i or C-m it will send a tab or enter character in any program, even outside Emacs. Indispensible!

                                                                                                                    1. 1

                                                                                                                      I have i, m, h, j, f, n, p, b, v etc but because it’s on a layer switch I can send actual C-i when I need to (for example invert selection in some drawing apps). ♥

                                                                                                          1. 4

                                                                                                            It’s a useful tool, but the whole parallel --citation business is a pain. Arch Linux disables this, but not Fedora (last time I checked). https://github.com/archlinux/svntogit-community/tree/packages/parallel/trunk

                                                                                                            1. 5

                                                                                                              Yay, I’ve been using this branch for months to get the Wayland scaling and I’ve had zero problems.

                                                                                                              1. 7

                                                                                                                I think that Wayland support is so important that they should cut ASAP Emacs 29 just for it, but probably we’ll have to wait a couple more years for a “stable” release.

                                                                                                                1. 3

                                                                                                                  Curious what your use case for Wayland is?

                                                                                                                  1. 21

                                                                                                                    I am a Wayland user with a boring desktop use case. I like the:

                                                                                                                    • Fractional DPI scaling (I have a 27” 4K monitor that I like to have somewhere between 1.25x and 1.5x)
                                                                                                                    • Handling of multiple monitors (I have monitors with different desired DPIs and refresh rates)
                                                                                                                    • Lack of screen tearing even with the aforementioned refresh rate mismatch (X11 multihead gives you a single Screen with numerous Displays that view the screen, so you can’t really do VSync with mismatched refresh rates that aren’t simple multiples of each other)
                                                                                                                    • (What feels like?) lower latency: Compositors on X seem to do a lot of copies but Wayland applications seem to have a culture of dmabuf and it seems to make my experience of wayland much snappier when compared to X11 with compton/picom or something.
                                                                                                                    1. 2

                                                                                                                      I feel that last point. When using X11, it feels like I have a choice between no compositor (and the lack of features and slightly buggy rendering that entails) and compton (with the very bad performance that entails). Workspace switching with i3 would make the every OpenGL window look initially blank before it pops in half a second later when using compton.

                                                                                                                      Sway, on the other hand, Just Works.

                                                                                                                      Everything else on that list is important too of course.

                                                                                                                      1. 3

                                                                                                                        Curious: what specific features do you like about the compositors? I’ve personally found them completely useless.

                                                                                                                        1. 2

                                                                                                                          I don’t remember 100% since it’s a long time ago, but IIRC, a compositor was necessary for reducing screen tearing, and parts of the screen would sometimes fail to update properly without a compositor.

                                                                                                                          1. 2

                                                                                                                            Screen tearing is easier to avoid with a compositor (nothing to do) than without. And in my case, true transparency (this helps me to check if a window is focused, but also for eye candy).

                                                                                                                            1. 1

                                                                                                                              Even if you don’t care about shiny stuff like shadows, you don’t need damage.

                                                                                                                          2. 2

                                                                                                                            X can do all those things too, except maybe the refresh rate thing though, I’m not sure about that. It is a pity that applications are just rewriting in Wayland instead of fixing their bugs on X and maintaining full compatibility.

                                                                                                                            1. 5

                                                                                                                              X11 can’t really avoid screen tearing. There are lots of different hacks which each somewhat reduce tearing in certain situations, but I’ve yet to see an X11 system which doesn’t have at least some screen tearing in at least some circumstances – while I’ve yet to see a Wayland system with screen tearing issues.

                                                                                                                              Fractional scaling on X11 is a hack which partially works sometimes but doesn’t work perfectly.

                                                                                                                              We’re long overdue for an X11 replacement. We’ve been adding hacks upon hacks upon hacks for far too long, and the fundamental limitations are really starting to show. It’s not enough to “just fix application bugs on X”. Screen tearing by itself is enough reason to throw X11 in the garbage and start fresh with something that’s actually reasonably well designed.

                                                                                                                              1. 1

                                                                                                                                As far as I understand, X cannot have different fractional scaling factors for different monitors, while Wayland can. It’s the main motivation for me to use Wayland, given I have a 1440p 25’ and 2160p 27’.

                                                                                                                              2. 1

                                                                                                                                I was always curious about fractional scaling. I thought that Wayland didn’t handle it (see https://gitlab.freedesktop.org/wayland/wayland-protocols/-/issues/47). From my understanding, you are rendering at 2x, then downscaling. If you happen to have two monitors, this can be a lot of pixels to render.

                                                                                                                                1. 1

                                                                                                                                  From my understanding, you are rendering at 2x, then downscaling.

                                                                                                                                  This is how macOS does it, IIRC.

                                                                                                                                  1. 1

                                                                                                                                    I think there are non-mainline GDK protocols for it. At least all the non-XWayland applications I use look perfectly crisp

                                                                                                                                2. 12

                                                                                                                                  For me personally, I use Wayland because it’s the only thing supported on my hardware (MNT Reform).

                                                                                                                                  The only thing I use it for is to run XWayland so I can immediately launch Emacs and exwm, and then I run Firefox inside that.

                                                                                                                                  At first glance it appears slower than using Wayland directly, but that’s only before you factor in the time you have to spend retrieving your laptop because you threw it out the window in rage because Firefox’s keybindings (when running outside exwm) are so bad and holding down C-n opened seventeen windows again instead of scrolling down.

                                                                                                                                  1. 1

                                                                                                                                    Doesn’t Firefox run directly with Wayland now?

                                                                                                                                    1. 1

                                                                                                                                      Probably, but if you run Firefox outside exwm there’s no way to fix the key bindings. The Firefox extension mechanism bans rebinding C-n and C-p for “security reasons”, making it completely unusable for me.

                                                                                                                                      1. 1

                                                                                                                                        Supposedly it does https://twitter.com/omgubuntu/status/1379818974532280321?s=20, but I guess exwm doesn’t.

                                                                                                                                        1. 1

                                                                                                                                          Yeah. I guess exwm is the problem and not Firefox.

                                                                                                                                          1. 2

                                                                                                                                            No, the problem is that Firefox doesn’t allow the user to change some keybindings, like C-n. EXWM is the solution to that problem.

                                                                                                                                            1. 1

                                                                                                                                              It’s exactly this.

                                                                                                                                        2. 1

                                                                                                                                          For a while now already. Gotta define the MOZ_ENABLE_WAYLAND=1 env variable and it will start in Wayland mode. Have been doing this for 2(?) years now on Sway without issue. (Maybe the env thing is a thing of the past…)

                                                                                                                                          1. 2

                                                                                                                                            Sway + Firefox here as well. MOZ_ENABLE_WAYLAND=1 is no longer needed. Rejoice!

                                                                                                                                      2. 8

                                                                                                                                        I’m surprised by your question. My (perhaps naive?) understanding is that the Xorg maintainers decided years ago that they don’t like the X protocol anymore for modern graphics stacks, that the stuff that was added on top of it is painful to design/implement/maintain, and that they wanted to start with something fresh with a more solid design. Wayland, as I understand it, this is “something fresh with a more solid design” (but its own protocols are still evolving and probably imperfect, as everything is.)

                                                                                                                                        With this understanding, if I have the choice to use both (that is, I’m not depending on worklows that are not supported on Wayland for fundamental reason (no support for easy forwarding) or due to lack of maturity), it seems natural to use Wayland. I want to use the new stuff that is the future and benefits from a growing userbase to mature (and benefit more users that currently have fewer options), and not the old stuff that keeps working but people dread maintaining.

                                                                                                                                        So: my use case is “moving to the new software stack that was designed from the start to be a better, more robust successor than the old software stack”.

                                                                                                                                        1. 6

                                                                                                                                          From my PoV Wayland is still in “second system redesign” territory like the early days of PulseAudio. Some people find it useful, some people like to help test the bleeding edge, but it’s not the default in anything I set up and since I’ve never had any issues with X I don’t currently go through the extra work to set it up. The only time I’ve worked with Wayland was to help my mom switch her computer back to X because some app was misbehaving under her Wayland setup.

                                                                                                                                          But if it’s working for you, that’s great of course. Just providing my PoV so hopefully my question is less surprising now.

                                                                                                                                          1. 3

                                                                                                                                            There is always a bias towards “not fixing what aint broken” so once you know a tool you’re likely to stick to it.

                                                                                                                                            That being said I don’t think wayland represents enough progress to consider it a successor to X, it’s a competitor for sure but I think by the time I move off X it won’t be to wayland.

                                                                                                                                            1. 5

                                                                                                                                              With most Linux distros gradually switching to Wayland and Windows adopting it as well for WSL, I think it’s fairly certain that Wayland is going to (mostly) replace X in the next 3-5 years. I doubt some other alternative will emerge before the transition to Wayland is complete.

                                                                                                                                        2. 5

                                                                                                                                          Desktops built on Wayland are amazing compared to desktops built on X11. I couldn’t go back anymore.

                                                                                                                                    1. 5

                                                                                                                                      Elm, Godot and how to protect against and how to execute TLS man in the middle replay attacks (pointers to how to get started with this are warmly welcome!).

                                                                                                                                      Also, more of: Rust, Blender, Renoise, BitWig, Octatrack, the game of Go (currently at ~4 kyu), ML and AVX2 assembly. Perhaps read a book or two about soft skills.

                                                                                                                                      Maybe some more Zig and Agda, if time allows it.

                                                                                                                                      1. 1

                                                                                                                                        Wait, isn’t it the entire point of TLS that such attacks are impossible?

                                                                                                                                        1. 3

                                                                                                                                          MITM attacks are possible against anything that either doesn’t check the cert chain or which allows certs signed by malicious entities (the latter includes all web browsers, since the default certificate bundle includes things like the not-the-Turkish-Intelligence-service-honest root cert, among others). Replay attacks and downgrade attacks are possible against older versions of TLS, which is why there was a big push to get everyone onto 1.2 or later. Attacking an older TLS / SSL stack is a good exercise for learning why features are present (or, in some cases, absent) in the newer protocol versions.

                                                                                                                                          1. 1

                                                                                                                                            not-the-Turkish-Intelligence-service-honest root cert

                                                                                                                                            Ouch, that sounds sexy, as in, a lot of things fucked. Can you write a short summary? Maybe backed by some links? Or just a link will do

                                                                                                                                            1. 3

                                                                                                                                              It looks as if that one (TURKTRUST) is gone now, after they were caught signing certificates for google.com for random people. The Turkish rep at one of the security conferences in the wake of this made such a big deal about this registrar not being in any way affiliated with their intelligence service that at the end no one believed him.

                                                                                                                                              My system appears to have 158 trusted root certificates. Unless you’re doing DNSSEC and publishing CCA records, any one of them can sign a cert for any of your domains and my system will trust it. Want to bet that all of them are trustworthy?

                                                                                                                                              1. 2

                                                                                                                                                My system appears to have 158 trusted root certificates. Unless you’re doing DNSSEC and publishing CCA records, any one of them can sign a cert for any of your domains and my system will trust it. Want to bet that all of them are trustworthy?

                                                                                                                                                Isn’t this what https://en.wikipedia.org/wiki/Certificate_Transparency addresses?

                                                                                                                                                1. 2

                                                                                                                                                  Kind of. Certificate transparency lets you see if you’re seeing a different certificate to other folks or if the cert has changed. I think Chrome may be querying the CT logs when it sees a cert now (which has some privacy issues) but it’s not clear what constitutes a false failure and what a user should do if they see one. If the domain owner needs to update the CT logs (as seems to be the case in the new system - originally clients would report the certs that they saw to the CT service) then that means you now have a centralised single point of failure to accomplish exactly the same security guarantees that CCA records with DNSSEC give you.

                                                                                                                                                  CT checks also make it difficult to use something like Let’s Encrypt for non-routable domains with a split horizon DNS (which you can do with the DNS-based version of the ACME protocol) without also leaking the names to the public (they end up in the public CT log, forever). In exchange for this information leak, you get a weaker security guarantee than with CCA records. With a CCA record, if a malicious registrar provides a cert for your domain, it will not work. With CT, if a malicious registrar provides a cert for your domain then there’s an audit log that might let you know that some clients had their connections compromised.

                                                                                                                                                  1. 2

                                                                                                                                                    With CT, if a malicious registrar provides a cert for your domain then there’s an audit log that might let you know that some clients had their connections compromised.

                                                                                                                                                    The “might” isn’t really fair there. Significant efforts goes into this and the intent is not to flag an error to the user (which they might click through) but to be a deterrent and a way to identify bad actors. You have to be prepared to burn a CA if you choose to coerce it into issuing certs it shouldn’t, since it would have it’s trust revoked.

                                                                                                                                                    There is a “how it works” overview here: https://certificate.transparency.dev/howctworks/ and there aren’t single points of failure in the sense you suggest.

                                                                                                                                                    DNSSEC is not without its own problems, including adding several more failure modes. CT doesn’t seem to add any negatives.

                                                                                                                                      1. 6

                                                                                                                                        I need to learn OpenGL. Hard to say what else I’ll need, there’s little sense in making plans.

                                                                                                                                        1. 1

                                                                                                                                          OpenGL ES or something like OpenGL 4?

                                                                                                                                          1. 1

                                                                                                                                            The oldest reasonable thing that will work on Linux desktops and macOS. I need it for rather simple texture transformations, because those are incredibly slow on a CPU, but I like to have deep understanding.

                                                                                                                                            1. 2

                                                                                                                                              Potentially useful resource on writing shaders? https://thebookofshaders.com/

                                                                                                                                              As far as my experience has gone, most of the buffer management stuff for OpenGL is pretty boilerplate (it’s just slinging buffers to the GPU and sometimes fetching results back), so most of the interesting work happens in the shaders.

                                                                                                                                              1. 1

                                                                                                                                                Also if you don’t need realtime rendering since it sounds like you might be doing batch processing, it could make sense to just use gpgpu features like OpenGL compute shaders or even OpenCL.

                                                                                                                                              2. 2

                                                                                                                                                People say that the book of shaders is good. I’ve found that going to shadertoy and tweaking some simple shaders heavily and googling built in gl mathematical functions to understand the ways I can modify the colors and point positions to be more interesting.

                                                                                                                                          1. 2

                                                                                                                                            ViM is now easier to quit than Nano, if Nano is launched with --zero or --nohelp:

                                                                                                                                            • ctrl-q starts a backwards search
                                                                                                                                            • ctrl-c shows a status message at the bottom
                                                                                                                                            • ctrl-h shows no help but starts deleting text
                                                                                                                                            • ctrl-? just inserts question marks
                                                                                                                                            • ctrl-x then actually quits nano, but only after saving the file with the deleted characters and question marks.

                                                                                                                                            I wonder what the rationale behind the default keybindings is.

                                                                                                                                            1. 7

                                                                                                                                              For ctrl-h, that isn’t nano-specific: that’s just the key combination that generates ASCII code 8, the backspace character (H being the 8th letter of the alphabet).

                                                                                                                                              ctrl-q and ctrl-w are backward- and forward-search, respectively, and they are right next to each other on the QWERTY keyboard. So that one at least makes geometric sense, although I don’t know why those two keys in particular.

                                                                                                                                              nano has an interesting history. It’s a clone of pico, which was originally written to be the built-in editor for the pine email client (which was a fork of the elm email client…), which used a forked version of MicroEMACS before they replaced it with pico. I wouldn’t be surprised if many of the keybindings were decided back then: “We can’t assign the spellchecker to ctrl-BLAH because that’s the keybinding for shuffling the user’s inbox!”

                                                                                                                                              1. 2

                                                                                                                                                I use micro because it has same default keybindings, and then ssh into boxes with just nano and end up typing ctrl-s and ctrl-q out of habit, alas.

                                                                                                                                              1. 25

                                                                                                                                                Not only do I unanimously agree, but this is the reason why I stopped putting licenses on my software. If a company wants a license, they can pay me, and individuals rarely care about licenses when they use software, which is perfectly fine (If a user cares enough, then they can contact me and I’ll grant them a lifetime license to modify and do whatever with it as long as it is non-commercial)

                                                                                                                                                We need an idea of “Communal Software” that both fixes the problems that were created by the GPL (Mostly with respect to the GNU foundation defending copyright), and that removes the cruel, needless, disgusting exploitation that has been created from ESR’s right-libertarian “Open Source” concept.

                                                                                                                                                Companies can fuck off. Mutually-owned coöperatives are where the future is.

                                                                                                                                                1. 23

                                                                                                                                                  I think I agree with you in spirit but I don’t understand why the GPL isn’t actually the solution. You say that it created problems. Can you elaborate?

                                                                                                                                                  1. 3

                                                                                                                                                    The GPL has explicitly allowed companies to repeatedly exploit maintainers. You can argue that “As long as the companies contribute their changes / the rest of their codebase back to upstream, then it’s fine”, but the reality is that this has directly led to a situation where maintainers of software that is in many ways the “backbone of the internet”, are not getting paid for their work and effort (and in many cases, very literal sweat, blood, and tears), and large companies (Specifically those based outside the US, but there are some that are US-based too) are more or less completely free to ignore or avoid the GPL through spurious means, just because they have money. After all, who actually is going to know if their tiny weekend project is being used in an organization’s infrastructure? For many GPL projects, there is simply absolutely no way to know if a large company is using it. Even then, there’s no way to magically be alerted to the fact that modifications have been done that have not been released upstream.

                                                                                                                                                    And even then, when companies and organizations do contribute to upstream, when you want to explicitly disallow this usage (for example, ICE, which has an unbelievably laundry list of human rights abuses), it gives the right to those exploitative companies and organizations to fork and maintain a separate branch of your software.

                                                                                                                                                    Not only does Copyright rely on someone knowing that software has been modified, changed, or is being used unlawfully in the first place, but Copyright requires lawsuits to enforce licensing. This inherently favours those people with means to be able to combat unlawful use, legally. The reality is that most people are completely unequipped financially to combat license fees, and companies in most cases do a legal “war of attrition” which depletes say, the EFF or other actual legal entities (Unlike the GNU Foundation or the FSF) from fighting cases that actually, tangibly matter a hell of a lot more, like the Right To Repair. Culturally it’s a net-loss to have copyright in existence in the first place, and the GNU and the FSF’s peripheral fighting in favour of Copyright has them fighting on the same side as Disney – as a result, we are actively losing many works that are otherwise irreplaceable simply because it is outright illegal for individuals and many sorts of archival organizations to preserve the works.

                                                                                                                                                    It’s a drain of time, money and resources, and ultimately does not solve (and as mentioned earlier, often runs counter to) the crucial problem at hand, which isn’t “do I have legal right to access code that a company uses”, but rather “how do we stop mass-exploitation of workers within Software Development as a field?”

                                                                                                                                                    1. 2

                                                                                                                                                      After all, who actually is going to know if their tiny weekend project is being used in an organization’s infrastructure?

                                                                                                                                                      Well, you’ll know it as soon as someone from that organization opens an issue demanding support, pressuring you because their money is on the line. At that point, you’ve caught them.

                                                                                                                                                      when you want to explicitly disallow this usage (for example, ICE, which has an unbelievably laundry list of human rights abuses), it gives the right to those exploitative companies and organizations to fork and maintain a separate branch of your software.

                                                                                                                                                      That’s not specific to the GPL, all open source software allows that. The Open Source Definition even makes it explicit that an open source license can’t discriminate among any users or groups.

                                                                                                                                                      and the GNU and the FSF’s peripheral fighting in favour of Copyright

                                                                                                                                                      Again, the same is true for all open source licenses, and the argument that copyright itself is broken and should be abolished, is like the argument that doing crimes is bad therefore crimes should be abolished. It’s true, but it ain’t happening. So let’s talk about something more productive.

                                                                                                                                                      1. 1

                                                                                                                                                        That’s not specific to the GPL, all open source software allows that. The Open Source Definition even makes it explicit that an open source license can’t discriminate among any users or groups.

                                                                                                                                                        Yes, and “Open Source” was specifically created to allow exploitation of open source maintainers, so I’m struggling to see how you think you’ve caught me in some kind of “gotchya”. A major part of the advertising of Open Source was how it would allow companies to take code for free without paying for the labour of others. I am explicitly arguing against both Open Source, and Free Software.

                                                                                                                                                        the argument that copyright itself is broken and should be abolished, is like the argument that doing crimes is bad therefore crimes should be abolished

                                                                                                                                                        The first is an argument and statement that has been made repeatedly, by people who literally make it their job to study Law – such as the author Lawrence Lessig, and the maintainers of pages like Public Domain Day at Duke Law School, the latter is a nonsensical tautology – crime is defined officially, as that which is illegal. So again, I do not understand what sort of point that you think you are making here.

                                                                                                                                                      2. 1

                                                                                                                                                        I wasn’t aware that GNU fights in favor of copyright, are you sure that’s accurate?

                                                                                                                                                        1. 1

                                                                                                                                                          There’s a writing by the GNU Foundation on it, I remember there being a news article too but I can’t find it. I remember that one of the “nordic block” countries were proposing to remove copyright from their legal system, and GNU/FSF heavily campaigned against it.

                                                                                                                                                          1. 1

                                                                                                                                                            That’s wild but I guess it makes sense. Their political actions have typically been naive and unstrategic.

                                                                                                                                                            IMO the most unstragetic part here is the pointless sectarianism. Wasted effort criticizing a platform that won’t be implemented. As unstrategic but perhaps less embarrassing than passing out Trisquel discs outside the Mac Store.

                                                                                                                                                    2. 15

                                                                                                                                                      This is mostly why I tend to license as AGPL3. Some individuals (myself for one) very much care about licenses and will generally avoid projects without one, but most companies have it on their “banned” list. If OTOH a company wants me to use a different license, well then that’s a lovely time to say “it’ll cost you X”.

                                                                                                                                                      1. 1

                                                                                                                                                        You could take it one step further and have “buy a license change” button on the project page.

                                                                                                                                                        1. 3

                                                                                                                                                          I could, but my preferred option is “fix your stupid license policy so you can cope with AGPL3”, so I’d prefer to lean them towards that even if it loses me some money!

                                                                                                                                                      2. 6

                                                                                                                                                        Projects without a license can not be packaged and redistributed by Linux distros.