1. 10

    I am 100% over versioning. I have never seen an implementation that doesn’t suck. It’s miserable. Something is fundamentally wrong with the whole model, whatever methodology you use for tagging won’t fix that.

    There could be different ways:

    1. Google has run decently internally by building everything from HEAD. It’s not easy, and it requires a monorepo, but it does work. Could this work in the real world? Probably not. But what if you say “GitHub is a monorepo”? What if when the dependency author uploads a breaking change, GitHub can say who they broke and how it broke, prompt the dependency author to document what the remediation for that pattern of breakage is, and just let people be broken until they upgrade? Maybe this is pushed to per-language registries like crates.io or the Go proxy.
    2. Unison tries to sidestep versioning entirely at the language level.
    3. Stop trying to meld dependencies together across packages. Every package and its dependencies are treated separately, and binaries just include every version that is depended on. Hard drive size is a trivial concern, binary sizes when you’re building binaries into Docker containers means the image size almost certainly dominates.
    1. 2

      I can’t wait for some of the ideas from Unison to permeate into more mainstream ecosystems. Lots of great ideas (globally accessible CAS, AST storage etc.) stuck behind a Haskell-like syntax.

      1. 1

        CAS

        Compare-And-Swap? Content-Aware Scaling? Close Air Support? Computer Algebra System? Content-Addressable Storage?

        1. 1

          Content-Addressable Storage. Check it out! https://www.unisonweb.org/

      2. 1

        I sort of agree because I don’t think there’s a perfect versioning system, but I think semver2 may be as good as it gets.

        I like it because it’s more functional than the marketing driven “versions don’t matter, we’ll just call it version 2.0 to sell more” and all the alternatives get into too much time spent on perfecting versioning systems to diminishing returns.

        I use it just so we have something, it saves time from deciding what to do, and it helps denote drafts or breaking changes. I use it even for stupid stuff like the “enterprise policy on bathroom breaks.” If it’s version 0.4.77 then it’s still in progress and could change any time. If it’s 1.1.16 then I mean it’s probably approved by someone. If I use 1.1.16 and see version 2.0 then it probably means I should read it because now it means I can only go to the bathroom on even hours or something that disrupts or may disrupt me.

      1. 3

        I had never heard of DOOM Emacs, but as a former Emacs user (but Vim since 2000), I would be quite curious to give it a shot. Also this article has quite a few good Vim plugins that I had not tried yet.

        Now the million dollar question, when are we going to see structured editors appear and be used for real?

        1. 3

          Doom Emacs is fine. I enjoyed using it as an out of the box experience.

          I eventually went back to Vim again with the 8ish plugins I find to be indispensable. I know I sound like an old beardy but there really is value in just knowing what is going on in the editing environment at all times, rather than dealing with oddities where you don’t know what is going on. The author of Doom Emacs is great and responsive on Discord, but it’s just kind of a bummer that you sometimes need to resort to that. That’s part and parcel of the out-of-thx-box experience in non-paid editors as far as I’ve experienced.

          I do think that LSPs and coc.nvim has been a huge productivity boost. You’re getting very close to VS Code levels of editor support but with full keyboard navigation.

        1. 2

          A neat analogy, but it seems the author is unaware of the Altor SAF lock.

          1. 4

            I have previously found that if thieves can’t get through the lock, they’ll just take the parts that aren’t locked or just damage your bike out of malice.

            1. 3

              Indeed. I’m simply pointing out that this arms race is always evolving.

            2. 3

              A massive 6.2kg $300 lock is probably a poor trade-off for many due to size, weight, and price.

              1. 2

                For most, but probably not for the owner of that $7k bike in the top comment on this post.

                1. 2

                  Maybe; but adding 7kg to your tour bike is not insignificant, never mind the huge size of the thing. I certainly wouldn’t look forward at hauling that around (especially not when using it as a touring bike) and would probably prefer either getting insurance or accepting the increased risk of theft.

                  For an expensive racing bike it’s even worse, as they usually weigh less than 10kg (even my €400 fixie was ~11kg) so you’re basically doubling your weight.

                  It all depends on your personal situation, chance of theft (i.e. where you live), what you do with it, and so forth. Generally speaking, I find that the quality of my life is better if I’m not so paranoid about this kind of stuff and just accept that I lose a bike every few years. It sucks, but one bad event every few years is better than spending time/brain cycles on this kind of stuff every day. YMMV of course.

              2. 3

                Altor SAF

                https://www.youtube.com/watch?v=1HvMPh6JBBI

                That thing is comically large! But it looks like it does resist the typical angle grinder.

              1. 5

                Ever since ponying up for PragmataPro, I find it very difficult to switch back to wider fonts. The extra information I get per line without sacrificing readability is wonderful.

                1. 3

                  I’m the opposite, I recently switched to a wider font (IBM Plex Mono) and I noticed I can reduce the font size by a couple of points (11 to 9), increasing the number of lines of code I can display compared to Iosevka. I’m still able to display 2 buffers side by side.

                  1. 1

                    +1 for wider fonts, Source Code Pro is king here.

                  2. 1

                    I had the same, though I went from Iosevka which is nice to see whether you enjoy these kinds of fonts. PragmataPro is just very slightly nicer, but the incredible configurability and free license of Iosevka is definitely cool.

                  1. 13

                    As someone who helped design the Cloud SQL VM environment, I can corroborate with the OP that it is utterly boring :) I left that team some time ago, basically after we launched this architecture.

                    When we wrote it we really were just using VMs as originally provisioned by Google Compute Engine and shoving MySQL as a Docker container and an API communication layer as a Docker container too. We deliberately wanted it to be as boring as possible partly for security concerns. The blast radius is pretty small when all you can do is compromise your single-tenant VM.

                    Obviously nowadays instead of single-tenant VMs you’d do this with Kubernetes. We were about two years too early.

                    1. 18

                      Nice setup.

                      1. I really advice against the side by side monitors. There problem is, your going to have your main app open in one monitor at a time so your going to be turning your neck for hours at a time. Suggest either stacking it going with a single large monitor. I got a Dell 43” 4k monitor for $700 ish. I previously had a single 32” ultra wide, which as the author mentioned is too short. Then a friend sold me his and I stacked them. That was ok but made me standing desk hard to use in standing mode.

                      I like the single monitors with a window management app. I’d love this setup now if I could get it in a curved version and a higher resolution for sharper text, but otherwise it’s amazing.

                      1. I’m always amazed that people are so hesitant to spend money on their work tools. They are tax-deductible but more importantly, they are in investment in your long term health and happiness. It’s one of the biggest advantages of working from home. Your don’t have to use the cheap crap your employer provides.

                      It’s doubly amazing because many in this situation are making $100k (possibly multiples of that). Also do many people have some crazy expensive bike,car,boat,guitars, home theater, etc that’s only used a few hours a week.

                      I know it’s tempting to cheap out, but 30,40,50 year old you will thank you.

                      That’s my PSA if the day.

                      1. 3

                        Shouldn’t have read this. The night just got expensive.

                        1. 3

                          turning your neck for hours at a time. Suggest either stacking it going with a single large monitor.

                          So you should be looking up for hours at a time?

                          1. 1

                            The distance between the center of two widescreen monitors is much smaller when stacked than when side-by-side. And of course that’s not true of landscape or square monitors. Not ALL stacked monitors are ergonomically arranged but you can reduce neck movement by stacking.

                            1. 4

                              I don’t know if it’s just about distance. I find the vertical angle matters much more than the horizontal angle. For example, I find laptops difficult to use for long periods because my neck gets sore looking down all the time, instead of looking straight ahead. However, I don’t have any problems with horizontal monitors.

                          2. 1

                            That’s a good point about the dual monitors. I’m considering having one facing flat forward, and another angled off to the side. I’d probably have to sit off to one side of my desk but that’s not too concerning.

                            I get your point about spending money on work tools, which might fall in the same category as what people say about beds & shoes. I do worry this attitude if adopted too enthusiastically can dull judgement about whether a given tool is really necessary - for example a gas-spring monitor stand instead of a basic one or an Ergodox instead of Goldtouch keyboard (although I admit being tempted by the Kinesis Advantage2 from seeing all the people who swear by it). With the way our society is set up it is often very difficult to determine (even within our own heads) whether something expensive is a reasonable purchase that supports good craftsmanship, or just a flex.

                            1. 6

                              Consider rotating one of the screens. I sit straight down the middle for the landscape screen, then have the portrait screen to my right.

                              I’m pretty sensitive to shitty ergonomic setups, and this causes me no problems at all.

                              1. 2

                                This is my setup too. Looks dorky, works great.

                                1. 2

                                  I do this too. The only problem is that 16:9 screens reeally don’t like being in portrait. I have a 24” 16:9 screen to the left of the primary screen used mostly for web browsing, and it’s really common for websites to grow a combination of horizontal scroll bars and buttons with text extending outside of their bounds.

                                  1. 1

                                    Hah, yeah I got the last 16:10 that dell sold a few years ago and just picked up a partner for it, and having them side-by-side vertically is great, but I would be loathe to throw away 10% of that space.

                                  2. 1

                                    That’s a neat idea, I think I’ll try that!

                                  3. 2

                                    All decisions come with error bars. Fall on one side, you have a flex; fall on the other, you are performing worse at work than you could be.

                                    I know which side I’m happier to land on.

                                    1. 2

                                      The main point is this: every single person I’ve had a discussion on buying quality tools for work and had an objection to spending money also had some expensive hobby they were willing to splurge on. (I’m sure not everyone is like this, just seemed the people with the strongest objection had other money sinks). Is just a matter of logical consistently. They might have $25k of bike equipment in the garage but get upity about spending $500 on good equipment. That’s why this is one of my hot button issues. A course of physical therapy is going to cost more than decent equipment.

                                      My old equipment always finds it way to friends and family and tends to get years of useful life beyond me.

                                      1. 2

                                        There’s nothing logically inconsistent about spending money in some places and saving it in others. “I spent a bunch of money on thing X, so I should also spend a lot of money on thing Y” sounds more like sales tactic psychology than logical reasoning. You can easily get good enough ergonomic equipment to keep the PT away without spending much money. A $20 used Microsoft Natural Ergonomic 4000 keyboard, a $25 Anker vertical mouse… even monitor stands can be replaced with a stack of old technical manuals. A good chair is really the only thing I’d say you need, and you can get a good-enough used Costco model for like $60.

                                        1. 1

                                          a stack of old technical manuals

                                          To be fair, these are harder and harder to find. Same goes for phone books…

                                          1. 1

                                            It is if a) this is the way you make your living and b) you are oddly cheap in this area but spend big money on things you use way less. That’s the point in trying to make and I still find the behavior quite baffling.

                                            Invest in yourself and your health.

                                            I’m not trying to sell you a standing desk.

                                        2. 1

                                          That’s a good point about the dual monitors. I’m considering having one facing flat forward, and another angled off to the side. I’d probably have to sit off to one side of my desk but that’s not too concerning.

                                          At work with a two monitors set-up, I tended to have my main one in front of me flat and the other angled on the left. Not being in the centre of the desk allowed me to have a notebook and pen on the left of the mouse that I can reach for quick notes and having a space not in front of the main screen for thinking with reasonable space to use the notebook.

                                        3. 1

                                          Could not agree more with this! Many of my colleagues think I’m crazy for sticking to one monitor but I find it not only saves my kneck but also helps keep focus.

                                        1. 19

                                          I’m probably not the only one with the opinion that rewrites in Rust may generally a good idea, but Rust’s compile times are unacceptable. I know there are efforts to improve that, but Rust’s compile times are so abysmally slow that it really affects me as a Gentoo user. Another point is that Rust is not standardized and a one-implementation-language, which also discourages me from looking deeper into Haskell and others. I’m not saying that I generally reject single-implementation languages, as this would disregard any new languages, but a language implementation should be possible without too much work (say within two man-months). Neither Haskell nor Rust satisfy this condition and contraptions like Cargo make it even worse, because implementing Rust would also mean to more or less implement the entire Cargo-ecosystem.

                                          Contrary to that, C compiles really fast, is an industry standard and has dozens of implementations. Another thing we should note is that the original C-codebase is a mature one. While Rust’s great ownership and type system may save you from general memory-handling- and type-errors, it won’t save you from intrinsic logic errors. However, I don’t weigh that point that much because this is an argument that could be given against any new codebase.

                                          What really matters to me is the increase in the diversity of git-implementations, which is a really good thing.

                                          1. 22

                                            but a language implementation should be possible without too much work (say within two man-months)

                                            Why is that a requirement? I don’t understand your position, we shouldn’t have complex, interesting or experimental languages only because a person couldn’t write an implementation by himself in 2 months? We should discard all the advances rust and haskell provide because they require a complex compiler?

                                            1. 5

                                              I’m not saying that we should discard those advances, because there is no mutual exclusion. I’m pretty certain one could work up a pure functional programming language based on linear type theory that provides the same benefits and is possible to implement in a reasonable amount of time.

                                              A good comparison is the web: 10-15 years ago, it was possible for a person to implement a basic web browser in a reasonable amount of time. Nowadays, it is impossible to follow all new web standards and you need an army of developers to keep up, which is why more and more groups give up on this endeavour (look at Opera and Microsoft as the most recent examples). We are now in a state where almost 90% of browsers are based on Webkit, which turns the web into a one-implementation-domain. I’m glad Mozilla is holding up there, but who knows for how long?

                                              The thing is the following: If you make the choice of a language as a developer, you “invest” into the ecosystem and if the ecosystem for some reason breaks apart/dies/changes into a direction you don’t agree with, you are forced to put additional work into it.

                                              This additional work can be a lot if you’re talking about proprietary ecosystems, meaning more or less you are forced to rewrite your programs. Rust satisfies the necessary condition of a qualified ecosystem, because it’s open source, but open source systems can also shut you out when the ABI/API isn’t stable, and the danger is especially given with the “loose” crate system that may provide high flexibility, but also means a lot of technical debt when you have to continually push your code to the newest specs to be able to use your dependencies. However, this is again a question of the ecosystem, and I’d prefer to only refer to the Rust compiler here.

                                              Anyway, I think the Rust community needs to address this and work up a standard for the Rust language. On my behalf, I won’t be investing my time into this ecosystem until this is addressed in some way. Anything else is just building a castle on sand.

                                              1. 5

                                                A good comparison is the web: 10-15 years ago, it was possible for a person to implement a basic web browser in a reasonable amount of time. Nowadays, it is impossible to follow all new web standards and you need an army of developers to keep up, which is why more and more groups give up on this endeavour (look at Opera and Microsoft as the most recent examples). We are now in a state where almost 90% of browsers are based on Webkit, which turns the web into a one-implementation-domain. I’m glad Mozilla is holding up there, but who knows for how long?

                                                There is a good argument by Drew DeVault that it is impossible to reimplement a web browser for the modern web

                                                1. 4

                                                  I know Blink was forked from webkit but all these years later don’t you think it’s a little reductive to treat them as the same? If I’m not mistaken Blink sends nothing upstream to webkit and by now the codebases are fairly divergent.

                                              2. 8

                                                I feel ya - on OpenBSD compile times are orders of magnitude slower than on Linux! For example ncspot takes ~2 minutes to build on Linux and 37 minutes on OpenBSD (with most features disabled)!!

                                                1. 5

                                                  37 minutes on OpenBSD

                                                  For reals? This is terrifying.

                                                  1. 1

                                                    Excuse my ignorance – mind pointing me to some kind of article/document explaining why this is the case?

                                                    1. 7

                                                      There isn’t one. People (semarie@ - who maintains the rust port on OpenBSD being one) have looked into it with things like the RUSTC_BOOTSTRAP=1 and RUSTFLAGS='-Ztime-passes -Ztime-llvm-passes' env vars. These point to most of the time being spent in LLVM. But no one has tracked down the issue fully AFAIK.

                                                  2. 6

                                                    Another point is that Rust is not standardized and a one-implementation-language

                                                    This is something that gives me pause when considering Rust. If the core Rust team does something that makes it impossible for me to continue using Rust (e.g. changes licenses to something incompatible with what I’m using it for), I don’t have anywhere to go and at best am stuck on an older version.

                                                    One of the solutions to the above problem is a fork, but without a standard, the fork and the original can vary and no one is “right” and I lose the ability to write code portable between the two versions.

                                                    Obviously, this isn’t a problem unique to Rust - most languages aren’t standardized and having a plethora of implementations can cause its own problems too - but the fact that there are large parts of Rust that are undefined and unstandardized (the ABI, the aliasing rules, etc) gives me pause from using it in mission-critical stuff.

                                                    (I’m still learning Rust and I’m planning on using it for my next big thing if I get good enough at it in time, though given the time constraints it’s looking like I’ll be using C because my Rust won’t be good enough yet.)

                                                    1. 2

                                                      The fact that the trademark is still owned by the Mozilla foundation and not the to-be-created Rust Foundation is also likely chilling any attempts at independent reimplementation.

                                                    2. 1

                                                      As much as I understand your point about the slowness of compile time in Rust, I think it is a matter of time to see them shrink.

                                                      On the standard point, Haskell have a standard : Haskell 2010 . GHC is the only implementation now but it have a lot of plugins to the compiler that are not in the standard. The new standard Haskell 2020 is on his way. Implementing the standard Haskell (not with all the GHC add-ons) is do-able but the language will way more simple and with flaws.

                                                      1. 2

                                                        The thing is, as you said: You can’t compile a lot of code by implementing Haskell 2010 (or 2020 for that matter) when you also don’t ship the “proprietary” extensions.

                                                        1. 1

                                                          It is the same when you abuse GCC or Clang extensions in your codebase. The main difference with Haskell is that you, almost, only have GHC available and the community put their efforts in it and create a ecosystem of extensions.

                                                          As for C, your could write standard-compliant code that an hypothetical other compiler may compile. I am pretty sure if we only had one main compiler for C for so long that Haskell have had GHC, the situation would have been similar : lots of language extension outside the standard existing solely in the compiler.

                                                          1. 3

                                                            But this is exactly the case: There’s lots and lots of code out there that uses GNU extensions (from gcc). For a very long time, gcc was the only real compiler around and it lead to this problem. Some extensions are so persistent that clang had no other choice but to implement them.

                                                            1. 1

                                                              But does those extensions ever reached the standard? It as asked candidly as I do not know a lot of the evolution of C, compilers and standard that much.

                                                              1. 3

                                                                There’s a list by GNU that lists the extensions. I really hate it that you can’t enable a warning flag (like -Wextensions) that warns you about using GNU extensions.

                                                                Still, it is not as bad as bashism (i.e. extensions in GNU bash over Posix sh), because many scripts declare a /bin/sh-shebang at the top but are full of bashism because they incidentally have bash as the default shell. Most bashisms are just stupid, many people don’t know they are using them and there’s no warning to enable warnings. Another bad offender are GNU extensions of the Posix core utilities, especially GNU make, where 99% of all makefiles are actually GNU only and don’t work with Posix make.

                                                                In general, this is one major reason I dislike GNU: They see themselves as the one and only choice for software (demanding people to call Linux “GNU/Linux”) while introducing tons of extensions to chain their users to their ecosystem.

                                                                1. 2

                                                                  Here are some of the GNU C extensions that ended up in the C standard.

                                                                  • // comments
                                                                  • inline functions
                                                                  • Variable length arrays
                                                                  • Hex floats
                                                                  • Variadic macros
                                                                  • alignof
                                                              2. 1

                                                                If I remember correctly 10 years ago hugs was still working and maybe even nhc :)

                                                                1. 1

                                                                  Yep :) and yhc never landed after forking nhc. UHC and JHC seem dead. My main point is mainly that the existence of a standard does not assure the the multiplication of implementations and the cross-cIompilation between compilers/interpreters/jit/etc. It is a simplification around it and really depends on the community around those languages. If you look at Common Lisp with a set in the stone standard and a lot of compilers that can pin-point easily what is gonna work or not. Or Scheme with a fairly easy standard but you will quickly run out of the possibility to swap between interpreters if you focus on some specific stuffs.

                                                                  After that, everyone have their checklist about what a programming language must or must not provide for them to learn and use.

                                                        1. 22

                                                          If you’re the kind of person who’s willing to put up with a learning curve and a smaller ecosystem of plugins to gain access to a powerful editing model, also consider Kakoune. It’s like Vim, but moreso.

                                                          1. 8

                                                            I simply can’t go back to Vim after using Kakoune. Feels like a step back to me.

                                                            1. 8

                                                              I am in the same boat. I think by and large Kakoune is a step up from Vim. That said, it is not emulated in very many other places (it is in vs-code now via dance) – so you do lose the ability to pop into IDE of your choice and have a good experience.

                                                              1. 2

                                                                Dance is cool, but there are a lot of little things that does not work the same way and it’s annoying.

                                                                When i’m at the beginning of a line and press x, it doesn’t select the line. It selects the line below. If i go forward one character before pressing x, it works.

                                                                It’s good enough…

                                                                1. 1

                                                                  That smells like a bug more than a difference.

                                                              2. 1

                                                                I wish emacs had a kakoune mode like the evil mode. It would help me pick up emacs finally. Each time I have tried evil, I got stuck in small differences with vim.

                                                                1. 2

                                                                  Unfortunately every emulation of another editor is not the same thing.

                                                                  I use kakoune to write small programs and scripts, but i have vscode as well. Vscode has a plugin called “dance”, it is a kakoune simulation plugin. It works, but not very much…

                                                                  The problem is the little things… there is always something that doesn’t really work the same and becomes annoying.

                                                              3. 6

                                                                How would you say the transition to Kakoune from someone who’s been using vim for awhile is like? I took it for a spin and am very confused, but I can already see things that I like.

                                                                1. 6

                                                                  I switched from vim to kakoune about 6 months ago. I think the majority of the users, including the author himself, came from vim. My strategy was to switch entirely for a week then decide if it was worth committing fully or not. I never went back to vim. Once you get over the initial hurdle of unlearning your vim muscle memory, kakoune is very intuitive to learn, more so than vim in my opinion.

                                                                  1. 4

                                                                    Seconding ifreund’s experience, I came to Kakoune after maybe 20 years using Vim and it took me maybe a month for Kakoune to feel comfortable. The biggest hurdles for me were a few commonly-used key-bindings that changed (x in Kakoune is “select the current line”, not “delete the character under the cursor), and that Kakoune is a little bit like that “Snake” game on old Nokia phones: as you’re moving around, you need to be conscious of where the “tail” of your selection is as well as the “head”.

                                                                    The thing I love most about Kakoune is global search-and-replace. In Vim, I’d often wind up in a cycle of “write a replacement regex, try it, check the document, find a mistake, undo, try again”, which was particularly frustrating when the thing I wanted to select was easy to describe in Vim’s normal mode (like % to select a matched pair of brackets) but difficult to describe in regex. Meanwhile, in Kakoune, I can match a regex across the entire document, producing multiple selections, cycle through them all to check I’ve selected the right things, manually adjust them with normal-mode commands or even drop false-positives, and then do the replacement. It’s more work than the best-case Vim equivalent, but far smoother and more pleasant than the worst-case Vim equivalent.

                                                                    1. 2

                                                                      I know you don’t use Vim anymore but for anyone else who has the problem described in the second paragraph: traces.vim offers a live preview that makes searching and replacing easier, if not quite as easy as it seems to be in Kakoune. As you’re typing a :s command, the plugin will highlight the parts of the file or line that would be matched, and it will also show you what they would be replaced with. It’s pretty magical.

                                                                  2. 3

                                                                    I really want to, but the hidden benefit of Vim keybindings is they translate to other programs too (I assume Vim people are just very militant and force devs to support them ;) ) so I can use IntelliJ or Emacs or even a web-based IDE and have access to those bindings. If I changed muscle memory to Kakoune, I’m going to be in trouble for hopping between programs.

                                                                    1. 3

                                                                      powerful editing model

                                                                      Can someone pitch to me, the established emacs user, what the benefits of Kakoune are? I have multiple cursors package enabled, plus helm and swoop (intra file fuzzy matching), but I presume Kakoune presents more benefits.

                                                                      1. 7

                                                                        EDIT: This explains it better https://kakoune.org/why-kakoune/why-kakoune.html


                                                                        Disclaimer: I’ve used Emacs for fewer than 10 hours in my life. I remember very little.

                                                                        The last time I looked into it, the big difference that Kakoune brings to the table is that nouns come before verbs. This feels minor but in practice it makes discoverability so much easier because you’re deciding which text to act upon before doing an action.

                                                                        For example, in Vim if you want to delete three words you type d3w, and if you realize that you meant to delete 2 words then you have to undo and try again. Kakoune lets you make your selection first, highlighting as you go, and makes it easy to change your selection before taking an action. It’s also constantly auto-completing with all of the possible commands you might want to make, which is much simpler than reading through a manual.

                                                                        1. 2

                                                                          Not having used the Emacs multiple cursors package (or Emacs at all, really) it’s hard for me to say what the advantages of Kakoune’s editing model might be. If I had to guess, though, I suspect the biggest difference would be that since the Emacs core is only built for single selections, most Emacs functionality (including third-party extensions, etc.) only works with single selections, except for the things that the multiple cursors package specifically modifies. Meanwhile, all of Kakoune’s standard features and third-party extensions deal with multiple selections, so you don’t need a mental model of how single-selection features interact with multiple-selection data.

                                                                          I don’t know how complete Emacs’ multiple cursors package is, but I expect it has all the same kinds of cursor interactions as Kakoune, like selecting substrings of the selection that match a regex, splitting the selection on a regex, dropping selections that do/do not match a regex, dropping selections interactively, rotating content through selections, etc. If not, that might be another reason to try Kakoune!

                                                                      1. 7

                                                                        I’ve written Java professionally for a few years now and continue to recommend Effective Java as a starting point. I originally read the second edition when I started writing Java professionally, and recommend the third edition to others in your shoes that I work with. It will bootstrap a lot of fundamental concepts into your knowledge that you would learn over your first six months or a year of writing Java.

                                                                        The third edition covers Java 9, and Java 10 + 11 haven’t introduced too much new stuff that really changes the ball-game of writing Java, especially for someone new to the language. I don’t think there’s anything I would consider critical knowledge in Java 10 + 11 (even var), and anything that is I think you’d quickly learn via code review etc.

                                                                        1. 4

                                                                          I’d second this. Java 8 introduced streams, which are probably the biggest change since Generics. Java 9 introduced modules, which have major implications for packaging, library compatibility and some other concerns like that. By comparison, Java 11 is pretty small stuff.

                                                                          I only read the second edition of Effective Java, but I’ve only heard good things about the third edition.

                                                                          1. 1

                                                                            Thanks both, I put in an order for the third edition :)

                                                                            1. 1

                                                                              Java 8 was really major imo: besides streams, 8 also introduced lambdas and the whole java.util.function hierarchy, which changes some codebases quite a bit. Suddenly it became easy to do things like sort by a custom sort order! I agree that 10/11 are pretty minor.

                                                                          1. 5

                                                                            I can’t specifically speak to Java 11 but I’d say this shouldn’t necessarily be your immediate goal unless you know that the code base you’ll be reading/contributing is using lots of features from Java 11. You should concentrate on learning the code base first so that you can be ramp up quicker. If there are idioms that seem foreign that’s when you go to Oracle docs/Google/Stack overflow/other coworkers.

                                                                            There’s two sites that might help with transitioning to another language

                                                                            Code Review RosettaCode

                                                                            Although Rosetta Code might not have the most idiomatic code.

                                                                            1. 4

                                                                              I can’t specifically speak to Java 11 but I’d say this shouldn’t necessarily be your immediate goal unless you know that the code base you’ll be reading/contributing is using lots of features from Java 11.

                                                                              This is a great point that speaks to something I didn’t mention before: the code we will be writing will be all new, there won’t be any previous code. So all the bells and whistles are available, as the golden rule of staying consistent doesn’t apply. The question is is which bells and which whistles should be thought about :)

                                                                              1. 4

                                                                                In that case, try to convince your team not to do green field development in an antiquated language.

                                                                                There are better JVM languages now, with near-perfect Java interop.

                                                                                1. 5

                                                                                  Google is all in on Java for the JVM. Sadly Kotlin remains banned except for Android work.

                                                                                  1. 4

                                                                                    Just curious what the rationale for that is? Kotlin is used in Android but not on the server side?

                                                                                    1. 7

                                                                                      Google is intensely conservative about server side code languages.

                                                                                      There are a few reasons that I can see:

                                                                                      • Readability: given the Google monorepo, you will depend on other peoples libraries a lot. It is very important you can read them, and that the documentation that there is is something you can understand. If you’ve only ever seen Kotlin, you have to do mental gymnastics to understand Java libraries or documentation, and no one wants to rewrite documentation/examples over and over in different languages.
                                                                                      • SRE support: SREs are the most conservative people on earth for good reason. They need to be able to jump into alien code they didn’t write understand it quickly, figure out what is happening and come up with a mitigation strategy under pressure. Language proliferation makes that much harder as you have to start splitting SREs over languages, and SREs are in short supply.

                                                                                      These are the two most obvious ones, I assume there are also plenty more about library support, running things reliably in production, security patching…

                                                                                      Kotlin is obviously an easier lift given it’s a JVM language and popular. I’d say it’s a 50:50 proposition it gets accepted in the next 5 years. It really depends on whether it can offer significant provable benefits to productivity over Java, and I think that jury remains out.

                                                                                      1. 5

                                                                                        Google can’t afford using expressive languages. Their hiring process results in having (enough of) developers thinking of themselves as being the smartest, infallible people on the planet which leads to overly smart, unreadable code in any language, but expressiveness exacerbates that. This is by the way why Go is so minimalist: the fewer variety, the better. Now imagine what damage they’re going to do in a language with five flavors of .let.

                                                                                        (This is all purely my speculation based on hearsay.)

                                                                                    2. 1

                                                                                      I will say that if I were going to choose a language for the JVM–which I’m not, because I don’t have to, thankfully–I would still stick with Java. Groovy and Clojure are dynamically typed, Scala has serious readability and maintainability concerns, and in my experiments with Kotlin I ran into numerous surprising warts that led me to conclude that the benefits it gives aren’t worth it. Java is a verbose, annoying language, but its semantics are well-defined and well-understood, so despite its age it still seems like the best choice to me if you must target the JVM.

                                                                                1. 31

                                                                                  The reason they spread these misconceptions is straightforward: they want to discourage people from using the AGPL, because they cannot productize such software effectively.

                                                                                  This doesn’t stand up to even a modicum of scrutiny. First of all, it assumes you know the intent of Google here. I don’t think Google’s intentions are that great to be honest, but as a rule of thumb, if you form an argument on knowing the intentions of other humans, it’s probably a bad argument unless you can provide credible evidence of their intent. Secondly, I see no such credible evidence in this article, and the lack of attention paid to how Google handles other licenses in this article is borderline disingenuous. All I see is a casual observation that Google’s policy benefits them systemically, which I would absolutely agree with! But that shouldn’t be a surprise to anyone.

                                                                                  Why? Because it omits critical context. The AGPL is not the only license that Google bans. They also ban the WTFPL, which is about as permissive as it gets. They ban it because they have conservative legal opinions that conclude it has too much risk to rely on. I think those legal opinions are pretty silly personally, although I am somewhat biased because I’ve released code under the WTFPL only to have one Googler after another email me asking me to change the license because it’s banned at Google.

                                                                                  My point is that there are other reasonable business explanations for banning licenses. Like that a team of lawyers paid to give their best expert advice on how a judge would rule for a particular license might actually, you know, be really risk averse. Licenses aren’t some black and white matter where things that are true and things that are not are cleanly separated in all cases. There’s oodles of grey area largely because a lot of it actually hasn’t been tested in court. Who would have thought the courts would rule the way they did in Google v. Oracle?

                                                                                  What’s the cost of being wrong and having Google required to publish all of their source code? Can anyone here, even a Googler, even begin to estimate that cost? If you haven’t thought about that, then you probably haven’t thought deeply enough to criticize the intentions on this particular piece of “propaganda.” Because that’s probably what Google’s lawyers are weighing this against. (And probably an assortment of other such things, like the implications of allowing AGPL but giving each such use enough scrutiny as to be sure that it doesn’t wind up costing them dearly.)

                                                                                  But by all means, continue punishing companies for making their policies like this public. Because that’s a great idea. (No, it’s not. Despite how annoying I find Google’s policies, I really appreciate having them documented like they are.)

                                                                                  Disclaimer: I don’t like copyleft, but primarily for philosophical reasons.

                                                                                  1. 11

                                                                                    I don’t think Google’s intentions are that great to be honest, but as a rule of thumb, if you form an argument on knowing the intentions of other humans, it’s probably a bad argument unless you can provide credible evidence of their intent.

                                                                                    As someone who previously worked on the open source team at Google and sat in the office and am friends with these humans, I can say very strongly that those lawyers do not have some sort of hidden agenda. It is also certainly false to assume they are not competent at their job. My read is that they are, as you might expect, very good at their job (noting I am also not a lawyer).

                                                                                    A common mistake I see many commenters (and news stories etc etc) and I think you head to unintentionally, is to talk about Google as if it is a single anthropomorphic entity with its own thoughts and feelings. This piece does the same. There is not “a Google” that is making amoral decisions for its global benefit . There is an office of humans that try their best and have good intentions.

                                                                                    The team makes decisions in this order:

                                                                                    1. Protect the open source ecosystem.
                                                                                    2. Protect the company.

                                                                                    “Protect the ecosystem” is hard to believe if you buy into the “amoral entity” argument but is provably true: the easiest way to protect the company is to ban open source contribution (aside from forced copyleft terms) at all, but Google does this a lot under the Apache 2 (permissive) license. The banned licenses, as you note, are those that either do not have enough specificity (like WTFPL) or ones with what the legal team believe are onerous terms. They are good laywers, and so you have to assume they have a pretty strong case for their interpretation. Even if you think they are wrong (as all law is essentially malleable), hashing things out in court to decide what the terms of the license truly mean is a really bad use of time and money.

                                                                                    1. 13

                                                                                      There is not “a Google” that is making amoral decisions for its global benefit . There is an office of humans that try their best and have good intentions.

                                                                                      Yes, there is. The two are not mutually exclusive. A corporation like Google is structured in such a way that the sum of all its humans, all trying their best, serves the interests of the company. It’s not anthropomorphic, but it does have an agenda, and it’s not necessarily that of any of its constituent humans. Whether morality features prominently on that agenda is a legitimate matter for debate.

                                                                                      I think you’re trying to open a semantic crack in which responsibility can be lost: misdeeds are attributed to Google, but since Google isn’t one person it can’t be guilty of anything. But if companies really aren’t more than the sum of their parts, at least one person at Google must be responsible for each of its transgressions, which I think casts doubt on the claim that they have good intentions.

                                                                                       

                                                                                      The team makes decisions in this order:

                                                                                      1. Protect the open source ecosystem.
                                                                                      2. Protect the company.

                                                                                      Maybe that’s true of the open source team. It’d be hard to believe that of Google in general—partly because it’s a coompany and you’d expect it to protect itself first, but more concretely because there’s history. Google has been hegemonizing Android for years. They’re also trying to do the same to the Web, via Chrome. The open source ecosystem gets to use whatever Google puts out, or suffer. I don’t see how that’s healthy.

                                                                                       

                                                                                      “Protect the ecosystem” is hard to believe if you buy into the “amoral entity” argument but is provably true: the easiest way to protect the company is to ban open source contribution (aside from forced copyleft terms) at all, but Google does this a lot

                                                                                      (I note that you don’t have a problem anthropomorphizing Google when it’s doing things you think are good.)

                                                                                      I’ve yet to see the proof. Publishing open source software doesn’t necessarily speak to any commitment to the wellbeing of the open-source ecosystem, nor does it typically carry any great risk. Let’s take a couple of minutes to think of as many reasons as we can why a company might publish open-source software out of self-interest:

                                                                                      • The existence of good tooling for markets you dominate (web, mobile) directly benefits you
                                                                                      • Developers like publishing things, so letting them publish things is a cheap way to keep them happy if it doesn’t hurt you too badly
                                                                                      • It’s great PR
                                                                                      • If you have a way to use your open-source thing in a way that nobody else does, the free work other people do on it gives you an advantage

                                                                                      You might say: so what? Obviously they have businessy motivation to care about open source, but what does it matter if the result is they care about open source? But, as we’ve seen, the moment it benefits them to work flat-out on destroying an open ecosystem, they do that instead.

                                                                                      1. 3

                                                                                        But, as we’ve seen, the moment it benefits them to work flat-out on destroying an open ecosystem, they do that instead.

                                                                                        This could be said of nearly any corporation as well.

                                                                                        Move from OS sales to cloud services, buy an open-source friendly company, release a good editor that works on the competition, and even inter-op with rhe competition.

                                                                                        The example may have the best intentions in mind, insofar a corporation can, but could also be a long-con for traction and eventually blast out something that makes the users jump ship to the corporation’s platform.

                                                                                        Best part of it all is, it could be hedging in case that “something” comes along. There is some win either way and an even bigger win if you can throw the ideals under the bus.

                                                                                        1. 2

                                                                                          For sure. It’d be naïve to think Microsoft had become nice. They’ve become smarter, and they’ve become a smaller player comparatively, and in their situation it’s pragmatic to be a good citizen. Google was the same with Android before they won their monopoly.

                                                                                        2. 2

                                                                                          (I note that you don’t have a problem anthropomorphizing Google when it’s doing things you think are good.)

                                                                                          It’s easy to do, mistakes were made, I’m human. Don’t assume malice or misdirection.

                                                                                          1. 5

                                                                                            I don’t assume either. I think it’s a natural way to communicate about organisations. But your opening gambit was about how talking about Google in those terms betrayed some error of thought, so I’d hoped that pointing this out might give you pause to reconsider that position. I didn’t mean to cast doubt on your sincerity. Apologies.

                                                                                            1. 2

                                                                                              All good 👍

                                                                                        3. 10

                                                                                          Right, I mostly agree with what you’re saying! I do think a lot of people make the mistake of referring to any large company as a single entity, and it makes generalizing way too easy. With the WTFPL thing, I experienced that first hand: a bunch of individuals at Google reached out to me because none of them knew what the other was doing. And that’s a totally reasonable thing because no large company is one single mind.

                                                                                          Now, I don’t want to come off like I think Google is some great thing. The WTFPL thing really left a sour taste in my mouth because it also helped me realize just how powerful Google’s policies are from a systemic point of view. They have all these great open source projects and those in turn use other open source projects and so forth. My libraries got caught up in that, as you might imagine in this day and age where projects regularly have hundreds or thousands of dependencies, and Google had very powerful leverage when it came to me relicensing my project. Because it worked itself back up the chain. “{insert google project here} needs to stop using {foo} because {foo} depends on {burntsushi’s code that uses WTFPL}.” Now foo wants to stop using my code too.

                                                                                          I’m not saying any of this is particularly wrong, to be honest. I am an individualist at heart so I generally regard this sort of thing as okay from an ethical or legal perspective. But still, emotionally, it was jarring.

                                                                                          Do I think the lawyers in Google’s open source policy office think about that sort of effect it has on individuals? I don’t really. I don’t think many do. It’s probably a third order effect of any particular decision, and so is very hard to reason about. But from my perspective, the line of policy making on Google connects very directly to its impact on me, as an individual.

                                                                                          In the grand scheme of things, I think this is not really that big of a deal. I’m not all hot and bothered by it. But I do think it’s a nice counter-balance to put out there at least.

                                                                                          1. 4

                                                                                            To play devil’s advocate:

                                                                                            It appears that seasoned lawyers have deemed the license you use “not specific enough”.

                                                                                            Isn’t the whole point of a license to fully lay out your intentions in legal terms? If it doesn’t succeed at that, wouldn’t it be better to find another license that does a better job at successfully mapping your intentions to law?

                                                                                            1. 6

                                                                                              To be clear, I don’t use the WTFPL any more, even though I think it makes my intent perfectly clear. So in a sense, yes, you’re right and I changed my behavior because of it. I stopped using it in large part because of Google’s influence, although the WTFPL didn’t have a great reputation before Google’s policy became more widely known either. But most people didn’t care until Google’s policy influenced them to care. Because in order for my particular problem to exist, some amount of people made the decision to use my project in the first place.

                                                                                              I brought up the WTFPL thing for two reasons:

                                                                                              • To demonstrate an example of a license being banned that isn’t copyleft, to show that Google has other reasons for banning licenses than what is stated in the OP.
                                                                                              • To demonstrate the impact of Google’s policies on me as an individual.

                                                                                              I didn’t bring it up with the intent to discuss the particulars of the license though. I’m not a lawyer. I just play one on TV.

                                                                                              1. 2

                                                                                                But I think even Google’s influence is just one example of the commercial world interacting with the “libre” world; in this light, Google is just entering earlier and/or investing more heavily than its peers. And it could be argued that’s a good thing, as it puts libre creators more in touch with the real needs of industry. It’s the creator’s choice whether to acknowledge and adapt to that influence, or to bend to it entirely. As I see it, Google can’t make you do anything.

                                                                                                I do hope that Google carves out exceptions for things like Affero though, since I share Drew’s confusion at Google’s claim of incompatibility. I’m in the same boat, after all; I’m also a user of a niche license (License Zero), the legal wording of which I nevertheless have great confidence in.

                                                                                                I believe that at some point, companies like Google will have to bend to the will of creators to have control over how their work is licensed. I happen to use License Zero because it seems to provide more control on a case-by-case basis, which I think is key to effecting that shift.

                                                                                                1. 4

                                                                                                  I do hope that Google carves out exceptions for things like Affero though, since I share Drew’s confusion at Google’s claim of incompatibility.

                                                                                                  Large parts of Google work in a monorepo in which anything goes if it furthers the mission. The Google licensing site brings up that example of a hypothetical AGPL PostGIS used by Google Maps. In normal environments that wouldn’t be an issue: your code interfaces to PostGIS through interprocess APIs (which still isn’t linking even with the AGPL) and users interact with your code, but not with PostGIS. In the monorepo concept code can quickly be drawn into the same process if it helps any. Or refactored to be used elsewhere. That “elsewhere” then ends up under AGPL rules which could be a problem from a corporate standpoint.

                                                                                                  It’s a trade-off between that flexibility in dealing with code and having the ability to use AGPL code, and the organizational decision was apparently to favor the flexibility. It can be possible to have both, but that essentially requires having people (probably lawyers) poring over many, many changes to determine if any cross pollination between license regimes took place. Some companies work that way, but Google certainly does not.

                                                                                                  I believe the issue with WTFPL is different: because it’s so vague my guess is that the open source legal folks at Google would rather see that license disappear completely to protect open source development at large from the potential fallout of it breaking down eventually, while they probably don’t mind that the AGPL exists. At least that’s the vibe I get from reading the Google licensing site.

                                                                                                  (Disclosure: I work at Google but neither on open source licensing nor with the monorepo. I also don’t speak for the company.)

                                                                                                  1. 4

                                                                                                    As I see it, Google can’t make you do anything.

                                                                                                    Maybe I didn’t express it clearly enough, but as I was writing my comments, I was painfully aware of the possibility that I would imply that Google was making me do something, and tried hard to use words that didn’t imply that. I used words like “influence” instead.

                                                                                                    And it could be argued that’s a good thing, as it puts libre creators more in touch with the real needs of industry. It’s the creator’s choice whether to acknowledge and adapt to that influence, or to bend to it entirely.

                                                                                                    Sure… That’s kind of what I was getting at when I wrote this:

                                                                                                    I’m not saying any of this is particularly wrong, to be honest. I am an individualist at heart so I generally regard this sort of thing as okay from an ethical or legal perspective. But still, emotionally, it was jarring.

                                                                                                    Anyway, I basically fall into the camp of “dislike all IP.” I’d rather see it abolished completely, for both practical and ideological reasons. Then things like copyleft can’t exist. But, abolishing IP would change a lot, and it’s hard to say how Google (or any company) would behave in such a world.

                                                                                                    1. 2

                                                                                                      Anyway, I basically fall into the camp of “dislike all IP.” I’d rather see it abolished completely, for both practical and ideological reasons.

                                                                                                      Maybe we should turn Google into a worker coop 😉 Then its employees could change IP policy like you say, the same way they successfully protested the deals w/ China & the US military.

                                                                                            2. 3

                                                                                              There is not “a Google” that is making amoral decisions for its global benefit . There is an office of humans that try their best and have good intentions.

                                                                                              Mike Hoye wrote a short article called “The Shape of the Machine” a couple of months ago that examines the incentives of multiple teams in a large company. Each team is doing something that seems good for the world, but when you look at the company as a whole its actions end up being destructive. The company he’s talking about also happens to be Google, although the lesson could apply to any large organization.

                                                                                              I definitely agree with you that Google has lots of capable, conscientious people who are doing what they think is right. (And to be honest, I haven’t thought about the licensing issue enough to be able to identify whether the same thing is at play here.) I just think it’s good to keep in mind that this by itself is not sufficient for the same to be said for the organization as a whole.

                                                                                            3. 9

                                                                                              This is exactly what I came here to say. Basing an argument on your own interpretation of a license is a great way to get into legal trouble. Not only is there the risk that a judge in a court of law may disagree with your interpretation but there is also the risk that you will invite litigation from others that have a different interpretation and disregarding the risk of losing that litigation that litigation has a cost.

                                                                                              So by using AGPL you incur not only the risk of having the wrong interpretation once it is tested in court but also the risk of an increase in costly litigation over time. This risk is further magnified by your size and how much larger it makes the target on your back.

                                                                                              1. 12

                                                                                                Basing an argument on your own interpretation of a license is a great way to get into legal trouble

                                                                                                The article starts with “I’m not a lawyer; this is for informational purposes only”, and then proceeds to make strong un-nuanced claims about the license and even proceeds to claim that Google’s lawyers are incompetent buffoons and/or lying about their interpretation. Saying you’re not an expert and then pretending you are in the very next sentence is pretty hilarious. It’s abundantly clear this article is to support the author’s politics, rather than examine legal details.

                                                                                                1. 6

                                                                                                  I’m not a lawyer; this is for informational purposes only

                                                                                                  I believe that Americans write that type of disclaimer because it is illegal over there to practice law without a license, and articles about software licenses can easily wander into dangerous territory. So based on that, I think it’s unfair to hold that up as a point against the article.

                                                                                                  Disclaimer: I’m not a lawyer; this is for informational purposes only.

                                                                                                  1. 1

                                                                                                    I started to call that tactic ‘joe-roganizing’. He does the same: “I don’t know anything about this.”, Then, in the next sentence: ‘[very strong opinion] - everyone who disagrees is surely stupid….’

                                                                                                2. 9

                                                                                                  I worked at a startup where we had a massive compliance burden (yay FDA!) and so had even fewer resources than usual. One of my jobs as engineering lead there was to go and audit the tools and source that we were using and set guidelines around what licenses were acceptable because we could not afford the lawyer time if there were any issues.

                                                                                                  If the AGPL had been tested in court, I think companies would be a bit more chill about it, but I reckon that nobody wants to bankroll a legal exploration that could turn out very much not in their favor.

                                                                                                  One of the annoying things too about licensing, especially with networked systems and cloud stuff, is that the old reliable licenses everybody basically understands (mostly) like BSD and MIT and GPL and LGPL were made in a (better) world where users ran the software on machines they owned instead of interacting with services elsewhere. We still haven’t really identified an ontology for how to treat licensing for composed services on a network, versus how to handle services that provide aggregate statistics for internal use but not for end users, versus dumbly storing user data, versus transforming user data for user consumption.

                                                                                                  1. 4

                                                                                                    What’s the cost of being wrong and having Google required to publish all of their source code?

                                                                                                    That’s not how the AGPL works.

                                                                                                    The AGPL does not force you to distribute anything.

                                                                                                    If they’re “wrong”, they are in breach of contract. That’s it. They can then remedy that breach either by ceasing use of that software or by distributing their changes, or even by coming to some alternative agreement with the copyright holders of the AGPL’d software in question.

                                                                                                    1. 2

                                                                                                      This seems like a nit-pick. The point of my question was to provoke thought in the reader about the costs of violating the license. What are those costs? Can you say with certainty that they will be small? I’m pretty sure you’d need to be a lawyer to fully understand the extent here, which was my way of saying, “give deference where it’s due.”

                                                                                                      I personally think your comment is trying to minimize what the potential costs could be, but this isn’t theoretical. Oracle v. Google is a real world copyright case that has been going on for years and has almost certainly been extremely costly. I don’t see any reason why an AGPL violation couldn’t end up in the same situation.

                                                                                                      1. 4

                                                                                                        It’s an actual misconception that many people have, and I don’t think it’s good to perpetuate it.

                                                                                                        1. 2

                                                                                                          I guess that’s fair, but it seems like splitting hairs to me. Even you said “distributing their changes” as a possible remedy, and there’s a fine line between that and “publish all of their source code.” It really depends on how the law and license is interpreted, and nobody knows how it will be. So lawyers guess and they guess conservatively.

                                                                                                          1. 0

                                                                                                            The easiest way not to perpetuate it is to not use the AGPL.

                                                                                                      2. 3

                                                                                                        Thanks for saying this. I don’t work at Google, but I know many people who work at it and other large companies and have talked with them about license policy, and the article just reeks of ignorance as to how corporate lawyers work; even for relatively small companies.

                                                                                                        There’s no ideology here, there’s just lawyers doing what they were hired to do: use an abundance of caution to give the company as ironclad a position as possible.


                                                                                                        Hell, forget WTFPL, I’ve been waved off considering triple licensing of (approved) licenses by Googlers as “the lawyers would never go for this”. The lawyers are going to go for well understood, battle tested licenses where the failure cases aren’t catastrophic.


                                                                                                        Besides that it seems like the article misunderstands what constitutes a “derivative work”, if the article’s definition of “derivative work” (i.e., the code must be modified, not simply “used as a dependency”) was the one used by the *GPL licenses, then there would be no need for LGPL to exist.

                                                                                                        1. 1

                                                                                                          but as a rule of thumb, if you form an argument on knowing the intentions of other humans, it’s probably a bad argument

                                                                                                          This is not true.

                                                                                                          Firstly, the rule for another person and the rule for CORPORATIONS are completely different. Corporations do not operate like people do. When corporations are small, they sort of do, but as they grow larger then they become more corporations like.

                                                                                                          Secondly, it is impossible to know the intentions of other humans. So by this argument, no argument is ever good.

                                                                                                          We might give people the benefit of the doubt, because people are mostly good. They are ruled by an ethical system, built into their brain, to socialise and cooperate. Corporations do not have this internal system. Their motivational system is entirely profit based, and therefore you cannot treat them like people.

                                                                                                          If you have been alive long enough and paid attention to what corporations do, and especially google, the idea that they consider AGPL hostile, and wish to limit its influence and expansion, is highly plausible. How will they limit its influence? They could ban it completely, and then publish a document detailing why they think it’s bad. That’s highly plausible.

                                                                                                          Is risk-averse lawyering a factor? Most likely yes. But risk-averse lawyer adds to the hostility argument. Having received the advice from lawyers to not use AGPL, leadership would easily conclude that a limit to AGPL spread would give them the best chance of getting free software and have their way.

                                                                                                          Additionally, your steelman argument does not explain why google publishes that they do not like AGPL. They could keep it entirely internal. Why do you think they would do that? Free legal advice to competing startups?

                                                                                                          1. 3

                                                                                                            Firstly, the rule for another person and the rule for CORPORATIONS are completely different. Corporations do not operate like people do. When corporations are small, they sort of do, but as they grow larger then they become more corporations like.

                                                                                                            That makes sense in a certain light, sure. But I don’t see what it has to do with my point.

                                                                                                            Secondly, it is impossible to know the intentions of other humans. So by this argument, no argument is ever good.

                                                                                                            I don’t really agree. It might be true in the strictest philosophical sense, but that needn’t be our standard here. Intent is clearly something that we as a society have judged to be knowable to an extent, at least beyond some reasonable doubt. Just look at the criteria for being convicted of murder. It requires demonstrating something about the intent of someone else.

                                                                                                            Why do you think they would do that?

                                                                                                            When was the last time you saw any company publish legal advice generated by internal review?

                                                                                                            If you have been alive long enough and paid attention to what corporations do, and especially google, the idea that they consider AGPL hostile, and wish to limit its influence and expansion, is highly plausible. How will they limit its influence? They could ban it completely, and then publish a document detailing why they think it’s bad. That’s highly plausible.

                                                                                                            I think you’ve really missed my point. If the OP were an article discussing the plausibility of one of any number of reasons why Google published an anti-AGPL policy, then I would almost certainly retract my comment. But that’s not what it was. It’s a one sided turd without any consideration of alternative perspectives or explanations at all.

                                                                                                        1. 5

                                                                                                          An interesting take. Glad to see Linux is still an option and really surprising that perceived performance between KDE and Gnome have flipped.

                                                                                                          • Surprising to hear that there isn’t a Google Drive client on Linux (as I recall there used to be one), don’t many engineers at Google use “Goobuntu”? Perhaps they don’t open source the client for public use.
                                                                                                          • I know that Steam works on both, do you find that your OS dictates what games you play most, or no?
                                                                                                          • OP didn’t mention the screen quality or eyesight issues, curious if there is a noticeable difference between the two? As I suspect there would be.
                                                                                                          1. 9

                                                                                                            Goobuntu (Ubuntu) was replaced by gLinux (Debian) a couple of years ago for maintainability reasons. They’re functionally the same though.

                                                                                                            The machines that we develop on is about what we think gets the programming job done, not as an indication of the target platform.

                                                                                                            My guess is that the numbers were crunched and found that Linux users would not have made up enough share to warrant a client. I’ve never missed it, I do all my office work directly in the browser, and we have company-wide disk snapshotting for backup purposes. On my laptop (which isn’t snapshotted) I use RSync.

                                                                                                            1. 1

                                                                                                              Ahh interesting, thanks for the update.

                                                                                                              The machines that we develop on is about what we think gets the programming job done, not as an indication of the target platform.

                                                                                                              Of course, but I’d imagine that some engineers would want to have native document sync with GDrive. I also use GDrive, but honestly found the syncing annoying when the usage flow is nearly always New tab > drive.google.com > search doc. But certainly someone on gLinux wanted to keep it? :shrug:

                                                                                                              What exactly are you rsync’ing against?

                                                                                                              1. 4

                                                                                                                Laptop (not snapshotted) > Desktop (snapshotted)

                                                                                                                But yeah, we just use the web interface for all docs writing stuff. For documentation (not documents), we have an internal Markdown renderer (think GitHub wiki with internal integrations). No one writes documents outside of a centralized system, and so has no need to back them up with a client.

                                                                                                            2. 6

                                                                                                              (I’m not OP) I recently started playing games on Linux via Steam. For reference, I’ve never been a Windows gamer – had been a console gamer up to that point. To answer your question:

                                                                                                              do you find that your OS dictates what games you play most, or no

                                                                                                              Pretty much. I play only what will work, so that means the game must either officially be supported under “Steam OS + Linux”, or work via Proton. But this is just me. Others are free to dual boot, which, of course, vastly broadens their spectrum of available games.

                                                                                                              1. 5

                                                                                                                I used to be a dual booter, but since Proton, so many games have been working on Linux that I stopped booting to Windows. Then at some point my windows installation broke and I never bothered to fix it.

                                                                                                                1. 3

                                                                                                                  That’s cool. However, I think we’re a ways off from totally being on par with native Windows. Several anti-cheat systems are triggered by running under Linux. And protondb shows that there are still many games that don’t run.

                                                                                                                  That said, things are improving steadily month by month, so that’s encouraging.

                                                                                                                  1. 2

                                                                                                                    That’s true, I didn’t mean to imply that all games I would like to play work on Proton now. But enough of them work now that instead of dealing with Windows for a game that doesn’t work on Proton, I usually just go and find something else that does.

                                                                                                                    If you have a group of gaming buddies, that obviously won’t work, though. It won’t be long before they get hooked up to a Windows-only game.

                                                                                                                2. 2

                                                                                                                  Same here, I find the biggest area where I need to switch back to windows is for multiplayer. I used to lan a lot and still have many of those contacts. I find a lot of games that have a host/client multiplayer, for example RTS games, have issues on linux even if the single-player works flawlessly. This means I have to keep dual boot available.

                                                                                                                  Even though linux does strongly influence which games I play, the range and variety is amazing and it is not reducing the quality or diversity of games I play at all. There are just a few windows only titles that I might play slightly more if they were available on linux.

                                                                                                                  While we are on the subject, what are people’s recommendations for a gaming distro? I am on Mint at the moment which is good, but I like to have options.

                                                                                                                  1. 1

                                                                                                                    I don’t know if I’d call it a gaming distro, but I have been using Gentoo for many years, and it seems to be doing just fine with Steam (which I just installed a couple months ago).

                                                                                                                    1. 1

                                                                                                                      Frankly, I’m not sure you need a gaming distro. I’ve had little issues running Steam and Wine (using Lutris) games on Void Linux, Debian, etc. (Mind you: always using Nvidia.)

                                                                                                                      1. 2

                                                                                                                        I actually phrased that really badly, thanks for the correction. I tried out a dedicated gaming distro and it was rubbish. Mint is a variation on Ubuntu.I was looking at Debian to try next.

                                                                                                                        It seems like the thing to look for is just something well supported with all the common libraries, so most big distros appear to be fine for gaming. The reason I am not entirely pleased with Mint is that they seem a bit too conservative in terms of adding new stuff to the package manager when it comes out. On the one hand that makes it more stable, but on the other games use a lot of weird stuff sometimes and it makes things a bit messy if you have to install things from outside the package manager.

                                                                                                                  2. 4

                                                                                                                    perceived performance between KDE and Gnome have flipped

                                                                                                                    Gnome Shell is huge and slow. A Canonical engineer (Ubuntu has switched from Unity to Gnome) has recently started to improve its performance with very good results but this also shows how terrible the performance was before: memory leaks, huge redraws all of the time and no clipping, … Now this needs to trickle down to users and the comments might change then.

                                                                                                                    PS: KDE has not gotten a lot more bloat or slowness over the years and I don’t know if Gnome will be faster and lighter or if both will be similar.

                                                                                                                    1. 2

                                                                                                                      The lack of a Google Drive client is shameful, but I tried Insync and it’s the best money I’ve ever spent on a Linux app. Much better than the Mac version of Google Drive which was super buggy

                                                                                                                    1. 3

                                                                                                                      So, and I mean this only slightly facetiously, is there any point in learning any language other than Rust at this point? I feel like all the momentum is with Rust and that languages like Go (which I prefer to Rust), the ML languages, and C++ are all dead in the water and basically just in maintaining-existing-codebases mode…

                                                                                                                      In other words, for the vast majority of non-web/non-desktop projects it would seem silly given the current zeitgeist to start them in any language other than Rust/JavaScript.

                                                                                                                      (I say this because the Linux kernel is notoriously conservative on language use, and with good reason…obviously other languages are gonna be around a long time but it seems like the only compiled typed language I hear about anymore is Rust.)

                                                                                                                      1. 11

                                                                                                                        the ML languages … are dead in the water

                                                                                                                        Haskell and Ocaml are still moving forward well. Haskell recently merged in Linear Types, which goes a long way to making the type system both richer and more intuitive.

                                                                                                                        C++ are all dead in the water

                                                                                                                        Take a look at C++20. It has some great features. Some undoubtedly inspired by Rust, but many others that have been working their way into the standard for over a decade. C++20 has lambdas, option types, awkward[1] sum types, designated initializers, and more.

                                                                                                                        In other words, for the vast majority of non-web/non-desktop projects it would seem silly given the current zeitgeist to start them in any language other than Rust/JavaScript.

                                                                                                                        At the end of the day, Rust is still a low-level language [2], which means the programmer is in charge of keeping track of when data is copied, when references to data are passed around, and when data goes out of scope. While the borrow checker certainly helps in this process, it’s still something that the programmer needs to be aware of while coding, and this has its own cognitive load. Often times, when programmers reach for a low-level language, it is specifically because they want to tackle some aspect of memory management (whether that’s custom allocation, data sharing, real-time performance, or other things) differently from the way a more standard managed runtime would. This can lead to situations where the borrow checker can actually make it more, rather than less, difficult (due to non-standard memory management techniques that the programmer consciously wants to undertake) to develop and reason about code.

                                                                                                                        Rust is also difficult to use in the following situations:

                                                                                                                        • Interfacing with binary libraries
                                                                                                                        • Using an alternate libc
                                                                                                                        • Using a custom memory allocator
                                                                                                                        • Developing for the Android NDK

                                                                                                                        Moreover, Rust is a complicated language. The surface area of the language is large and that makes understanding its nuances both difficult and, at times, time consuming. Other languages like Nim and Zig take alternate decisions that also enable low-level development with greater safety and lower cognitive load than C.

                                                                                                                        Then there’s the world of scientific computing. C++, C, and Fortran have long been the stalwarts of scientific computing, but now we have a new crop of dynamic languages like Python, Julia, and R, that are all great. Rust still lacks interfaces to many of the really big scientific-computing frameworks[3], whereas many frameworks (such as Stan or CLASP) are written in C++ and offer C++ libraries out of the box, along with Python, R, and sometimes Julia wrappers. One can certainly wrap the interface for these libraries themselves into Rust, but in C++ or Python, I can just grab the library and start developing.

                                                                                                                        I think it’s unfortunate that due to the vocal Rust fanbase on certain parts of the internet that some folks feel pressured to use Rust. Rust is a fantastic language (IMO), but there certainly are interesting, performant, and practical alternatives out there that can often be better for certain usecases.

                                                                                                                        [1]: I call them awkward because they aren’t as neatly baked into the language as they are in Rust, but C++ offers the well written any and variant types.

                                                                                                                        [2]: It’s funny because literature from a few decades ago largely considered C++ to be a “higher level language”, but here we are.

                                                                                                                        [3]: Others often call this machine learning, but the proliferation of scientific computing is not at all restricted to ML. Stan is a Bayesian inference library and CLASP is an Answer-Set Programming language/environment.

                                                                                                                        1. 9

                                                                                                                          Take a look at C++20. It has some great features.

                                                                                                                          I think C++’s problem has never been its lack of features.


                                                                                                                          My approach has served me quite well: If I see new software being written in C or C++, I’m going to ask “why?” – and if there is no really really convincing reason – I stay away.

                                                                                                                          1. 4

                                                                                                                            Developing for the Android NDK

                                                                                                                            With my initial contributor of Android support for Rust hat on, I am curious about this. Yes, it always could be better, but what’s the specific problem? Rust for Android is production ready, in the literal sense of the word. It has been years since Firefox for Android (>100M installs) shipped millions of lines of Rust code in production. Cloudflare also shipped WARP for Android, whose WireGuard implementation is written in Rust.

                                                                                                                            1. 3

                                                                                                                              It’s funny because literature from a few decades ago largely considered C++ to be a “higher level language”, but here we are.

                                                                                                                              “High” is a great term for describing languages this way, because it’s inherently context dependant; you can be high on a ladder or high on an aeroplane. That the heights are so different is not a problem; you wouldn’t use an aeroplane to clean your roof.

                                                                                                                              1. 2

                                                                                                                                Haskell recently merged in Linear Types

                                                                                                                                I guess you mean GHC, not (standard) Haskell, insofar that even exists.

                                                                                                                              2. 4

                                                                                                                                I think for down and dirty systems programming, probably not.

                                                                                                                                For distributed systems, Java is still in the mix at most companies. Rust isn’t really what I would call “web yet” (despite what the web site says) and Go is a much easier lift for that sort of backend work.

                                                                                                                                I think there is still a good number of options on the backend.

                                                                                                                                For the front end, I would only consider TypeScript at this point.

                                                                                                                                1. 2

                                                                                                                                  i’m personally perfectly happy using ocaml, and i think the language has a decent bit of momentum these days. it’s a really good statically compiled applications language; it’s not quite a systems language but then neither is go, both of them depend on a gc.

                                                                                                                                  for a systems-level language i’m really hoping that D will catch on as cleaner than C++, more capable than go and easier to use than rust, but it doesn’t seem to be gaining popularity as fast as it should. rust is a perfectly fine language too and i keep meaning to do a serious project in it, but it definitely has a higher entry barrier than D does.

                                                                                                                                  1. 2

                                                                                                                                    I don’t think it’s so black and white. Go has some serious momentum right now. It’s a very pragmatic and practically useful language. Rust is great but has many downsides, e.g. the compiler isn’t anywhere close to as fast and it is far more complex to learn and use.

                                                                                                                                    1. 4

                                                                                                                                      Go has occupied the “devops tools” niche, but thankfully it didn’t really take off anywhere else.

                                                                                                                                      the compiler isn’t anywhere close to as fast

                                                                                                                                      It’s gotten really good at being incremental though. Even on my low-power laptop, cargo run after changing a couple source files is pretty quick. Faster than TypeScript for sure. Also I wonder how many Linux users are just losing lots of time to linking with some awfully slow linker like GNU BFD ld instead of LLD.

                                                                                                                                      1. 1

                                                                                                                                        but thankfully it didn’t really take off anywhere else.

                                                                                                                                        Not sure what you mean here. It’s the language of the cloud. Every major cloud provider has an official Go SDK and the Go team at Google is actively involved in supporting this. Many of the CNCF projects are written in Go.

                                                                                                                                        e.g. see go-cloud or the support in gcloud functions.

                                                                                                                                        For CLI tools as well, it’s become preferred over scripting languages like python and ruby. e.g. fzf is written in Go, the new GitHub CLI is in Go. While rust is used in newer CLIs as well, it’s usually only for performance critical CLIs like ripgrep.

                                                                                                                                        It’s gotten really good at being incremental though.

                                                                                                                                        Agreed. I still appreciate just how insanely quick Go is, especially when building on a new machine or pulling a dependency. I never have to really wait for things to compile.

                                                                                                                                        1. 4

                                                                                                                                          Many of the CNCF projects are written in Go

                                                                                                                                          That is exactly what I meant by ‘the “devops tools” niche’! Maybe I should’ve used the “cloud” buzzword instead of “devops”, but I like calling it “devops”.

                                                                                                                                          e.g. fzf is written in Go

                                                                                                                                          fzf is hardly a unique tool, I have a list of these things here :) Personally I use fzy, which is pretty popular and actively developed, is packaged everywhere, has a very good matching algorithm.. and is written in C, haha.

                                                                                                                                          the new GitHub CLI is in Go

                                                                                                                                          Yep, that kind of thing is what I’m not very happy about, but it’s still a pretty small amount of things still, and I can successfully avoid running any Go code on any of my personal machines.

                                                                                                                                          1. 3

                                                                                                                                            Yep, that kind of thing is what I’m not very happy about, but it’s still a pretty small amount of things still, and I can successfully avoid running any Go code on any of my personal machines.

                                                                                                                                            Why does it matter whether a binary you use on your machine is written in Go or not? If you’re building it from source, presumably your distribution’s build scripts should take care of orchestrating whatever Go code is necessary in order to compile the package; and if you’re just pulling an executable why does it matter what language was used to produce the binary?

                                                                                                                                            1. 6

                                                                                                                                              I think GP’s answer is great and insightful, just adding my own take:

                                                                                                                                              I try to avoid code by people who think LARPing programming-in-the-1960ies is a reasonable choice to build things in 2020, because I’d rather not find out which other “reasonable” choices they have made further down the line.

                                                                                                                                              Also, the community’s anti-intellectualism is off-putting for me.

                                                                                                                                              1. 6

                                                                                                                                                I’m the kind of person who cares about how the sausage is made :) If I can “boycott” things I just don’t like, I’ll do it. Here’s a great criticism of the language, but what made me hate it was the internals of the implementation:

                                                                                                                                                • the fully static binary thing, not even using libc syscall wrappers
                                                                                                                                                  • first obvious practical problem: you can’t hook syscalls with LD_PRELOAD in go binaries! I don’t want any binaries where LD_PRELOAD does nothing.
                                                                                                                                                  • they do raw syscalls even on FreeBSD, where libc is the public API and raw syscalls are not. They completely ignored FreeBSD developers’ messages about this and went ahead with the private API. Yeah sure, the syscalls are backwards compatible, it works fine (until someone disables COMPAT_FREEBSDn kernel options but whatever)..
                                                                                                                                                  • but porting to a new platform is hell! Yeah, for the most popular ABI (Linux) there’s enough contributors to write custom syscall wrappers for all CPU architectures, but any {less-popular OS + less-popular CPU ISA} combo just won’t be supported for a long time. I’ve started porting Go to FreeBSD/aarch64, abandoned it in frustration, but others have picked it up and finished it. Cool, I guess. But we’ll have the same problem with FreeBSD/powerpc64, FreeBSD/riscv64 etc! (This is the most “practical” consideration here, yes.)
                                                                                                                                                • which brings me to how these syscall wrappers (and other things) have to be written.. Go uses a very custom toolchain with a very custom assembler which is completely alien to normal unix conventions. It’s not easy to write it. Oh, also, it is rather half-assed (this affects applications way more than it affects porting Go itself):
                                                                                                                                                  • it doesn’t support SIMD instructions, and if you want to call something fast written in C or normal sane assembly, you’d have to take the overhead of cgo (because the Go calling convention is custom)
                                                                                                                                                    • and to not take the overhead, people have written things like c2goasm. Just read that readme and let that sink in!!
                                                                                                                                                  • it doesn’t even seem to support all addressing modes of amd64! When writing a binding to SIMD base64, I couldn’t use c2goasm because I couldn’t express mov al, byte ptr [rax + base64_table_enc] in Go assembly. (There were probably ways around it, like only passing the offset into the normal-assembly functions and letting them use that offset to look up in the table.. but I was already fed up with the awfulness and just used cgo.)
                                                                                                                                                1. 2

                                                                                                                                                  (I’d like to point out that I too care how the sausage is made and I loved your phrasing on that point.)

                                                                                                                                                  Obviously what follows is solely my opinion, but I feel like some of those criticisms are unjustified.

                                                                                                                                                  From your comment:

                                                                                                                                                  The static binary thing is a huge boon in some situations. We have a remarkably heterogenous mix of Linux versions in the field and yet the same Go binary “just works” on all of them. That’s an enormous burden off our backs.

                                                                                                                                                  That Go’s assembler is weird is I suppose problematic, but for the “average user” of Go that’s just an implementation detail that can be safely ignored.

                                                                                                                                                  From the linked rant:

                                                                                                                                                  Yes the file permissions APIs are weird because the models for Windows and *nix are so different. I feel like that’s a very specific issue that the rant generalizes to the whole language. In general, a large part of the rant focuses on how Go doesn’t do the right thing for Windows which may be true but it doesn’t seem to be quite that bad…I know a lot of people who have written large Go codebases that run on Windows and are very happy with it. In the rant it comes across, IMHO, as nitpicking.

                                                                                                                                                  Later on the rant goes on about how a Go project pulls in a bunch of dependencies and then transitively pulls in even more and so on…I feel like comparing that to Rust isn’t quite fair. I’m not super-familiar with Rust but several of the projects I’ve looked at pull in huge numbers of crates which pull in more crates and so on. It seems like it might even be worse in Rust because of the smaller standard library and, given the Actix controversy, it doesn’t seem like you can rely on third-party Rust crates being inherently safe.

                                                                                                                                                  Finally, though, and these are again my opinion:

                                                                                                                                                  • Rust feels chaotic. There’s no formal specification of the language. The Rustonomicon says this:

                                                                                                                                                    Unfortunately, Rust hasn’t actually defined its aliasing model. 🙀 While we wait for the Rust devs to specify the semantics of their language, let’s use the next section to discuss what aliasing is in general, and why it matters.

                                                                                                                                                    That does not fill me with warm fuzzies.

                                                                                                                                                  • Documentation seems lacking. There are a lot of TODOs everywhere.

                                                                                                                                                  • There’s a new release every six weeks so I always feel like I’m playing catch-up. The “Editions” mechanism seems to help some here, but I went to try to build a Rust program (alacritty) and my Rust version was too old…and it wasn’t that old.

                                                                                                                                                  • I don’t like the community. I know that this may come as a shock but I have gotten this “superiority complex” feeling from the Rust community. Any criticism of or concerns about the language seems to be met with “no, you’re wrong, Rust is the best! Your language sucks! Why would you use any tool other than Rust?” Sometimes it’s more polite but it’s still there. Any time someone talks about another language (Go, C++, whatever), someone has to come in and say “why don’t you rewrite it in Rust?” There have been times where I’ve seen on SO or Twitter people almost being made to feel foolish for daring to use some language other than Rust.

                                                                                                                                                  • Again on the community, one of the core developers made a joke about C being designed by men and breaking constantly and COBOL being designed by women and just working. When a guy on Twitter said that was kinda sexist, she accused him of “mansplaining” and said he was telling her the joke was sexist rather than understanding its “obvious meaning” (which apparently wasn’t so obvious)…which I found kind of bothersome, especially since the community seemed to agree and anyone who took offense was called sexist (and trust me, I’m as leftist/feminist as they come but that doesn’t and shouldn’t mean that I hate men). This again felt like the “Rust community is superior” thing again: the Rust community was correct and those who disagreed with them were wrong, inherently so.

                                                                                                                                                  1. 2

                                                                                                                                                    We have a remarkably heterogenous mix of Linux versions in the field and yet the same Go binary “just works” on all of them

                                                                                                                                                    Sure, do that on Linux where the syscalls are the public API. Zig does that too, but IIRC it has an option to use libc on Linux, so you could make LD_PRELOAD work and everything, say when you’re building distro packages or personal binaries that you don’t want running on ancient distros.

                                                                                                                                                    I just really don’t like that a) there’s no choice, only direct usage of syscalls and b) this is forced on platforms that don’t consider raw syscalls as public API.

                                                                                                                                                    (Also, something dynamically linked to glibc will work on all glibc distros of the last N years if you use the headers from an N years old version. With a language like Rust that has its own definitions of libc symbols instead of C headers, these definitions usually are as backwards-compatible as possible already.)

                                                                                                                                                    for the “average user” of Go that’s just an implementation detail that can be safely ignored

                                                                                                                                                    Yes. Well, I’ve seen what’s inside, so it’s my mission to tell everyone how cursed it is there. Feel free to ignore me!

                                                                                                                                                    After all, all of computing is cursed on the inside somewhere :D But these particular experiences are what made me scream at computers the most, so I’m sharing them. Some people do care about implementation details of a thing even when they don’t modify that thing specifically.

                                                                                                                                                    There’s a new release every six weeks so I always feel like I’m playing catch-up

                                                                                                                                                    Use nightly! :P

                                                                                                                                                    someone has to come in and say “why don’t you rewrite it in Rust?”

                                                                                                                                                    At least on /r/rust this kind of stuff usually downvoted into oblivion.

                                                                                                                                                    Twitter is a trash fire that brings the worst out in people. Heck, some people tweeting that might not have written a line of Rust ever, just shitposting memes they’ve heard somewhere.

                                                                                                                                                    trust me, I’m as leftist/feminist as they come but that doesn’t and shouldn’t mean that I hate men

                                                                                                                                                    Well that should mean hopefully having a (n extremely-online ironic millennial) sense of humor :) I wouldn’t start serious Discourse™ in defense of the joke, but I’m okay with the joke. “sexism against men” isn’t really meaningful because men are the more dominant group in current societies. (oops did I just start a Discourse?) Anyway tbh you don’t have to “hate” anyone to find this funny.

                                                                                                                                                    1. 3

                                                                                                                                                      trust me, I’m as leftist/feminist as they come but that doesn’t and shouldn’t mean that I hate men

                                                                                                                                                      Well that should mean hopefully having a (n extremely-online ironic millennial) sense of humor :) I wouldn’t start serious Discourse™ in defense of the joke, but I’m okay with the joke. “sexism against men” isn’t really meaningful because men are the more dominant group in current societies. (oops did I just start a Discourse?) Anyway tbh you don’t have to “hate” anyone to find this funny.

                                                                                                                                                      No doubt. The joke itself was funny. What bothered me was that someone responded with a polite “hey, that seems uncool” and then that person was called “sexist” and a “mansplainer”. I’m all for off-color humor but if someone you’re ostensibly trying to welcome to the community says that it bothered them, the correct response is “sorry, it was a joke but I could see how it could be taken in that manner and I apologize”…not attacking them. That this behavior was from a Rust core team member made it even worse.

                                                                                                                                                      But that whole thing was really just a footnote. What pushes me away more is the constant slamming of other tools and languages, which really gets grating. I don’t hang out on Reddit (if I wanted to hear about how COVID-19 is a plot by Obama to make Trump look bad or how same-sex marriage is Satanism I’d just talk to my father-in-law) but the…zealous…behavior of Rustaceans pops up just about everywhere I frequent, including my beloved lobste.rs from time to time..

                                                                                                                                                      Long story short (too late!), I like Rust quite a bit, but there are some negatives that I wish would be addressed.

                                                                                                                                    1. 8

                                                                                                                                      Can someone please explain how it is possible that one malfunctioning SDK can break the entire app? IIUC this is due to Facebook login but still, why can’t the app continue to function regularly?

                                                                                                                                      Or is it broken only for whoever actually logged in with Facebook in the first place?

                                                                                                                                      1. 24

                                                                                                                                        This is due to Facebook’s idiosynchratic engineering practices.

                                                                                                                                        At least last time this happened (https://github.com/facebook/facebook-ios-sdk/issues/1373), two months ago*, just including the SDK was enough to bring your app down before it had even initialised because Facebook ran code in the Objective-C class load method, which no sane person would override, let alone do network calls in.

                                                                                                                                        That’s the idiosynchratic part, but it spells disaster when combined with Facebook’s amateurish development practices: The SDK will load objects from the FB backend, parsing them with brute force, expecting them to always be well-formed. This, combined with no working internal CI/CD system, leads to situations like this, where anyone doing a configuration error on a backend service can bring down millions of clients without them even calling the code in question.

                                                                                                                                        1. 10

                                                                                                                                          “Idiosyncratic” seems like an exceedingly polite way to put it.

                                                                                                                                          1. 5

                                                                                                                                            Realized today that I’m more dismayed by the tech public’s reaction to this than the failures of engineering displayed. Specifically, a bunch of people over at the orange site believe it isn’t fully preventable when the fix is simply to see bad engineering decisions for what they are: static initialization is dangerous and has no place in a SDK deployed at FB’s scope. Full stop.

                                                                                                                                            1. 2

                                                                                                                                              Unfortunately, there are tons of SDKs out there that does static initialization. When brought this issue up with another big-name SDK during integration, the response is in the line: we need to do some initialization, and relying on SDK users to call “init” method properly is a no-go based on what we experienced. That sounds plausible, but the solution is to make sure you have init’ed upon the first call to your library, and this can be solved through tooling (adding a custom LLVM pass to call your init method if not through your public API).

                                                                                                                                            2. 2

                                                                                                                                              Do you have a citation for "no working internal CI/CD system"?

                                                                                                                                              1. 2

                                                                                                                                                They have a CircleCI instance, but if it did continuous integration and delivery, it would not be all-green.

                                                                                                                                              2. 2

                                                                                                                                                The SDK will load objects from the FB backend, parsing them with brute force, expecting them to always be well-formed

                                                                                                                                                I spit water out of my mouth as I read it.

                                                                                                                                              3. 9

                                                                                                                                                It’s just shoddy code from Facebook, and it’s a hot mess, because their SDK calls home in the initializer, IIRC, and a “bad” result that causes it to throw will blow up any app that includes the SDK, even if the app doesn’t use FB login. It’s a total catastrophe.

                                                                                                                                                1. 3

                                                                                                                                                  To add my speculative point to the good substantive answers above…

                                                                                                                                                  Another part of the problem is our industry has never really adopted REST as a way of architecting big public APIs. So instead of accessing them over HTTP using common patterns every API is expected to have a client library implementing the API’s custom, closed RPC-over-HTTP architecture.

                                                                                                                                                  (I don’t have any solutions, I’m just lamenting.)

                                                                                                                                                  1. 1

                                                                                                                                                    Which industry are you referring to? Serious question.

                                                                                                                                                    1. 2

                                                                                                                                                      Software. Or that part of it that creates Web APIs.

                                                                                                                                                  2. 4

                                                                                                                                                    I’m guessing this is why a bunch of apps on my iPhone weren’t working this morning (GroupMe, Spotify, etc.). I wasn’t logged in with FB, for what it’s worth.

                                                                                                                                                  1. 33

                                                                                                                                                    Someone on Reddit put it best:

                                                                                                                                                    Java devs never fail to be parodies of themselves.

                                                                                                                                                    This is so spot on.

                                                                                                                                                    Java is actually a good language, it’s the ecosystem that kills it for me. By “the ecosystem”, I don’t just mean the tooling (e.g. Java build tools are universally awful AFAICT), but the developers themselves. So much Java I read is just “magic”. Magic annotations, magic dependency injection, interfaces over classes that there is only one of etc. etc.

                                                                                                                                                    The author points out very good failures in the way its been architected, but the code in the OP isn’t all that strange looking to me as Java, and that’s a pretty damning statement.

                                                                                                                                                    I wish Java had a better audience around it. The Kotlin ecosystem seems better, but I’ve never used it.

                                                                                                                                                    1. 25

                                                                                                                                                      (edit: my first pass at this came off a little overly negative in a way that I think betrays the seriousness of my point)

                                                                                                                                                      I’m not sure Java actually is a good language. My first introduction to Java was as the primarily language that was used in college, and even as a pretty green programmer them (I’d started writing C and C++ a few years earlier in high school, but I was definitely not a good programmer), I found it awfully questionable. In the intervening 15 years I’ve managed to avoid it, until quite recently. It’s been really eye-opening to see how the language has evolved in that time, but not really in a good way. Perhaps it’s because I’ve largely written OOP off as a bad idea that shouldn’t have ever taken off like it did, and is certainly outstaying it’s welcome, but I find that Java, and even the JVM itself, to be a masters class in solving the wrong problem in the most complex possible way. The complexity in java seems to be like glitter, you can’t touch anything with getting covered in it, and once it’s on you you’ll never get it off. Even working with people that I generally hold in high regard as developers, I see that the ecosystem has forced them into patterns and architecture that I think is questionable- except it’s not because to do anything better would be to try to work against every single design decision in the language and ecosystem. There’s simply no reasonable way to write good Java, the best you can reasonably hope for is to write as little java as possible, and hope the absurd complexity giltter doesn’t spread to all of your connected services by way of the blind “the whole world is Java” assumptions that the JVM ecosystem wants to make on your behalf.

                                                                                                                                                      I say Java here, but realistically I think that all JVM languages end up falling into the same gravitational well. I’ve been using Kotlin lately, and from what I’ve seen of Scala and Clojure they are all infected by the same inescabable fractally wrong view of the world that is imposed by the JVM, by way of the JVM itself being born from the primordeal ooze of bad decisions and oop-kool-aid that led to Java in the first place. Kotlin in particular suffers from being not only unable to escape the Java ecosystem, but also from generally being a poorly designed language. Everything it adds to java, it adds in such a superficial and impotent way that a slight breeze knocks over the facade and you realize you’re stuck back in the Kingdom of the Nouns all over again.

                                                                                                                                                      1. 7

                                                                                                                                                        I tend to agree about the java part. The constructs at your disposal requires you to write very very verbose code, even for simple things. But I disagree about the JVM bit. I find it a pretty good runtime system. Although it tend to eat its fair share of RAM, the GCs and the JIT are first class. Overall, you get pretty decent perf without too much thought. Also, Having written a lot of clojure, it’s vastly different from java, couldn’t be further from the Kingdom of the Nouns.

                                                                                                                                                        1. 14

                                                                                                                                                          The JVM feels to me like it was written for a world that just didn’t really ever happen. It promised cross platform compatibility, that never really materialized since there are only two real meaningful places where the jvm is heavily used these days (x86 linux servers and arm Linux phones). Even where the jvm itself is running on multiple platforms, it’s not running the same workloads across it. We would have been every bit as well off with a toolset that made native cross compilation feasible (go and rust), and probably would have been no worse off even with the old C and C++ cross compilation story. Love it or hate it, JavaScript is what actually fulfilled the promises that java made and never was able to keep.

                                                                                                                                                          Other promises that JVM made either never made sense- language interoperability always existed before java, and exists outside of it now. All the JVM did was fracture the environment by making it nearly impossible to produce native code- it’s a vampire if you look at it in terms of interoperability, unless you want to use gcc to compile your java code. The isolation and runtime management is, consistently, 90% of the work involved in deploying any java application I’ve used, and at the end of the day everyone does that work twice now because most workloads are getting deployed in cloud native containers anyway- so the JVM is superfluous there. GC is a pain in the JVM and has been done as well elsewhere without requiring the rest of the baggage of its runtime and jitter.

                                                                                                                                                          Looking at performance, I’m dubious that it has much going for it. It’s still not a contender in the same space as C or C++, and in many cases the pain of native interop make it slower than even python because python can rely on native code for a lot of heavy lifting. I’ve even seen fairly well optimized JVM code fail to keep up with reasonably (perf) naive Haskell.

                                                                                                                                                          Even with instrumentation, the supposed killer feature of the jvm, I have yet to see anything I can’t get out of a native application with native tooling and instrumentation, and the case is getting weaker by the day as more and more application telemetry moves up and down the stack away from the application itself and into either tracing layers in front of services, or tooling built around things like ebpf that live very low down in the system and allow you to instrument everything.

                                                                                                                                                          The JVM is at best a middle-of-the road performance language with a largely superfluous ecosystem. It might have been a good idea when it was created, and I have no doubt a lot of smart engineering went into its implementation, but it’s time we give it up and realize it’s a sunken cost that we need to leave to the history books as a quirky artifact of the peculiar compute and business environment of the early 90s.

                                                                                                                                                          1. 3

                                                                                                                                                            Clojure’s okay (and still way better than Java, IMO) but suffers from pretty poor error handling compared to other Lisp environments.

                                                                                                                                                          2. 4

                                                                                                                                                            I really don’t like how Java makes optimization of its runtime overcomplicated, then has the gall to make you deal with the complexity. There is no reason to be manually tuning GC and heap sizes when every other runtime, including CLR implementations, can deal with this efficiently and automatically. They might be complex, unlike the JVM, they’re not complex and making you deal with that complexity.

                                                                                                                                                            1. 3

                                                                                                                                                              Just curious what you dislike about Kotlin’s design? It seems like you make two points: that Kotlin can’t escape Java and, separately, that it’s poorly designed. I agree with the former, but in light of the former, I find Kotlin to be pretty well-designed. They fixed Java’s horrible nullness issues and even kludged in free functions to the JVM, which is neat. Data classes are a band-aid, but still help for the 80% of cases where they can apply. Same with sealed classes (I’d much prefer pattern matching akin to Rust, Swift, OCaml).

                                                                                                                                                              1. 13

                                                                                                                                                                My biggest issue is that everything feels like a kluge. Null tracking at the type level is fine, but they didn’t really go far enough with the syntax to make it as useful as it could have been- rust does better here by allowing you to lift values from an error context inside of a function. The language tries to push you toward immutability with val and var, but it’s superficial because you’re getting immutable references to largely mutable data structures without even getting a convenient deep copy. Extension methods are a fine way of adding capabilities to an object, but you can’t use them to fulfill an interface ala go, or outright extend a class with an interface implementation ala Haskell typeclasses, so you’re left with basically a pile of functions that swap an explicit argument for a this reference, and in the process you are conceptually adding a lot of complexity to the interface of an object with no good associated abstraction mechanism to be explicit about it. Even the nature of the language as a cross platform language that can target jvm, llvm, and web asm seems fundamentally flawed because in practice the language itself seems to lack enough of a stand alone ecosystem to ever be viable when it’s not being backed up by the jvm, and even if you did have a native or web ecosystem the design choices they made seem to be, as far as I can tell, about the worst approach I’ve ever seen to cross platform interoperability.

                                                                                                                                                                Ultimately the features they’ve added all follow this pattern of having pulled a good idea from elsewhere but having an implementation that seems to not fulfill the deeper reason for the feature. The only underlying principle seems to be “make java suck less”. That is, of course, a bar buried so low in the ground it’s in danger of being melted by the earths core, and I would say they did cross over that bar- kotlin does suck less than Java, but what’s astonishing to me is how for such a low bar they still seem to have managed to cross over it just barely.

                                                                                                                                                                1. 4

                                                                                                                                                                  I share every single one of those sentiments, but I’ve excused many of them specifically because of the limitations of being a JVM language. (interfaces at class definition, no const, no clones)

                                                                                                                                                                  I’ve almost taken it upon myself to periodically go and correct people in the Kotlin subreddit that val does not make things immutable, and that Kotlin has not cured the need for defensive copies in getters.

                                                                                                                                                                  I think the idea of making Kotlin cross-platform is totally stupid for those same reasons you point out. All of that is a limitation of wanting to be on the JVM and/or close to Java semantics. Why they hell would you want to export that to non-JVM platforms?

                                                                                                                                                                  Thanks for the response.

                                                                                                                                                            2. 12

                                                                                                                                                              I have a completely opposite opinion. Java is not the best language out there, I prefer Scala and Kotlin, but the selling point for me is the ecosystem: great tooling (tools simply work in lots of cases), great platform (lots of platforms are covered, really awesome backward compatibility, stability), great API (it might be far fetched, but I have a feeling that Java’s stdlib is one of the most feature-packed runtimes out there, if not the most?). The “magic” is the same problem as everywhere else; it’s magic until you know the details. Also just because there’s a dependency injection trend in the backend development world, it doesn’t mean that you should use DI in different projects. Interfaces of classes are a Java thing; it wouldn’t exist if the language was more sophisticated.

                                                                                                                                                              Maybe I’m comparing Java’s ecosystem to C++ – because with C/C++, the tooling is in appalling state, the standard library is awful and I’m not sure what it tries to achieve at times. So I guess I have a very low standards to compare to :P

                                                                                                                                                              1. 3

                                                                                                                                                                Java has an incredibly rich ecosystem, that’s true. What annoys me though, is that every single tool in the Java ecosystem is written in Java, meaning you have a ton of CLI programs which take a couple of seconds just to heat up the JVM. Once the JVM is hot and ready to actually do work, the task is over and all that JIT work is lost.

                                                                                                                                                                At least C/C++ tooling is fast :p

                                                                                                                                                                1. 2

                                                                                                                                                                  That’s true, JVM startup time is a pain point. But there are several walkarounds for that:

                                                                                                                                                                  • some tools use build server approach (gradle), so that startup time is less slow ;)
                                                                                                                                                                  • some tools like sbt (scala build tool) use build server + shell approach, and it’s possible to use a thin client to invoke a command on this build server (e.g. ‘sbt-client’ written in rust). This makes Scala compilation take less time than compiling a C++ application.
                                                                                                                                                                  • GraalVM native-image is pushed right now, which allows to compile JVM (java, kotlin, scala) application to native code without the use of JRE. This allows writing tools that have non-noticeable startup time, just like tools written in e.g. Go. I was testing some of my small tools with it and it was able to compile a small Clojure app to native code. This tool had same startup speed than a C++ application. Unfortunately, GraalVM can’t compile every app yet, but they’re working on it ;)

                                                                                                                                                                  Also C/C++ tooling is fast, but C++ compilation is nowhere near being fast. Changing one header file often means recompilation of the first half of the project. Bad build system (e.g. in manually written Makefiles) that doesn’t track dependencies properly sometimes produces invalid binaries that fail at runtime, because some of the compilation units weren’t recompiled when they should be. It can be a real mess.

                                                                                                                                                              2. 10

                                                                                                                                                                I wish Java had a better audience around it.

                                                                                                                                                                That doesn’t seem terribly likely to happen.

                                                                                                                                                                1. Java was never aimed at programmers who value power, succinctness, and simplicity - or programmers who want to explore paradigms other than OO (although newer versions of the lanaguage seem to be somewhat relaxing the Kingdom of Nouns[1] restrictions). It was intended to improve the lives of C++ programmers and their ilk[2].

                                                                                                                                                                2. Java is frequently used in large, corporate, environments where programmers are considered (and treated as) fungible. “The new COBOL”, as it were[3].

                                                                                                                                                                3. The JVM itself allows programmers not falling into (1) and (2) to abandon the Java language itself - Clojure, Scala, Kotlin, and Armed Bear Common Lisp spring (heh) to mind. Most of the best JVM programmers I know aren’t actually using Java. Most of the ‘Java shops’ I’ve worked with in the past decade are now, really, ‘JVM shops’.

                                                                                                                                                                My observation is that most - to be clear, not all - people who continue using Java in 2020 are forced to do so by legacy codebases, and / or companies that won’t let them adopt new languages, even JVM languages. I honestly believe this is the proximate cause of the audience problem you describe. (Not the root cause, mind you).

                                                                                                                                                                Edited: I’m amused by the fact that the first two, nearly concurrent, replies both reference Yegge’s nouns blog post :)

                                                                                                                                                                [1] http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html

                                                                                                                                                                [2] “We were after the C++ programmers. We managed to drag a lot of them about halfway to Lisp.” - Gosling. http://www.paulgraham.com/icad.html

                                                                                                                                                                [3] https://www.infoworld.com/article/3438158/is-java-the-next-cobol.html

                                                                                                                                                                1. 5

                                                                                                                                                                  Java is a horrible language. No mortal can mentally hold on to a class hierarchy where inheritance is more than a few levels deep. Furthermore it is a bad way to add “another layer of abstraction” , because it just paints you more and more into a corner.

                                                                                                                                                                  (Clojure is a great language, you can add layers of abstraction to solve problems, without just digging yourself deeper.)

                                                                                                                                                                  1. 3

                                                                                                                                                                    But one can write Java programs without abusing inheritance, and even pretty much without inheritance.

                                                                                                                                                                    1. 1

                                                                                                                                                                      Yes. I agree that Java is a horrible language, but class inheritance doesn’t even make the list of things I find poor about it.

                                                                                                                                                                  2. 3

                                                                                                                                                                    I don’t agree that Java is a good language at all, but I wanted to hard-agree at the distaste for magic annotations and DI frameworks.

                                                                                                                                                                    1. 1

                                                                                                                                                                      Java is actually a good language, it’s the ecosystem that kills it for me. By “the ecosystem”, I don’t just mean the tooling (e.g. Java build tools are universally awful AFAICT), but the developers themselves. So much Java I read is just “magic”. Magic annotations, magic dependency injection, interfaces over classes that there is only one of etc. etc.

                                                                                                                                                                      I don’t agree with this - in my experience, “magic” is “code that integrates my application-specific functionality with a massively feature-rich general purpose framework”. It’s magic in the sense that you need to understand the enclosing framework to understand why those annotations are there and their semantics, but they do real work. Work I’d have to do myself if I didn’t use them.

                                                                                                                                                                      You don’t see this much in other languages, but it’s because “massively feature-rich general purpose frameworks” aren’t common outside of Java. The ones that do exist seem to have punted on important architectural decisions - you don’t need a dependency injection framework if your data layer objects are just global values (I’m looking at you, Django).

                                                                                                                                                                      I’ve definitely felt this urge before - why do I need all this spring crap? Then I end up re-implementing half of that magic myself and not as well.

                                                                                                                                                                      1. 1

                                                                                                                                                                        What language has tooling that you like? Curious what you are comparing the Java build tools with

                                                                                                                                                                        1. 2

                                                                                                                                                                          Rust and Go (at least since Go modules) I find both intuitive and fast. I am still not sure how to properly build a Java application without an IDE.

                                                                                                                                                                          1. 1

                                                                                                                                                                            $ ./gradlew build

                                                                                                                                                                      1. 16

                                                                                                                                                                        On one side, I strongly agree with this. I use GCP and DigitalOcean often to outsource what I do.

                                                                                                                                                                        On the other hand, I’m watching an entire community of people put out fires because they built their IT on a managed service which Apple bought and effectively terminated yesterday, causing people to wake up to entire fleets of devices with broken policies.

                                                                                                                                                                        Like everything else in tech, there’s no right answer, rather it’s a set of tradeoffs someone has to make.

                                                                                                                                                                        1. 2

                                                                                                                                                                          MASSIVE DISCLAIMER I WORK ON GOOGLE CLOUD

                                                                                                                                                                          I think there is definitely a difference between using AWS/Azure/GCP/AliCloud and a startup like Fleetsmith. I feel super sad for the people that got impacted, as that sunset is really bad (I know that GCP has a 1 year sunset for GA products). If you’re using say, GKE for your k8s clusters, you can be confident that’s not going away.

                                                                                                                                                                          Yesterday I was trialing EKS (k8s) on AWS. I did not like the experience, I ended up abandoning the AWS native method for a third-party tool called eksctl and it still took ~30m to provision a 2 node cluster. I cannot begin to imagine how one would self host a k8s cluster.

                                                                                                                                                                          So yes, there are trade-offs, but I think there are definitely ways to mitigate them.

                                                                                                                                                                          P.S. Given the Fleetspeak turn-off, one great service going away that would keep me up at night is PagerDuty, there really is no product that I know of that is anywhere near as good.

                                                                                                                                                                          1. 3

                                                                                                                                                                            a difference between using AWS/Azure/GCP/AliCloud and a startup like Fleetsmith

                                                                                                                                                                            Is there thought? So only use a big provider (AWS/GCP/Azure) for your startup project? No Digital Ocean/Vultr? Those are both fairly large shops with a lot of startups on them. But they’re also not too big to fail. Digital Ocean is offering more managed services (databases and k8s) but if they ever declared bankruptcy, your startup will be scrambling for another service (and could find yourself with a much higher bill on the big three).

                                                                                                                                                                            I’d rather see more open source management solutions for things like simply full redundancy management for postgres or mysql. What I’ve found is that most shops that have this kind of tooling keep it under lock, and it’s proprietary/specific to their setup.

                                                                                                                                                                            I think managed services are bad due to cost and lockin, and they’re also having the side-effect on slowing innovation for better tooling so people can self-host those same solutions.

                                                                                                                                                                            1. 2

                                                                                                                                                                              Yes, the loss of DigitalOcean in particular would be a huge blow to the ecosystem. Their documentation in particular is fabulous.

                                                                                                                                                                              I’m unclear about whether I’d agree with lock-in as long as you are judicious if this is a concern, e.g. Google Cloud SQL is just Postgres/MySQL with Google juju underneath to make it run on our infra. There’s nothing stopping you dumping your database at any time. Same goes for something like a service like Cloud Run where you’re just deploying a Docker container, you can take that anywhere too. But then if you go all in on GCP BigQuery, then yeah, you’re going to have a harder time finding somewhere to take a data dump of that to.

                                                                                                                                                                              1. 1

                                                                                                                                                                                Is there thought?

                                                                                                                                                                                I would say that the difference isn’t big provider vs startup but infrastructure-as-a-service vs software-as-a-service. Sure the major cloud providers have some software they offer as services but they all also have VMs that you can spin up and install whatever you want on. It’s not like you can install Fleetsmith on your own machines.

                                                                                                                                                                              2. 1

                                                                                                                                                                                Disclaimer: I work on containers for AWS, but not directly on EKS

                                                                                                                                                                                Just a note here that eksctl is the official and recommended tool for interacting with EKS. You can find it in the EKS user guide here.

                                                                                                                                                                            1. 31

                                                                                                                                                                              Managed services frequently determine the shape of your application, the velocity of feature delivery, and, when gone deep in, it removes the capability to use sophisticated open source software.

                                                                                                                                                                              This kind of smear-it-on-everything advice is not good. You need to analyze what your software does, where it will be, what the organization needs, and what it plans to need.

                                                                                                                                                                              It’s going to be operated well. The expertise that the cloud providers can provide and the automation they can afford to implement will likely surpass what you can do, especially across multiple services.

                                                                                                                                                                              That, in the most blunt sense: depends. Wildly. EC2 is a good service. DynamoDB is deeply limited. GKE is not deeply configurable. Azure has some strange APIs.

                                                                                                                                                                              It’s going to be cheaper. Especially when you consider employee costs. The most expensive AWS RDS instance is approximately $100k/year (full price). It’s not an apples to apples comparison, but in many countries you can’t get a database architect for that salary.

                                                                                                                                                                              Dollar for dollar, but that’s not even appropriate level analysis. You need to analyze what it does to the system under delivery: limitations, expansions, and integration work.

                                                                                                                                                                              It’s going to be faster for development. Developers can focus on connecting these pieces of infrastructure rather than learning how to set them up and run them.

                                                                                                                                                                              Same as above.


                                                                                                                                                                              The advent of managed services and writing integrations/overlays has given a lot of people extremely well paid jobs. Thought should be put into this decision: second and third order effects will start to outweigh simplistic considerations like the above.

                                                                                                                                                                              “My cloudformation changes are taking a week to be applied” -> iterate that problem enough and you’ve delayed releases by months, costing far more in reputation, income, morale, etc than that Staff Engineer you didn’t want to hire.

                                                                                                                                                                              1. 4

                                                                                                                                                                                MASSIVE DISCLAIMER I WORK ON GOOGLE CLOUD

                                                                                                                                                                                Azure has some strange APIs.
                                                                                                                                                                                

                                                                                                                                                                                But, it has APIs, right? If you self-manage, do you want to spend engineering hours making your own API? I don’t think I would. I’d rather build my product.

                                                                                                                                                                                1. 7

                                                                                                                                                                                  If you self-manage, do you want to spend engineering hours making your own API? I don’t think I would. I’d rather build my product.

                                                                                                                                                                                  It is your product! Every part of your product is your product. Every dependency of your product is your product.

                                                                                                                                                                                  1. 4

                                                                                                                                                                                    This depends, heavily, on what that service adds and what that service API looks like. The worse the API is, the fewer cases it covers, the worse it is for me. The more commodity the tool is, the more comfortable I am in using it, because it implies I can (1) migrate (2) there’s competition vs providers. My “effectiveness” moat needs not to be a thin wrapper over an API, it needs to be much better.

                                                                                                                                                                                    Every third party thing I integrate demands hours of work, design review, etc. The rough complexity of integrations is n!, n being the number of integrations(technically each third party thing has its own complexity count).

                                                                                                                                                                                    Our own code might be something like polynomially expensive to maintain. If you can keep your complexity count under the complexity count that I take in - both initially and over time (dev time, ops time, maintenance time), then you will win.

                                                                                                                                                                                    Note that I’ve personally been in an org which was so bought into a certain cloud provider that it had no ability to innovate via, e.g., using Apache projects, and all improvements came from the cloud provider… we’d essentially stalled out. New divisions actually wound up spinning their own devops orgs because we’d become so incapable at delivering new tools because “not supplied by cloud provider”.

                                                                                                                                                                                    What we’re actually talking about is called vertical integration in the general case. It can be enormously effective if you can swing it.

                                                                                                                                                                                    Let me ask you this question: how much does Google use from AWS? (Mind, I don’t think you can answer. ;) But Google is notorious for writing its own software).

                                                                                                                                                                                    edit: Note that what I’m saying is not “Don’t use cloud services/SaaS services”. It is: understand deeply what you’re doing and the ramifications of your choices, both technically and organizationally.

                                                                                                                                                                                1. 1

                                                                                                                                                                                  I am lucky enough to have a fat download pipe, so I run a cron job to delete all my images. It’s a blunt hammer, but it gets the job done.

                                                                                                                                                                                  1. 9

                                                                                                                                                                                    Great news! I am eager to try this!

                                                                                                                                                                                    Turn on -XLinearTypes, and the first thing you will notice, probably, is that the error messages are typically unhelpful: you will get typing errors saying that you promised to use a variable linearly, but didn’t. How hasn’t it been used linearly? Well, it’s for you to puzzle out. And while what went wrong is sometimes egregiously obvious, it can often be tricky to figure the mistake out.

                                                                                                                                                                                    So, basically, GHC just got its own “Syntax error” a la OCaml… just a bit more specialized :p.

                                                                                                                                                                                    1. 11

                                                                                                                                                                                      Maybe it’s just me, but to me OCaml’s errors are terse and unhelpful and GHC’s errors are… verbose and unhelpful. ;)

                                                                                                                                                                                      There are interesting papers that show working ways to improve both, but I wonder why none of those improvements are in the mainline compilers.

                                                                                                                                                                                      1. 2

                                                                                                                                                                                        Good error reporting is easiest if it’s built into the compiler front end from the start. If a new algorithm comes along to improve the error information it’s almost never going to be a simple job to drop it into an existing compiler.

                                                                                                                                                                                        You need type information & parse information from code that’s potentially incorrect in both spaces, so any error algorithm usually has to be tightly integrated into both parts of the compiler front end. That tight integration usually means that improving compiler errors is a significant amount of work.

                                                                                                                                                                                        1. 3

                                                                                                                                                                                          It varies. What puzzles me is that a lot of time ready to use, mergeable patches take much longer to merge than they should.

                                                                                                                                                                                          Like this talk: https://ocaml.org/meetings/ocaml/2014/chargueraud-slides.pdf

                                                                                                                                                                                          1. 1

                                                                                                                                                                                            Do you also have a link for a patch for the improved error messages?

                                                                                                                                                                                            A lot of work has been going on to move OCaml to a new parser and improve error messages. Even though there is a lot still needed to be done, latest releases have started improving a lot. Maybe we can still extract some useful bits from that effort and try again

                                                                                                                                                                                            1. 2

                                                                                                                                                                                              Turns out it was even made into a pull request that isn’t merged yet: https://github.com/ocaml/ocaml/pull/102

                                                                                                                                                                                              1. 1

                                                                                                                                                                                                Thanks. It is quite an informative PR actually, and explains why the change is not there yet and once can infer why it is easier to add informative messages in new languages and complier but it may be quite hard to retrofit them to seasoned ones

                                                                                                                                                                                      2. 7

                                                                                                                                                                                        Would you be kind enough to give me an ELI5 about what linear types are and what you can do with them?

                                                                                                                                                                                        1. 29

                                                                                                                                                                                          In logic, normal implication like A implies B means whenever you have A, you can derive B. You have tautologies like “A implies (A and A)” meaning you can always infinitely duplicate your premises.

                                                                                                                                                                                          Linear implication is a different notion where deriving B from A “consumes” A. So “A linearly implies B” is a rule that exchanges A for B. It’s not a tautology that “A linearly implies (A and A).”

                                                                                                                                                                                          The classic example is you can’t say that “$3 implies a cup of coffee” but “$3 linearly implies a cup of coffee” makes sense. So it’s a logical form that reasons about resources that can be consumed and exchanged.

                                                                                                                                                                                          Same in functional programming. A linear function from type A to type B is one that consumes an A value and produces a B value. If you use it once with an A value then you can’t use it again with the same A value.

                                                                                                                                                                                          This is nice for some performance guarantees, but also for encoding safety properties like “a stream can only be read once” etc.

                                                                                                                                                                                          1. 6

                                                                                                                                                                                            Keynote: Linear Haskell: Practical Linearity in a Higher-Order Polymorphic Language https://skillsmatter.com/skillscasts/11067-keynote-linear-haskell-practical-linearity-in-a-higher-order-polymorphic-language

                                                                                                                                                                                            1. 5

                                                                                                                                                                                              It can be used to model protocols with type signatures. The following is in theory what you should be able to do.

                                                                                                                                                                                              data ConsoleInput
                                                                                                                                                                                                  = Input String ConsoleOutput
                                                                                                                                                                                                  | ExitInput
                                                                                                                                                                                              
                                                                                                                                                                                              data ConsoleOutput
                                                                                                                                                                                                  = PrintLines ([String] ⊸ Console)
                                                                                                                                                                                                  & PrintLastLines ([String] ⊸ ())
                                                                                                                                                                                              
                                                                                                                                                                                              greet :: ConsoleOutput ⊸ ()
                                                                                                                                                                                              greet console
                                                                                                                                                                                                  = let PrintLines f = console
                                                                                                                                                                                                    in step2 (f ["name?"])
                                                                                                                                                                                              
                                                                                                                                                                                              step2 :: ConsoleInput ⊸ ()
                                                                                                                                                                                              step2 ExitInput = ()
                                                                                                                                                                                              step2 (Input input console)
                                                                                                                                                                                                  = let PrintLastLines f = console
                                                                                                                                                                                                    in f ["hello " ++ input]
                                                                                                                                                                                              

                                                                                                                                                                                              If you combine it with continuation passing style, you get classical linear logic and it’s a bit more convenient to use.

                                                                                                                                                                                              If you model user interfaces with types, they should be quite useful.

                                                                                                                                                                                              I’m also examining and studying them: http://boxbase.org/entries/2020/jun/15/linear-continuations/

                                                                                                                                                                                              1. 1

                                                                                                                                                                                                Wikipedia gives a reasonable overview. The closest analogy would be something like move semantics – for example ownership in Rust can be considered as manifestation of linear types.

                                                                                                                                                                                                1. 6

                                                                                                                                                                                                  Rust ownership is linear affine types. Linear types are similar but differ in the details. A shitty way of understanding it is affine types mimic ref counting and prevent you from having a ref count < 0. Linear types are more a way of acting like RAII in that you might create a resource but just “know” that someone later on in the chain does the cleanup.

                                                                                                                                                                                                  Which I’m sure sounds similar but affine types allow for things like resource leaks but linear types should guarantee overall behavior to prevent it.

                                                                                                                                                                                                  This all assumes my understanding and explanation is apt. I’m avoiding a ton of math and i’m sure the shitty analogy doesn’t hold up but behaviorally this is how I have it in my brain.

                                                                                                                                                                                                  1. 2

                                                                                                                                                                                                    Linearity Design Space: https://i.imgur.com/s0Mxhcr.png

                                                                                                                                                                                                    1. 2

                                                                                                                                                                                                      I’m personally of the stance that the 2020 linear ghc stuff is more <= 1 usage, and kinda misses out on a lot of really fun expressivity that can fall out of making full classical linear logic first class. But that’s a long discussion in its own right , and I’ve yet to make the time to figure out the right educational exposition on that front

                                                                                                                                                                                                      1. 1

                                                                                                                                                                                                        it definitely seems more limited in scope/ambition compared to the effort ongoing for dependent types, for better or worse. Can’t say I know much about what first class linear logic would look like, but perhaps now there will be more discussion about such things.

                                                                                                                                                                                                        1. 2

                                                                                                                                                                                                          The really amazing thing about full linear logic is it’s really sortah a rich way to just do mathematical modelling where everything has a really nice duality. The whole thing about linearity isn’t the crown jewel (though wonderfully useful for many applications ), it’s that you get a fully symmetric bag of dualities for every type / thing you can model.

                                                                                                                                                                                                          The paper that really made it click for me was mike shulmans linear logic for constructive mathematics paper. It’s just a fun meaty read even at a conceptual level. There’s a lot of other work by him and other folks that taken together just point to it being a nice setting for formal modelling and perhaps foundations of category theory style tools too!

                                                                                                                                                                                                      2. 1

                                                                                                                                                                                                        Not sure I can agree that Uniqueness types are the same as Linear types. Care to explain they’re similar sure but not the same thing and your… screenshot of a powerpoint? isn’t very illustrative of whatever point you’re trying to make here.

                                                                                                                                                                                                        And from my experience with Idris, I’m not sure I’d call what Rust has Uniqueness types.

                                                                                                                                                                                                        1. 1

                                                                                                                                                                                                          They are different rows in the matrix because they are different, of course.

                                                                                                                                                                                                          it’s from this presentation about progress on linear ghc a little over a year ago https://lobste.rs/s/lc20e3/linear_types_are_merged_ghc#c_2xp2dx skip to 56:00

                                                                                                                                                                                                          What is meant by Uniqueness types here is “i can guarantee that this function gets the unique ptr to a piece of memory” https://i.imgur.com/oJpN4eN.png

                                                                                                                                                                                                2. 2

                                                                                                                                                                                                  Am I the only one thinking this is not how you ship language features?

                                                                                                                                                                                                  If the compiler can’t even report errors correctly, the feature shouldn’t ship.

                                                                                                                                                                                                  1. 15

                                                                                                                                                                                                    If the compiler can’t even report errors correctly, the feature shouldn’t ship.

                                                                                                                                                                                                    Its more this is an opt-in feature with crappy error reporting for now using computer programming design features not in use in most programming languages. Its going to have rough edges. If we required everything to be perfect we’d never have anything improved. Linear types like this also might not have a great way to demonstrate errors, or the domain is new so why not ship the feature for use and figure out what kind of error reporting you want based on feedback.

                                                                                                                                                                                                    1. 13

                                                                                                                                                                                                      Many people do not realize that haskell is a research language and GHC is one of the main compilers for it. This is an experimental feature in a research language. If it works out well, then it will be standardized.

                                                                                                                                                                                                    2. 5

                                                                                                                                                                                                      Other people have sort-of said it, but not clearly enough I think. This is not a language feature being added. It is a feature-flagged experimental feature of a particular compiler. Most such compiler extensions never make it into real Haskell, and the ones that do take years after they are added to a compiler to make it to a language spec.

                                                                                                                                                                                                      1. 4

                                                                                                                                                                                                        for all practical purposes isn’t “real Haskell” defined by what ghc implements these days?

                                                                                                                                                                                                        1. 2

                                                                                                                                                                                                          Yes, all the other implementations are dead. They still work, but they won’t run most modern Haskell code, which usually uses a bunch of GHC extensions.

                                                                                                                                                                                                          1. 1

                                                                                                                                                                                                            You might say “isn’t it not popular to write standards-compliant Haskell these days?” and you’d be right. Of course it’s often trendy to write nonstandard C (using, say, GNU extensions) or nonstandard HTML/JavaScript. However, ignoring the standard being trendy doesn’t mean the standard doesn’t exist, or even that it isn’t useful. I always make sure my Haskell is Haskell2010, and I try to avoid dependencies that use egregious extensions.

                                                                                                                                                                                                          2. 2

                                                                                                                                                                                                            Honestly curious: are there any other Haskell compilers out there? Are they used in production?

                                                                                                                                                                                                            Also, what is a definition of a true Haskell? I always thought it’s what’s in GHC.

                                                                                                                                                                                                            1. 5

                                                                                                                                                                                                              There’s a Haskell which runs on the JVM - Frege. But it makes no attempt to be compatible with the version of Haskell that GHC impements, for good reasons. Hugs is a Haskell interpreter (very out of date now, but still works fine for learning about Haskell.) There a bunch of other Haskell compilers, mostly research works that are now no longer in development - jhc, nhc98 etc etc.

                                                                                                                                                                                                              But GHC is the dominant Haskell compiler by far. I don’t think there are any others in active development, apart from Frege, which isn’t interested in being compatible with GHC.

                                                                                                                                                                                                              (“True Haskell” is the Haskell defined in the Haskell Report, but real world Haskell is the Haskell defined by what GHC + your choice of extensions accepts.)

                                                                                                                                                                                                              1. 2

                                                                                                                                                                                                                There are other compilers and interpreters. None of them is anywhere near as popular as GHC, and usually when one does something interesting GHC consumes the interesting parts.

                                                                                                                                                                                                                There is definitely a standard, though: https://www.haskell.org/onlinereport/haskell2010/

                                                                                                                                                                                                                The whole reason language extensions are called “extensions” and require a magic pragma to turn on is that they are not features of the core language (Haskell) but experimental features of the compiler in question.

                                                                                                                                                                                                              2. 1

                                                                                                                                                                                                                In short, GHC Haskell is a language designed by survival-of-the-fittest.

                                                                                                                                                                                                                1. -2

                                                                                                                                                                                                                  If you haven’t noticed, the language spec is dead.

                                                                                                                                                                                                                2. 3

                                                                                                                                                                                                                  Overly terse error messages are bad, but they are better than wrong error messages. Some things are much harder to give helpful error messages for than others.

                                                                                                                                                                                                                  I wish people spend more time improving error reporting, at least in cases when the way to do it is well understood. There is no reason for say TOML or JSON parsers to just say “Syntax error”. But, YAML parsers are pretty much doomed to give unhelpful errors just because the language syntax is ambiguous by design.

                                                                                                                                                                                                                  And then some errors are only helpful because we know what their mean. Consider a simple example:

                                                                                                                                                                                                                  Prelude> 42 + "hello world"
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  <interactive>:1:1: error:
                                                                                                                                                                                                                      • No instance for (Num [Char]) arising from a use of ‘+’
                                                                                                                                                                                                                      • In the expression: 42 + "hello world"
                                                                                                                                                                                                                        In an equation for ‘it’: it = 42 + "hello world"
                                                                                                                                                                                                                  

                                                                                                                                                                                                                  How helpful is it to a person not yet familiar with type classes? Well, it just isn’t. It’s not helping the reader to learn anything about type classes either.

                                                                                                                                                                                                                  1. 1

                                                                                                                                                                                                                    I’ve seen some good suggestions on r/haskell for improving the wording of these errors.

                                                                                                                                                                                                                  2. 2

                                                                                                                                                                                                                    The error they’re talking about is a kind of type error they’ve not worked with. It’s produced if you forget to construct or use a structure. I I’m guessing it’s technically “proper” but the produced error message may be difficult to interpret.

                                                                                                                                                                                                                    They’ve ensured it’s a feature you can entirely ignore if you want to. Everybody’s not convinced they need this.

                                                                                                                                                                                                                    I otherwise dunno what they’re doing and I’m scratching my head at the message. Something like “Oh cool you’ve done this… … … So where are the types?”

                                                                                                                                                                                                                    1. 2

                                                                                                                                                                                                                      So you never got a C++ template error in the good olden days? Seriously though, it just got merged. It’s not released or “shipped” in any means.

                                                                                                                                                                                                                      1. 0

                                                                                                                                                                                                                        So you never got a C++ template error in the good olden days?

                                                                                                                                                                                                                        No, because I looked at the language, figured out that the people involved completely lost their fucking mind, and moved on.

                                                                                                                                                                                                                        Seriously though, it just got merged. It’s not released or “shipped” in any means.

                                                                                                                                                                                                                        They took 4 years to arrive at the current state, which I’ll approximate at roughly 10% done (impl unfinished, spec has unresolved questions, documentation doesn’t really seem to exist, IDE support not even on the radar).

                                                                                                                                                                                                                        So if you assume that there will be a Haskell version in the next 36 years, then this thing is going to end up in some Haskell release sooner or later.

                                                                                                                                                                                                                        1. 2

                                                                                                                                                                                                                          So if you assume that there will be a Haskell version in the next 36 years, then this thing is going to end up in some Haskell release sooner or later.

                                                                                                                                                                                                                          Could you elaborate on this? If practical users of linear types will only use them if they have good error messages, and early testers want to work out the kinks now, what’s wrong with having a half-baked linear types feature with no error messages permanently enshrined in GHC 8.12?

                                                                                                                                                                                                                  1. 48

                                                                                                                                                                                                                    I’ve read through a lot of these kind of discussions in the last week, and one thing that really strikes me is that they consist almost entirely of white people discussing this. This seems a bit odd to me because there are plenty of non-white programmers as well. I’d like to think that these people are more than articulate enough to raise these kind of issues themselves if they have a desire to, but thus far I gave not really seen much of that.

                                                                                                                                                                                                                    Quite frankly, I find that the entire thing has more than a bit of a “white saviour” smell to it, and it all comes off as rather patronising. It seems to me that black people are not so fragile that they will recoil at the first sight of the word “master”, in particular when it has no direct relationship to slavery (it’s a common word in quite a few different contexts), but reading between the lines that kind-of seems the assumption.

                                                                                                                                                                                                                    For me personally – as a white person from a not particularly diverse part of the world – this is something where I think it’s much wiser to shut up and listen to people with a life experience and perspective very different than mine (i.e. black people from different parts of the world), rather than try and make arguments for them. I think it’s a very unfortunate that in the current climate these voices are not well heard since both the (usually white) people in favour and opposed to this are shouting far too loud.

                                                                                                                                                                                                                    1. 28

                                                                                                                                                                                                                      It’s called White guilt. Superficial actions like changing CS terms and taking down statues are easy ways to feel better about oneself while avoiding the actual issue (aka: bike-shedding).

                                                                                                                                                                                                                      1. 5

                                                                                                                                                                                                                        I had the same thought: this is something that is easy to have an opinion about and feels achievable. That makes it very attractive to take action on, independent of the actual value it has.

                                                                                                                                                                                                                        1. 8

                                                                                                                                                                                                                          It is easier to change the name of a git default branch and put that on your CV as an action demonstrating you are not racist, than it is to engage in politics and seek to change some of the injustices that still remain.

                                                                                                                                                                                                                          1. 6

                                                                                                                                                                                                                            Or to put it really on point: it’s easier for GitHub to talk about changing the default branch name on repos created on GitHub from ‘master’ to ‘main’ than it is for them to cut their contract with ICE.

                                                                                                                                                                                                                      2. 14

                                                                                                                                                                                                                        It’s not like you can guess someone’s race from a gravatar. Not to mention, one of the liberating features of the Internet is being able to hide your identity and be treated for what you say in stead of what you are. On the flip side that does mean everybody sees everyone as an adolescent white male.

                                                                                                                                                                                                                        In any case, there’s a black engineer expressing their thanks in the comment section of the OP.

                                                                                                                                                                                                                        1. 11

                                                                                                                                                                                                                          I probably wasn’t too clear about this, but I did not guess anyone’s skin colour; I just looked at their profile pictures, names, etc. For example the author of this post is clearly white, as are the authors of the IETF draft he linked (I did a quick check on this), everyone involved in the Go CL was white, and in the Rubocop discussion everyone was white as well as far as I could tell – certainly the people who were very much in favour of it at the start. There certainly are non-white people participating – anonymously or otherwise – but in general they seem to be very much a minority voice.

                                                                                                                                                                                                                          Or, to give an analogy, while I would certainly support something like Black Lives Matter in various ways, I would never speak on the movement’s behalf. It’s simply not my place to do so.

                                                                                                                                                                                                                          On the flip side that does mean everybody sees everyone as an adolescent white male.

                                                                                                                                                                                                                          Yeah … that’s true and not great. I try not to make assumptions on the kind of person I’m speaking to, but “talking” to just a name is very contrary to human social interaction and it’s easy to have a mental picture that’s similar to yourself and those around you. This is kind of what I was getting at: sharing of different experiences and perspectives is probably by far the most helpful thing and constructive thing that can move this debate (as well as several other things) forward, instead of being locked in the shouting match it is today.

                                                                                                                                                                                                                          I have no illusions that this will happen, because far too many people seem far too eager to comment on the matter, and to be honest I’ve been guilty of that as well.

                                                                                                                                                                                                                        2. 14

                                                                                                                                                                                                                          If we look back at how visceral the reaction to these types of ideas can be, and especially how that response is so often personally directed, it should be no surprise that someone who feels in any way marginalized or at risk in the software community might be reluctant to speak up.

                                                                                                                                                                                                                          1. 14

                                                                                                                                                                                                                            OK, so I think you’re referring to the Reddit Go thread (which was a dumpster fire of “I’m not racist but…” comments; for someone to get so upset about someone else’s internal code base is proof of some underlying issue).

                                                                                                                                                                                                                            Here’s some things to think about:

                                                                                                                                                                                                                            • “It seems entirely white people discuss this”: There’s a really obvious reason for this. Look at Google’s diversity numbers: their value of hiring vs attrition places the number of black people at Google at 3.7%. And yet the census reports 12.1% in the US are African American. Who do you think is going to be discussing this? They’re not here. They can’t be part of this conversation. Worse, black people leave Google faster than other demographics, so even when they get there they decide they don’t like it more and leave. Why would you work hard for your whole life to get a job at Google and then decide to leave? What is it about the software engineering environment that is toxic? Why bother getting upset and making a noise when you’ve already decided it’s hopeless and given up?
                                                                                                                                                                                                                            • “It has a white savior smell”: It is incumbent on the privileged class to show allyship and help build equality for the underprivileged. It is unacceptable to put on blinkers and go “they’ll work it out”, as it ignores the systemic reasons why inequity exists. A big difference about what is happening now is that white people are going out to the streets and showing their allyship. These protests are very similar to those in Ferguson, except in Ferguson it was all black people. Nothing happened. Now that white people have come out, suddenly people start talking about “movements”. You can’t look to black people in CS and say “you overcome all the systemic problems” just like we can’t look to women in CSand say “you overcome all the systemic problems and please suck it up when you get battered with toxic behavior that’s just the way we are lol.” For the privileged class to sit back is for the privileged class to approve of what happens. “White savior” is a weaponized term to say that if you are white, you don’t get to help. Actually, if you are white, you absolutely should be helping.
                                                                                                                                                                                                                            • “you should listen rather than make arguments for them”: Again, we are back to who do you listen to? Representation is so horrifically low. The Go thread raised up anyone who identified as black, had the same viewpoint as the mob and held that viewpoint as representative for the whole black community. You can’t just ask someone on the street and say “there you go, he said it”. You have to talk. And talk. And talk. And talk. To as many people as you can. Over and over again. I am so glad Google has the Black Googlers Network for exactly that sort of discussion.

                                                                                                                                                                                                                            Names mean something. master/slave has clearly had it’s time. whitelist/blacklist (as in the Go thread) is unnecessary, a term that we basically invented, and is easily replaced. Would I change master to main? Probably not. But I’m certainly not going to come and say that attempting to move the needle, even if it doesn’t work or the needle move only a fraction, shouldn’t be attempted.

                                                                                                                                                                                                                            Anecdote: Google offers a number of optional diversity training. I went to one that showed this video. I was in tears. It was so foreign to me and so horrific that I was crying at work and had to leave the room. That video is the result of white America doing nothing.

                                                                                                                                                                                                                            1. 12

                                                                                                                                                                                                                              I’m not really referring to the Reddit thread as such. Not only is Reddit really anonymous, so much of the time I have no idea who I’m dealing with, Reddit also has its fair share of … unpleasant … people. On Twitter Nate Finch mentioned he banned a whole truckload of people who had never posted in /r/golang before coming in from whatever slimepit subreddit they normally hang out in. Unfortunately, this is how things work on Reddit. There were some interesting good-faith conversations, but also a lot of bad-faith bullshit. I was mostly referring to the actual CL and the (short) discussion on that.

                                                                                                                                                                                                                              As for Google diversity, well, Google is just one company from one part of the world. The total numbers of developers in India seems comparable or greater than the number of developers in the US, for example. I’ve also worked with many Brazilian developers over the years, so they also seems to have a healthy IT industry. There are plenty of other countries as well. This is kind of what I meant with the “outside of the Silicon Valley bubble” comment I removed. Besides, just because there are fewer of them doesn’t mean they don’t exist (3.7% is still >4k people) or that I need to argue things in their place.

                                                                                                                                                                                                                              It’s one thing to show your allyship, I’m all in favour of that, but it’s quite another thing to argue in their place. I have of course not read absolutely anything that anyone has written on this topic, but in general, by and large, this is what seems to be happening.

                                                                                                                                                                                                                              This is something that extends just beyond the racial issue; I’ve also seen people remove references to things like “silly” as ableist, but it’s not entirely clear to me that anyone is actually bothered by this other than the (undoubtedly well-intentioned) people making the change.

                                                                                                                                                                                                                              The Go thread raised up anyone who identified as black, had the same viewpoint as the mob and held that viewpoint as representative for the whole black community.

                                                                                                                                                                                                                              Yeah, this is a problem: “here’s a black person saying something, therefore [..]”. Aside from the fact that I wouldn’t trust such a post without vetting the account who made it (because, you know, /r/AsABlackMan) a single person commenting doesn’t represent anything other than that single person.

                                                                                                                                                                                                                              An initiative from something like the Black Googler Network would probably be much more helpful than some random GitHub PR with little more than “please remove oppressive language” true-ism.

                                                                                                                                                                                                                              If you’re telling people who have been used to these terms for years or decades that all of the sudden it’s racist and oppressive without any context or explanation, then it’s really not that strange that at least some people are going to be defensive. I really wish people would spend a lot more thought and care in the messaging on this; there is very little effort spent on actually building empathy for any of this; for the most part it’s just … accusations, true-isms, shouting. You really need to explain where you’re coming from, otherwise people are just going to be confused and defensive.

                                                                                                                                                                                                                            2. 4

                                                                                                                                                                                                                              This seems a bit odd to me because there are plenty of non-white programmers as well, especially if you look beyond the Silicon Valley bubble.

                                                                                                                                                                                                                              Silicon valley is full of nonwhite programmers. White people are somewhat underrepresented in Silicon Valley compared to their percentage of the American population. And of course most of the world is not America.

                                                                                                                                                                                                                              1. 3

                                                                                                                                                                                                                                I’ve actually never been to the States, much less the Silicon Valley. I just dimly remember reading somewhere that it’s mostly white, but I probably just remembered wrong. I’ll just remove that part since it doesn’t matter for my point and I clearly don’t know what I’m talking about with that 😅

                                                                                                                                                                                                                                1. 4

                                                                                                                                                                                                                                  In my previous company in SV (I was a remote engineer abroad, everybody else US based) we had literally 1 person on the team that was born and raised in the US, everybody else was from somewhere else. India and China were dominant, but not the only other countries.

                                                                                                                                                                                                                                  Other teams looked pretty much the same. CEO (+founder), VP of Eng and all team leads in Engineering were non US born and almost all non white too.

                                                                                                                                                                                                                                  I am now working for a different company with head-quarters in SF and it is a bit different. We still have pretty big mix of backgrounds (I don’t know how to express it better, what I mean is that they are not decedents of white Europeans). We seem to have more people that were born in the US yet are not white.

                                                                                                                                                                                                                                  Our European office is more “white” if you will, but still very diverse. At one point we had people from all (inhabited) continents working for us (place of birth), yet we were only ~30 people in total.

                                                                                                                                                                                                                                2. 2

                                                                                                                                                                                                                                  Well, it’s full of programmers from Asian countries, to the point where I wouldn’t call their presence diverse. Being a Chinese/Indian/White male isn’t diversity, it’s a little bit more diverse. So while “nonwhite” is accurate, it’s not really the end game. Software engineering is massively underrepresented in women and in Black and Latinx.

                                                                                                                                                                                                                                  1. 6

                                                                                                                                                                                                                                    So who exactly sets the rules on what is diverse enough? Is it some committee of US Americans or how does that work?

                                                                                                                                                                                                                                    1. 1

                                                                                                                                                                                                                                      Ah okay so here we see the problem. It’s only diversity when there aren’t enough of them, then it stops counting as diversity once you actually have diversity and the goalposts shift once again.

                                                                                                                                                                                                                                  2. 4

                                                                                                                                                                                                                                    Quite frankly, I find that the entire thing has more than a bit of a “white saviour” smell to it, and it all comes off as rather patronising. It seems to me that black people are not so fragile that they will recoil at the first sight of the word “master”, in particular when it has no direct relationship to slavery (it’s a common word in quite a few different contexts), but reading between the lines that kind-of seems the assumption.

                                                                                                                                                                                                                                    Agreed that black folks are in the main far too sensible to care about this kind of thing.

                                                                                                                                                                                                                                    I don’t know that it is really so much about being a ‘white saviour’ (although that may be part of it); rather, I see it more as essentially religious: it is a way for members of a group (in this case, young white people) to perform the rituals which bind the group together and reflect the moral positions the group holds. I don’t mean ‘religious’ here in any derogatory way.

                                                                                                                                                                                                                                    1. 9

                                                                                                                                                                                                                                      Not sure about this specific issue, but in general there’s so much systemic stuff that it’s a bit much to ask black communities alone to speak up for everything. It’s emotionally exhausting if we don’t shoulder at least some of the burden, at the same time listening to and amplifying existing voices.

                                                                                                                                                                                                                                      To be honest I’d never really thought about the ‘master’ name in git before, and think there might be larger issues we need to tackle, but it’s a pretty low effort change to make. Regardless, the naming confused me anyway when I first used git and then just faded into the background. I’ll let black people speak up if they think it’s overboard, however, although I’d imagine there’d be different perspectives on this.

                                                                                                                                                                                                                                      1. 3

                                                                                                                                                                                                                                        Not sure about this specific issue, but in general there’s so much systemic stuff that it’s a bit much to ask black communities alone to speak up for everything. It’s emotionally exhausting if we don’t shoulder at least some of the burden, at the same time listening to and amplifying existing voices.

                                                                                                                                                                                                                                        Yeah, I fully agree. I don’t think they should carry all the burden on this and it’s not just helpful but our responsibility to be supportive both in words and action. But I do think they should have the initiative. Otherwise it’s just a bunch of white folk sitting around the table musing what black folk could perhaps be bothered by. Maybe the conclusions of that might be correct, but maybe they’re not, or maybe things are more nuanced.

                                                                                                                                                                                                                                      2. 2

                                                                                                                                                                                                                                        Really couldn’t disagree more — one of the big repository hosting services had this discussion just the other week. Much of the agitation came from Black employees, particularly descendants of enslaved Africans brought to America.

                                                                                                                                                                                                                                        I agree with you on one count, though: if you’re white and you don’t have any particular investment in this issue, you should probably keep your opinion on it to yourself.

                                                                                                                                                                                                                                        1. 4

                                                                                                                                                                                                                                          Which discussion in particular are you referring to?

                                                                                                                                                                                                                                          1. 2

                                                                                                                                                                                                                                            The idea that this is being primarily driven by white people, specifically as a “white savior” exercise. The word “master” does bring up a painful legacy for lots of Black people, and with the context as muddled as it is with “git master,” it makes sense to defer to them on how they perceive it, especially in an industry where they’re so underrepresented.

                                                                                                                                                                                                                                            1. 3

                                                                                                                                                                                                                                              You mentioned that:

                                                                                                                                                                                                                                              one of the big repository hosting services had this discussion just the other week. Much of the agitation came from Black employees

                                                                                                                                                                                                                                              So I was wondering if you have a link or something to that discussion? I’d be interested.

                                                                                                                                                                                                                                              1. 3

                                                                                                                                                                                                                                                I wish I had something to share — the conversations have been internal and I wouldn’t want to breach confidentiality (any more than I already have). Once we’ve all forgotten about this, if there’s a blog post to share, I’ll thread it here.

                                                                                                                                                                                                                                                1. 3

                                                                                                                                                                                                                                                  Ah cheers, I didn’t realize it was an internal thing.