1. 1

    that was great - I would love to do more of these!

    1. 12

      I got a lot out of reading DJB’s daemontools a number of years ago.

      https://cr.yp.to/daemontools.html

      https://github.com/daemontools/daemontools/tree/master/src

      It’s good if you want to see how to write simple and reliable C code in a very careful and minimalist way. This paper has some thoughts on DJB’s style of secure C coding:

      https://blog.acolyer.org/2018/01/17/some-thoughts-on-security-after-ten-years-of-qmail-1-0/

      DJB also notably uses shell and C together to minimize privilege.

      I think you can start at any file with a main(), as it is a small collection of utilities, loosely joined. The overall design is as important as the code.


      Another good read is CPython. There are definitely things I don’t like about it, but it’s been well maintained by a small-ish group of people for 30 years now, which is incredible.

      It’s not a project where one person does everything. I think that’s a good contrast to DJB’s style, which is more about keeping everything small so that one person can vouch for correctness and security.

      It’s obviously important to the world, which makes it worth reading. But I would also say that the code is significantly easier to read than its contemporaries: Perl, Ruby, PHP, R, and arguably Lua. (I have looked at all of them to varying degrees, as well as many other language implementations)

      It’s extremely modular and globally coherent. Seeing how PyObject and PyTypeObject work together actually taught me a lot about the Python language, even after I had programmed in it for ~15 years!

      I’m not sure you can start in one place by reading CPython; I think it’s easier to write your own Python-C extension, and that may have give you a hint of how the interpreter works. It’s very simple, open to extension, and dynamically typed. C sort of lends itself to this dynamically typed architecture which tends to “grow well”. There are a lot of things about CPython that could be more optimal locally, but I think it has a lot of global coherence and that’s one reason why it has lasted.


      Another good read is xv6, which is the modernized source for v6 Unix, and taught at MIT. It’s extremely easy to compile and modify, which is rare for an OS. I added a command line tool to it and ran it in QEMU, and it was easy (I think it also taught me how to run QEMU :) ). It’s good for understanding where C and Unix came from.


      As for Python code, I got a lot of out of this, but it’s NOT easy to read. It’s just small. If you know Python well then it’s fun to figure out the puzzle of how they did it: http://www.tinypy.org/

      There’s also a Python bytecode compiler in Python here that is interesting because it’s very short and Lispy:

      https://github.com/darius/tailbiter

      It definitely reminded me that you can write Python with a Lisp accent :) :) Very cool and short.

      accompanying article: https://codewords.recurse.com/issues/seven/dragon-taming-with-tailbiter-a-bytecode-compiler

      1. 8

        Another good read is CPython

        Seconded. The CPython implementation is quite straightforward. It doesn’t use too many tricks to improve its speed, which means the code is easier to read than hyper bummed implementations. Speaking of which, the same is certainly true for Scheme48 which was also written for clarity and with simplicity in mind.

        I found SBCL to be a treasure trove of solid code as well, since here too most of the system is implemented in Lisp itself. It’s a bit more complex to navigate as it’s very big, but I found it very valuable to study when I was reading up on bignum implementations.

        1. 1

          I agree and like that it’s straightforward, though one exception is ceval.c, the main bytecode interpreter loop. It is really long and full of macros and and obscure control flow. Not very readable IMO, which is why I started hacking on the Python versions.

          I think some code generation could simplify things (even though it also adds another level of indirection). That is not too uncommon for bytecode interpreters; I think one of the JS Engines like JavaScriptCore uses a Ruby DSL to express the bytecode instruction set. Apparently PHP has a whole lot of indirection and code generation there but I haven’t looked closely. I think bytecode loops are just awkward for C! (although I guess no other language really does better, including C++ as far as I can tell)

          1. 2

            Ruby itself also uses codegen in its bytecode interpreter: https://github.com/ruby/ruby/blob/master/insns.def

            1. 1

              Oh yeah I think I have peeked at that file before! Definitely looks cleaner than how CPython has done it.

        2. 2

          If you’re a little intimidated to read CPython yourself and would like a ‘guided tour’, Philip Guo has an excellent set of lectures where he just goes through the code piece-by-piece. He goes from ‘CPython is just a bunch of .c and .h files’ to ‘you create an iterator from a generator object by calling PyObject_SelfIter, which just increments a ref counter and returns itself.’

          1. 1

            I neglected to mention a shell codebase :) Aboriginal Linux is defunct but its goal was to be the smallest Linux system that can rebuild itself. (In that sense it’s similar to recent Guix bootstrapping efforts.)

            http://landley.net/aboriginal/

            And it’s all written in shell. It’s like a mini-Linux from scratch. Linux from Scratch is also worthwhile though it takes forever to do, whereas Aboriginal is small.

            So in a sense I think Aboriginal gives you a better idea of how to build Linux from scratch – how to build and configure a kernel, and what’s in user space and how to assemble it. It also gave me more of an idea of how embedded devs think and code which is considerably different than server side / desktop / web / etc. developers.

            It’s much clearer than say Debian, which is a bunch of shell-make-custom-tool-package-manager gobbledygook. Aboriginal is pure shell. It’s closer to a program than a bunch of scripts grown over time.

          1. 3

            Such a shame. I only know Dan from his work and from his fantastic defcon 22 talk. He will be missed.

            Defcon talk: https://www.youtube.com/watch?v=xneBjc8z0DE

            1. 2

              Thank you for the link. I wasn’t familiar with his work before today, but that talk was very interesting.

              As a sidenote, does anyone know the (scooby doo?) shirt he’s wearing?

            1. 10

              Jon Gjengset (Rust contributor & streamer) touches on this in the Humans of Open Source podcast (link to episode, it’s at 17:16).

              Sean Chen: I discount just how much time it takes to digest the entire codebase. How long would you say it takes you to digest a large codebase?

              Jon Gjengset: It’s hard for me to answer because that’s just not how I read code. It’s very rare that I just open the project and read the codebase. I’ve heard this recommended in some places and it’s just weird to me. You’re likely to just get impatient reading it.

              More commonly, there’s a particular thing that I need to know how it works. For example, let’s imagine that you need to sort an array and you’re going to use the standard library sort. You want to know what happens if two elements are equal, whether their position gets swapped or not. Let’s say for whatever reason, that matters to your application and the documentation doesn’t say. My first inclination is to click the ‘Source’ button and read what the function does. Usually, that’s how I consume a codebase, bit-by-bit, from the things that I’m using. After awhile, you get a sense for how things fit together. It’s very rare that I read the whole thing.

              If you just read a whole codebase, you get the wrong impression that some really smart person sat down and just wrote this thing. That’s just never how these things are developed. If you look at some of the really core, tricky libraries like syn, or once_cell, or rayon, their codebases are quite intricate. But they didn’t start out that way. They started with some naive implementation and then someone found a problem and then they found some neat solution. It’s rare that one person just put their thoughts into the computer and it worked.

              My way of thinking of open source is: All these codebases are continuously improving by small amounts, but the only way they improve is if someone reports something and then tries to improve it. You can be a part of that. If you’re contributing to open source for the first time, all you have to do is contribute a delta. You’re not contributing a whole thing.

              I would add: Seek out communities that value small contributions and have a holistic view of what constitutes a ‘contribution.’

                1. 7

                  The Rustacean Station podcast goes through the changelog for each release. They typically contain quality-of-life improvements to the compiler and filling in “gaps” to existing APIs. For example, 1.48/49 stabilized the move_ref pattern which makes it easier to use values after matching on them, const-ified some functions in the standard library, and added future::ready() and future::pending(). The big feature was “intra-doc links,” which lets you write doc-comments that link to different parts of the code. ARM Linux was also added as a Tier-1 platform.

                  These changes should make it easier, not harder, to learn Rust. They also shouldn’t require drastically changing your existing code.

                  My biggest concern is the maintenance burden. I feel enough a part of the Rust community that I care about contributors I’ve never met. I worry about the increased interest from larger companies who may try to accelerate development of features they want without sufficient consideration for the effort it takes to build or maintain those same features, and how they may affect unrelated parts of the ecosystem. Fortunately, it seems as if the Rust leadership also shares these concerns. I know they’ve spoken about people being burned out trying to ship the 2018 edition and want to ensure that doesn’t happen for the next one. They recently announced a new rule that (IIRC) no more than 2 people from the same company can be a part of a single working group. So I’m hopeful.

                  OK, let me take off my contributor/backseat driving hat for a second. As a user of Rust, over the last year I have been happy with all the changes I’ve seen. I actually just updated my (~4000 LOC) project a month or two ago after not touching it for 6 months and it took me two hours to get it to Rust nightly. I was not surprised.

                  1. 3

                    I recommend this 3-part course on programming languages. It uses SML. It’s a fine language but I see that as the ‘price of entry’ to learn from Dan Grossman who is a fantastic teacher. It will give you the tools to make sense of all the languages you mention. If I recall correctly, in an early lecture Dan calls this course his ‘magnum opus’ and it shows.

                    1. 25

                      Note a couple things:

                      • With the 2021 edition, Rust plans to change closure capturing to only capture the necessary fields of a struct when possible, which will make closures easier to work with.
                      • With the currently in-the-works existential type declarations feature, you’ll be able to create named existential types which implement a particular trait, permitting the naming of closure types indirectly.

                      My general view is that some of the ergonomics here can currently be challenging, but there exist patterns for writing this code successfully, and the ergonomics are improving and will continue to improve.

                      1. 12

                        I have very mixed feelings about stuff like this. On the one hand, these are really cool (and innovative – not many other languages try and do async this way) solutions to the problems async Rust faces, and they’ll definitely improve the ergonomics (like async/await did).

                        On the other hand, adding all of this complexity to the language makes me slightly uneasy – it kind of reminds me of C++, where they just keep tacking things on. One of the things I liked about Rust 1.0 was that it wasn’t incredibly complicated, and that simplicity somewhat forced you into doing things a particular way.

                        Maybe it’s for the best – but I really do question how necessary all of this async stuff really is in the first place (as in, aren’t threads a simpler solution?). My hypothesis is that 90% of Rust code doesn’t actually need the extreme performance optimizations of asynchronous code, and will do just fine with threads (and for the remaining 10%, you can use mio or similar manually) – which makes all of the complexity hard to justify.

                        I may well be wrong, though (and, to a certain extent, I just have nostalgia from when everything was simpler) :)

                        1. 9

                          I don’t view either of these changes as much of a complexity add. The first, improving closure capturing, to me works akin to partial moves or support for disjoint borrows in the language already, making it more logically consistent, not less. For the second, Rust already has existential types (impl Trait). This is enabling them to be used in more places. They work the same in all places though.

                          1. 11

                            I’m excited about the extra power being added to existential types, but I would definitely throw it in the “more complexity” bin. AIUI, existential types will be usable in more places, but it isn’t like you’ll be able to treat it like any other type. It’s this special separate thing that you have to learn about for its own sake, but also in how it will be expressed in the language proper.

                            This doesn’t mean it’s incidental complexity or that the problem isn’t worth solving or that it would be best solved some other way. But it’s absolutely extra stuff you have to learn.

                            1. 2

                              Yeah, I guess my view is that the challenge of “learn existential types” is already present with impl Trait, but you’re right that making the feature usable in more places increases the pressure to learn it. Coincidentally, the next post for Possible Rust (“How to Read Rust Functions, Part 2”) includes a guide to impl Trait / existential types intended to be a more accessible alternative to Varkor’s “Existential Types in Rust.”

                              1. 6

                                but you’re right that making the feature usable in more places increases the pressure to learn it

                                And in particular, by making existential types more useful, folks will start using them more. Right now, for example, I would never use impl Trait in a public API of a library unless it was my only option, due to the constraints surrounding it. I suspect others share my reasons too. So it winds up not getting as much visible use as maybe it will get in the future. But time will tell.

                            2. 2

                              eh, fair enough! I’m more concerned about how complex these are to implement in rustc (slash alternative compilers like mrustc), but what do I know :P

                              1. 7

                                We already use this kind of analysis for splitting borrows, so I don’t expect this will be hard. I think rustc already has a reusable visitor for this.

                                (mrustc does not intend to compile newer versions of rust)

                                1. 1

                                  I do think it is the case that implementation complexity is ranked unusually low in Rust’s design decisions, but if I think about it, I really can’t say it’s the wrong choice.

                              2. 3

                                Definitely second your view here. The added complexity and the trajectory means I dont feel comfortable using Rust in a professional setting anymore. You need significant self control to write maintainable Rust, not a good fit for large teams.

                                What I want is Go-style focus on readability, pragmatism and maintainability, with a borrow checker. Not ticking off ever-growing feature lists.

                                1. 9

                                  The problem with a Go-style focus here is: what do you remove from Rust? A lot of the complexity in Rust is, IMO, necessary complexity given its design constraints. If you relax some of its design constraints, then it is very likely that the language could be simplified greatly. But if you keep the “no UB outside of unsafe and zero cost abstractions” goals, then I would be really curious to hear some alternative designs. Go more or less has the “no UB outside of unsafe” (sans data races), but doesn’t have any affinity for zero cost abstractions. Because of that, many things can be greatly simplified.

                                  Not ticking off ever-growing feature lists.

                                  Do you really think that’s what we’re doing? Just adding shit for its own sake?

                                  1. 8

                                    Do you really think that’s what we’re doing?

                                    No, and that last bit of my comment is unfairly attributed venting, I’m sorry. Rust seemed like the holy grail to me, I don’t want to write database code in GCd languages ever again; I’m frustrated I no longer feel confident I could corral a team to write large codebases with Rust, because I really, really want to.

                                    I don’t know that my input other than as a frustrated user is helpful. But I’ll give you two data points.

                                    One; I’ve argued inside my org - a Java shop - to start doing work in Rust. The learning curve of Rust is a damper. To me and my use case, the killer Rust feature would be reducing that learning curve. So, what I mean by “Go-style pragmatism” is things like append.

                                    Rather than say “Go does not have generics, we must solve that to have append”, they said “lets just hack in append”. It’s not pretty, but it means a massive language feature was not built to hammer that one itch. If “all abstractions must have zero cost” is forcing introduction of language features that in turn make the language increasingly hard to understand, perhaps the right thing to do is, sometimes, to break the rule.

                                    I guess this is exactly what you’re saying, and I guess - from the outside at least - it certainly doesn’t look like this is where things are headed.

                                    Two, I have personal subjective opinions about async in general, mostly as it pertains to memory management. That would be fine and well, I could just not use it. But the last few times I’ve started new projects, libraries I wanted to use had abandoned their previously synchronous implementations and gone all-in on async. In other words, introducing async forked the crate community, leaving - at least from my vantage point - fewer maintained crates on each side of the fork than there were before the fork.

                                    Two being there as an anecdote from me as a user. ie. my experience of async was that it (1) makes the Rust hill even steeper to climb, regressing on the no. 1 problem I have as someone wanting to bring the language into my org; (2) it forked the crate community, such that the library ecosystem is now less valuable. And, I suppose, (3) it makes me worried Rust will continue adding very large core features, further growing the complexity and thus making it harder to keep a large team writing maintainable code.

                                    1. 8

                                      the right thing to do is, sometimes, to break the rule.

                                      I would say that the right thing to do is to just implement a high-level language without obvious mistakes. There shouldn’t be a reason for a Java shop to even consider Rust, it should be able to just pick a sane high-level language for application development. The problem is, this spot in the language landscape is currently conspicuously void, and Rust often manages to squeeze in there despite the zero-cost abstraction principle being antithetical to app dev.

                                      That’s systems dynamics that worries me a lot about Rust: there’s a pressure to make it a better language for app development at the cost of making it a worse language for systems programming, for the lack of an actual reasonable app dev language one can use instead of Rust. I can’t say it is bad. Maybe the world would be a better place if we had just a “good enough” language today. Maybe the world would be better if we wait until “actually good” language is implemented.

                                      So far, Rust resisted this pressure successfully, even exceptionally. It managed to absorb “programmers can have nice things” properties of high level languages, while moving downwards in the stack (it started a lot more similar to go). But now Rust is actually popular, so the pressure increases.

                                      1. 4

                                        I mean, we are a java shop that builds databases. We have a lot of pain from the intersection of distributed consensus and GC. Rust is a really good fit for a large bulk of our domain problem - virtual memory, concurrent B+-trees, low latency networking - in theory.

                                      2. 4

                                        I guess personally, I would say that learning how to write and maintain a production quality database has to be at least an order of magnitude more difficult than learning Rust. Obviously this is an opinion of mine, since everyone has their own learning experiences and styles.

                                        As to your aesthetic preferences, I agree with them too! It’s why I’m a huge fan of Go. I love how simple they made the language. It’s why I’m also watching Zig development closely (I was a financial backer for some time). Zero cost abstractions (or Zig’s case, memory safety at compile time) isn’t a necessary constraint for all problems, so there’s no reason to pay the cost of that constraint in all cases. This is why I’m trying to ask how to make the design simpler. The problem with breaking the zero cost abstraction rule is that it will invariably become a line of division: “I would use Rust, but since Foo is not zero cost, it’s not appropriate to use in domain Quux, so I have to stick with C or C++.” It’s antithetical to Rust’s goals, so it’s really really hard to break that rule.

                                        I’ve written about this before, but just take generics as one example. Without generics, Rust doesn’t exist. Without generics (and, specifically, monomorphized generics), you aren’t able to write reusable high performance data structures. This means that when folks need said data structures, they have to go implement them on their own. This in turn likely increases the use of unsafe in Rust code and thus significantly diminishes its value proposition.

                                        Generics are a significant source of complexity. But there’s just no real way to get rid of them. I realize you didn’t suggest that, but you brought up the append example, so I figured I’d run with it.

                                        1. 2

                                          I guess personally, I would say that learning how to write and maintain a production quality database has to be at least an order of magnitude more difficult than learning Rust.

                                          Agree, but precisely because it’s a hard problem, ensuring everything else reduces mental overhead becomes critical, I think.

                                          If writing a production db is 10x as hard as learning Rust, but reading Rust is 10x as hard as reading Go, then writing a production grade database in Go is 10x easier overall, hand wavingly (and discounting the GC corner you now have painted yourself into).

                                          One thing worth highlighting is why we’ve managed to stick to the JVM, and where it bites us: most of the database is boring, simpleish code. Hundreds of thousands of LOC dealing with stuff that isn’t on the hot-path. In some world, we’d have a language like Go for writing all that stuff - simple and super focused on maintainability - and then a way to enter “hard mode” for writing performance critical portions.

                                          Java kind of lets us do that; most of the code is vanilla Java; and then critical stuff can drop into unsafe Java, like in the virtual memory implementation. The problem with that in the JVM is that the inefficiency of vanilla Java causes GC stalls in the critical code.. and that unsafe Java is horrifying to work with.

                                          But, of course, then you need to understand both languages as you read the code.

                                      3. 4

                                        I think the argument is to “remove” async/await. Neither C or C++ have async/await and people write tons of event driven code with them; they’re probably the pre-eminent languages for that. My bias for servers is to have small “manual” event loops that dispatch to threads.

                                        You could also write Rust in a completely “inverted” style like nginx (I personally dislike that, but some people have a taste for it; it’s more like “EE code” in my mind). The other option is code generation which I pointed out here:

                                        https://lobste.rs/s/rzhxyk/plain_text_protocols#c_gnp4fm

                                        Actually that seems like the best of both worlds to me. High level and event driven/single threaded at the same time. (BTW the video also indicated that the generated llparse code is 2x faster than the 10 year old battle-tested, hand-written code in node.js)

                                        So basically it seems like you can have no UB and zero cost abstractions, without async/await.

                                        1. 5

                                          After our last exchange, I don’t really want to get into a big discussion with you. But I will say that I’m quite skeptical. The async ecosystem did not look good prior to adding async/await. By that, I mean, that the code was much harder to read. So I suppose my argument is that adding some complexity to language reduces complexity in a lot of code. But I suppose folks can disagree here, particularly if you’re someone who thinks async is overused. (I do tend to fall into that camp.)

                                          1. 2

                                            Well it doesn’t have to be a long argument… I’m not arguing against async/await, just saying that you need more than 2 design constraints to get to “Rust should have async/await”. (The language would be a lot simpler without it, which was the original question AFAICT.)

                                            You also need:

                                            1. “ergonomics”, for some definition of it
                                            2. textual code generation is frowned upon

                                            Without constraint 3, Rust would be fine with people writing nginx-style code (which I don’t think is a great solution).

                                            Without constraint 4, you would use something like llparse.

                                            I happen to like code generation because it enables code that’s extremely high level and efficient at the same time (like llparse), but my experience with Oil suggests that most “casual” contributors are stymied by it. It causes a bunch of problems in the build system (build systems are broken and that’s a different story). It also causes some problems with tooling like debuggers and profilers.

                                            But I think those are fixable with systems design rather than language design (e.g. the C preprocessor and JS source maps do some limited things)

                                            On a related note, Go’s philosophy is to fix unergonomic code with code generation (“go generate” IIRC). There are lots of things that are unergonomic in Go, but code generation is sort of your “way out” without complicating the language.

                                  2. 1

                                    I didn’t know about the first change. That’s very exciting! This is definitely something that bit me when I was first learning the language.

                                  1. 3

                                    neato! you may want to combine e.g. zucchini and courgette.

                                    1. 1

                                      Thanks - yep, synonyms and/or translations would be really good to handle. No decisions yet on how best to model that (per-language? simple global replacements? do queries accept any version of the ingredient name?).

                                    1. 8

                                      This was my first game and I thought for years that I just sucked at videogames.

                                      1. 2

                                        Yes! This was my first RPG. It was very hard but I got better at the jumping, eventually. Some games were meant to be hard back then, I actually kind of liked e.g. Baldur’s Gate where you would walk into a room and get creamed by high-level NPCs and die. I also liked the dark theme of U8… so much that when I played the other Ultima’s I was confused by all the good guy stuff. The fiddliness of the pentagrams made the magic seem more arcane. Overall - I think it likely could have become a good game with some additional dev time.

                                        1. 1

                                          Oh no! That must have been traumatic. I feel bad for past-you.

                                        1. 7

                                          nano is my go-to editor and I have only good things to tell about it.

                                          Also, unlike Vim (and Emacs for a long time) it supports the XDG spec.

                                          1. 2

                                            If you feel comfortable elaborating, I’m curious why you’d pick it over other editors. Are you primarily sshing to places that don’t always have other editors installed?

                                            1. 7

                                              That is mostly my use case with it. nano works out of the box. It requires no configuration and it’s the same everywhere. That is valuable to me as I need to change a setting or tweak a service file or whatever. It’s not my main editor. I use VSCode for that. You could argue that I could use vi for this, but I just need to change a damn file. I’m not going to work on it for long. Maybe I’ll tweak a line or two and move on with my life. I can use vi, but really, it’s an extra mental load when all I’m doing is scrolling down a file to find the setting I need to change to “yes”.

                                              1. 2

                                                that makes complete sense. i definitely wasn’t asking from a position of trying to evangelize my own approach. thanks for explaining

                                            2. 1

                                              Also, unlike Vim (and Emacs for a long time) it supports the XDG spec.

                                              It is possible to configure vim to respect XDG. I have this in my ~/config/vimrc:

                                              set undodir=${XDG_CACHE_HOME}/vim/undo//
                                              set dir=${XDG_CACHE_HOME}/vim/swap//
                                              set backupdir=${XDG_CACHE_HOME}/vim/backup//
                                              

                                              These tell vim to put everything in .cache (I also create those directories if they don’t exist in a file included from my .bashrc because vim sulks if they don’t exist). This also avoids cluttering my filesystem with ~ and .swp files: they all go in ~/.cache where I can clean them out centrally if I ever want to.

                                              I have this in a file included from my .bashrc:

                                              export EDITOR=vim
                                              export VIMINIT="source ${XDG_CONFIG_HOME}/vimrc"
                                              

                                              The second of these lines tells vim to source my ~/.config/vimrc file when it starts up. It will also try to source .vimrc but it’s quite happy if that doesn’t exist.

                                              With this combination, I don’t have a ~/.vimrc and everything seems to work quite happily in XDG locations.

                                              1. 3

                                                I don’t think there’s any question about a highly configurable editor being able to be made to respect XDG. But that’s not really the same as supporting it, is it? That’s a quite a bit of configuration, in files for two different programs. And even then you have to manually create directories to get it to play nice.

                                            1. 2

                                              It’s unconscionable that companies would forbid us from looking at the source code of a program that runs on a device literally embedded in one’s own body.

                                              This was a great talk. I already knew a bit about Open APS, but not about Open AAC. Thanks for sharing.

                                              1. 6

                                                Glancing over the thread, I’m surprised by how many people seem to selfhost almost everything/nothing. There are three classes of answers in the thread today:

                                                • everything I possibly can
                                                • some things, others not
                                                • only what I cannot avoid

                                                I see some “everything” answers, fewer “nothing”, some comments on people’s answers, and ≤1 inbetween. This makes me think that the decision of whether to selfhost depends almost 100% on the person who decides (and the area, perhaps) and almost 0% on specifics of each software/system/blah. This is strange and surprising to me.

                                                1. 10

                                                  Sample bias. I am the in your “some things, others not” category. I have a raspberry pi running pihole, a server for keeping some files around, and use hosted platforms for everything else. It works fine for me. However, it’s not especially interesting or unique so I don’t typically participate in this kind of discussion.

                                                  1. 5

                                                    Once I’m already adminning a server adding another service to it is almost no overhead

                                                    1. 3

                                                      I used to self host everything. I hosted my website on a Sharp Zaurus, with the files on a Compact Flash card. I hosted my own email server, a forum, various tools (RSS reader, for example), etc.

                                                      There were some problems:

                                                      • Spam filtering didn’t work very well. When I sent email, sometimes it didn’t arrive - presumably because it was seen as spam, though of course I didn’t spam anyone. I was just one person sending normal emails. When I tried putting a whitelisting system in place to stop spam, I missed emails people wanted to send me.

                                                      • Running a server requires keeping it up to date and secure. OpenBSD was good, but sometimes I’d ask it to update itself and it’d get into a knot, despite me having only half a dozen packages installed. I also tried Debian Linux. Same thing - it started spewing errors during a self-update and I didn’t know how to fix it. I’m not exactly a UNIX/Linux newbie, but I had no clue, the docs had no clue, the mailing lists had no clue… And I started again, and ran into the same again.

                                                      • You really want somewhere you can keep a ‘server’ where you can get a keyboard and monitor on it easily, without having to crouch / contort yourself, because some random thing will break and you’ll be sat there for hours trying to figure out why it’s decided not to boot, or bring up its network interface, or whatever. The easiest way, I’ve found, is to use an old laptop. ThinkPads are cheap and reliable. Unfortunately the old, cheap, reliable ThinkPad I had was also my main laptop, so my ‘server’ was always a cobbled-together load of unreliable parts.

                                                      Because of the above, and when Google were less evil:

                                                      • I moved my email there (but kept my own domain)

                                                        • Because I got too much spam and their filtering was great.
                                                        • Because I got marked as spam when sending, for no good reason.
                                                      • I moved my website to Google Sites, because my site was just a collection of ill-thought-out opinions and no-longer-useful code, but occasionally I’d get emails thanking me for certain bits of info or code, so I wanted it to live.

                                                      • I moved my forum to Google Groups, because it did spam filtering and could do email without it getting blocked randomly.

                                                      Over time I started to see that I could stick stuff on someone else’s machine and it was fine.

                                                      I made my own link shortener and pastebin on Google Cloud and used them for many years - never paying anything for hosting them, and only once being forced to do an upgrade of the pastebin code, which was painless and I had plenty of notice about.

                                                      Now:

                                                      • I’m on a different email provider
                                                      • I don’t have a personal site (most of the info on it is no longer useful to anyone) and the various sites I used to maintain that still have value are just on free static hosting (e.g. github) fronted by CloudFlare.
                                                      • That forum is still on Google Groups. I now wish I hadn’t moved it there - not because I think there’s currently anything wrong with it, but because I fear them shutting it down. Hopefully they’ll provide a migration path, though.

                                                      If I want to make tools like the previously mentioned link shortener or pastebin, I’ll do them on a cloud provider again, as it’ll cost me nothing to run, I’ll never have to worry about them going down, or having security issues, or needing their OS upgrading or hardware fixing.

                                                      1. 2

                                                        I see some “everything” answers, fewer “nothing”, some comments on people’s answers, and ≤1 inbetween.

                                                        Well, the question isn’t “which services do you self host and which don’t you self-host?”. For example, a few years ago my answer would not have included my git repositories. That’s because a few years ago I hosted my repositories on Bitbucket (when they still offered Mercurial and I was still using Mercurial). My answer would not have mentioned Mercurial at all. And like I also mention in my comment, I would not be hosting DNS myself except for the crappiness of my registrar’s DNS servers (and I fear downtime if I did switch and I just don’t have the time anymore to spend on fiddling with that stuff; it works - don’t touch it).

                                                        I see plenty of answers where “my repositories” and “DNS” is not part of the list. Since the vast majority of people here are programmers, I conclude that there are >1 in between.

                                                        1. 1

                                                          I fall in your in between category even though I said “all the things” in the first sentence of my top level comment. That was figurative language meaning I self host all the little things I like to play with and share with family and friends. Once I need reliable uptime or need to share with a large number of people I don’t know personally, I let someone who’s in the hosting business handle it. So hugginn, bitwarden-rs, 7 or 8 little web apps I make, miniflux, nextcloud, a znc bouncer, a small forum where some friends and I discuss coffee, and a few more things all get hosted by me, many using the scheme I described in my blog posts.

                                                          My email, DNS, web pages that I really need to keep online, and repositories that I need to collaborate on with arbitrary people all get hosted by people who are in the business of doing those things.

                                                          Hopefully the expansion of the “in between” you’re seeing in the replies to your comment makes it less strange and surprising.

                                                        1. 5

                                                          I’ve been learning about Finite State Transducers with the fst crate and some good videos, then, I finished some ECS tooling for checking compatibility between systems on top of the shipyard crate.

                                                          1. 2

                                                            Do you have any videos on FSTs you’d recommend?

                                                            1. 3

                                                              Sure, this talk and the following intro helped me connect the dots. Text Tagging with FSTs (Lucene/Solr) https://youtu.be/3kQyYbTyXfc Introducing FSTs https://youtu.be/jpZLwAfKbDs

                                                              1. 1

                                                                These both look great, and I don’t think I would’ve stumbled upon them otherwise. Thanks!

                                                          1. 2

                                                            Is there some milestone that made this possible recently? Regardless, this is pretty cool!

                                                            1. 2

                                                              I don’t think super recently, the checkm8 bootrom exploit was announced Sep 2019: https://twitter.com/axi0mX/status/1177542201670168576 (They’re using “checkra1n” which is a packaged binary to exploit that.)

                                                              and the “project sandcastle” folks released their beta in March 2020 last year: https://arstechnica.com/gadgets/2020/03/project-sandcastle-brings-android-to-the-iphone/

                                                              I assume kernel support (via Project Sandcastle) is only getting better, though…

                                                            1. 3

                                                              i always did this with toothpaste :)

                                                              1. 12

                                                                There’s a lot about this article I like (and the site - powered by solar power and sometimes offline/ cute!) but the xenophobia towards Chinese people is not acceptable.

                                                                1. 30

                                                                  This seems like an overreaction to me. There’s exactly two comments about China/Chinese people:

                                                                  The Chinese don’t have a reputation for building quality products

                                                                  and

                                                                  The Chinese may not have a reputation for building quality products, but they sure know how to fix things.

                                                                  But:

                                                                  • statements exhibiting prejudice != xenophobia.
                                                                  • reporting on a reputation is just stating a fact: this is indeed the reputation Chinese (consumer?) products have. You can’t infer the author thinks the reputation is accurate, especially given how they acted (they bought the Chinese product anyway).
                                                                  • even if you believe the author does think the reputation is accurate: you don’t know how many experiences they have with Chinese products. Their belief in the accuracy of the reputation may be supported by their own experiences
                                                                  • A jab against the quality of products is not a jab against the people producing the product. Even if the author phrases it using the unfortunately common conflation of a country and its people.
                                                                  • it’s human and useful to generalize: a generalization isn’t necessarily problematic, unless the conclusions are extended too far. They aren’t suggesting you don’t buy Chinese products or only let things be repaired by a Chinese person, are they?
                                                                  1. 17

                                                                    I agree with the parent, this also rubbed me the wrong way. Even just having “the Chinese” in your vocabulary is too much IMO, no matter whether it displays xenophobia or just unreflected prejudice.

                                                                    1. 9

                                                                      The author’s native language is Dutch, in which it’s still idiomatic to say ‘the Chinese’ to mean ‘the Chinese people’. It used to be idiomatic in English as well, of course, but it has gathered negative connotations in the past few decades. That’s something his proofreader should’ve picked up.

                                                                      As regard the statements about the quality of Chinese electronics and workmanship, yes, I could do without those as well.

                                                                      1. 2

                                                                        The author’s native language is Dutch, in which it’s still idiomatic to say ‘the Chinese’ to mean ‘the Chinese people’. It used to be idiomatic in English as well, of course, but it has gathered negative connotations in the past few decades

                                                                        Im curious how else you would say it? Would you attribute it to the country and not the people? i.e. China (or Chinese manufacturers) don’t have a reputation for quality?

                                                                        Is the issue attributing it to a people as a whole?

                                                                        Not trying to be argumentative, just trying to understand the issue.

                                                                        1. 3

                                                                          I just wouldn’t make unsubstantiated claims about an entire country.

                                                                    2. 17

                                                                      The Chinese don’t have a reputation for building quality products

                                                                      The funny thing about this one is that not only does the person saying it come off as prejudiced, they’re also out of touch.

                                                                      Almost any electronic device made today is built in China, with components also made in China. From high end Apple products down to bottom of the barrel knock offs. Just being made in Chna doesn’t say much about quality any more.

                                                                      1. 11

                                                                        There is a condescending tone at play though, which generalises Chinese people (e.g. the guy that repaired his laptop) to members of a group and refuses to treat them as individuals.

                                                                        I don’t take issue with the literal meaning of those sentences, but given their tone and cultural context, I think it’s rather insensitive and unhelpful.

                                                                        1. 2

                                                                          The second occurrence was referring to a repair shop they sent it to. So unless that shop was in China (I don’t think they say so, so I assume not) they’re referring to the ethnicity of the shop worker.

                                                                        2. 9

                                                                          MacBooks are made in China, so if you can agree they’re at least on par with X60 build quality, the point falls apart. Perhaps you could say Lenovo chose a subpar Chinese supplier, but that hardly indicts the whole country.

                                                                          I enjoyed my X200s until hardware failure & blue screens, and my old X61s is in a closet (some sort of display issue). Eventually, these machines wear out. I find MacBooks at least as well-designed/-built, and the M1 ain’t too shabby, so while I miss the 12” ThinkPads I’ll be fine.

                                                                        1. 34

                                                                          How common is it to find git stash scary? I can’t recall hearing that from anyone I’ve worked with. The manpage has a clear explanation of what it’s for and how it works, with multiple examples covering common use cases.

                                                                          1. 19

                                                                            I think stash is an odd corner of Git.

                                                                            • It doesn’t modify the commit graph. It’s really easy to stash stuff and forget about it. I’ve definitely rewritten code because I forgot it was stashed.
                                                                            • It’s an optional part of your workflow. I use git stash but I know plenty of people who have used git for years who don’t touch it. This means it’s not mentioned in “Intro to Git”-type resources.
                                                                            • git stash drop is one of the few ways to lose your work. I’ve lost more work stash drop than to reset --hard

                                                                            I really like git stash now, but I have learned to avoid keeping important code stashed for very long.

                                                                            1. 8

                                                                              Yeah, my stash tends to grow with dead code-paths and I have to clean it out every so often. IMO it’s particularly useful as a method to move uncommitted changes to a different a branch. The syntax of stash save will never not confuse me though, it’s so unergonomic.

                                                                              1. 2

                                                                                Hmm, in what sense does it not modify the commit graph? It seems like it does to me

                                                                                git init
                                                                                echo hello > a
                                                                                git add a && git commit -m "Added a"
                                                                                echo goodbye > a
                                                                                git stash
                                                                                git log --decorate --all --graph --pretty=format:"%C(auto)%h %<(7,trunc)%C(auto)%ae%Creset%C(auto)%d %s [%ar]%Creset"
                                                                                *   232e380 tom-g.. (refs/stash) WIP on master: 1a86647 Added a [2 seconds ago]
                                                                                |\
                                                                                | * ba5c812 tom-g.. index on master: 1a86647 Added a [2 seconds ago]
                                                                                |/
                                                                                * 1a86647 tom-g.. (HEAD -> master) Added a [10 seconds ago]
                                                                                
                                                                              2. 8

                                                                                I don’t find it scary as such, but feel it’s messy and tends to lose me work. Typically, by running into conflicts that I can’t resolve with git stash pop (possibly by accidentally popping the wrong change). I expect there might be a way to recover, but that’s where it typically ends and I start over from scratch.

                                                                                1. 2

                                                                                  Makes sense. Popping the wrong change by mistake and thus losing it would hurt. I almost always use git stash apply instead of git stash pop, though obviously sticking with apply has the side effect of the stash list growing over time.

                                                                                2. 3

                                                                                  How many here learned git with a GUI? I use git stash all the time without thinking about it but I remember avoiding it for a couple years after I somehow shot myself in the foot with it using a GUI. I only use the cli and scripting at the moment.

                                                                                  1. 2

                                                                                    I wouldn’t call it scary, however it’s common for guides to caution against it, and advocate replacing it with temporary commits.

                                                                                    The potential for merge conflicts and subsequently losing work when doing git stash pop are the one part I might call scary.

                                                                                    1. 2

                                                                                      I find stash scary because if you make a mistake with it you cannot fix it with the reflog. I use it very gingerly and only when I know my editor is also making backups.

                                                                                    1. 9

                                                                                      The thing with git stash is that it essentially just duplicates everything you can do with branches and commits, but, IMHO, not really better. I don’t really see anything in this article that’s a clear advantage of stashing either.

                                                                                      And commands such as git stash apply stash@{1} are just … ugh.

                                                                                      The problem I had with git stash is that I would build up a queue of 7 different things, and then figuring out what’s what isn’t too easy. Making a named (local) branch is just a lot easier.

                                                                                      1. 8

                                                                                        I typically use stashes when I’m not ready to commit.

                                                                                        For example, I’ll often work on something for an hour and then realize I forgot to git pull. To fix, I stash, pull, and then stash pop. If I later decide I don’t want to commit the code, I can just reset --hard and move on. If I’d instead committed, I would have to modify history or add a revert commit.

                                                                                        I almost never revisit old stashes and I periodically drop all my stashes to minimize clutter.

                                                                                        1. 3

                                                                                          Same workflow here. I recently learned about git pull —autostash which is 1 command instead of 3.

                                                                                        2. 6

                                                                                          The problem I had with git stash is that I would build up a queue of 7 different things, and then figuring out what’s what isn’t too easy. Making a named (local) branch is just a lot easier.

                                                                                          Have you tried adding comments to your stashes? To me this is what helped to make it understandable and usable.

                                                                                          1. 5

                                                                                            One nice thing about stash is that it can preserve both the index and the working tree. So if you are in the middle of a change and have git added some files but not others, git stash push followed by git stash pop will restore your previous state in a way that git commit -a wouldn’t.

                                                                                            1. 2

                                                                                              For the record, you can name your stashes when you create them to make it easier to know what’s what.

                                                                                            1. 55

                                                                                              We need a postmortem on how a small group of wokes were able to force millions of hours of toil on the entire software industry. Think of all the repos and scripts that have to be updated… my god.

                                                                                              The connection between master branches and slavery is suuuuuch a stretch: git has no concept of slave branches, but BitKeeper, the version control system git was based on did. In woke logic, being descended from something offensive makes you offensive, therefore git is offensive.

                                                                                              As crazy as this is, there’s no way I’m going to fight this one. The mobs of self-righteous wokes that police the software industry are too strong, so I will update my repos and double-check my scripts like a good little worker bee.

                                                                                              1. 46

                                                                                                Here’s your postmortem: the “small group” of “wokes” appears to be the majority of our industry, just people trying to be kinder to one another. Personally I find the change heartening.

                                                                                                1. 21

                                                                                                  I agree that this is true for a lot of things but I find this one a bit of a stretch. For example, I fully support avoiding the terms ‘blacklist’ and ‘whitelist’ because they provide a narrative that white == good, black == bad, which is not something I want to perpetuate in a society where ‘black’ and ‘white’ are adjectives applied to people independent of any personal choice on their part.

                                                                                                  The discussions I’ve seen around renaming the branch name have had white Americans leading the charge for this change and black people either saying nothing or that they don’t personally feel a negative connection with the word ‘master’ and they’d rather white folks spent more time addressing structural racism and less time addressing words with a tenuous connection to some awful bits of history. The word ‘master’ in the absence of ‘slave’ crops up in so many other contexts (in degree titles, master of martial arts, master chef, and so on) and, if anything, this narrative is pushing the idea that black people can’t (or shouldn’t) self-identify with the word ‘master’ in any context, which is pretty harmful.

                                                                                                  That said, on a personal level, I recently followed some advice in another article to put the current Git branch name in my command prompt and main gives me two extra characters of space before I wrap lines than master, so I do see a small concrete benefit to this.

                                                                                                  1. 15

                                                                                                    My own anecdata tells me that the number of black people who are uncomfortable with master/slave terminology in tech isn’t zero. I’m with you 100% on this not being the most important thing to tackle, but I fail to see why we shouldn’t do this as well as address the larger systemic problems.

                                                                                                    The default branch in git seems like such a silly thing for people to object to changing (to me, at least) as branch names have no special meaning. All these scripts that need changing have the same bug: they hard-coded a value which was never guaranteed to be static.

                                                                                                    This isn’t directed at you, but I read through threads like these and find myself wondering about the folks who argue strongly that this change, of all things, is simply too much to bear.

                                                                                                    1. 9

                                                                                                      The default branch in git seems like such a silly thing for people to object to changing (to me, at least) as branch names have no special meaning. All these scripts that need changing have the same bug: they hard-coded a value which was never guaranteed to be static.

                                                                                                      It was never guaranteed, no, but it was the de-facto default for the overwhelming majority; probably above 99%. I’m a big fan of “convention over configuration”, and that has now been kind of lost. I also have 70 git repos or some such I now need to rename (or stick to “master” which might be misconstrued as making some political point) and probably a script or three.

                                                                                                      At my last job we had even more repos, and a bunch of scripts floating left and right on people’s machines. Changing all of this for a group of ~100 devs and making sure everyone is up to date would be quite a task. Life is short; and there are real problems everyone agrees on. It just seems to me it would be much better if all that time and money was spent on more important issues.

                                                                                                      At any rate, I think why people object so strongly is a resentment over being told what to do. No one really likes that, and a lot of people have the feeling this change is being imposed upon them. Hell, I feel this change is being imposed on me, because I now need to spend time on something I don’t see the point of. It’s not a “passive change” like a project renaming some terminology which doesn’t affect much outside of some documentation or popup.

                                                                                                      Personally I think all of this is wasting a lot of political capital on something that’s … just nowhere near the top of the priority list, even if you agree it’s a problem in the first place. This seems to be a pattern I’ve seen over the last few years; this lack of focus, prioritisation, stubbornness, and tendency to divide people in camps is why I find American liberals so incredibly frustrating to deal with 🤷‍♂️

                                                                                                      1. 5

                                                                                                        At my last job we had even more repos, and a bunch of scripts floating left and right on people’s machines. Changing all of this for a group of ~100 devs and making sure everyone is up to date would be quite a task. Life is short; and there are real problems everyone agrees on. It just seems to me it would be much better if all that time and money was spent on more important issues.

                                                                                                        My expectation is that when/if this change lands we’ll all be even more bored with it. It’s just a change to the default, I don’t see why much at my work or in my personal projects would need to change. Either we’re using 3rd-party generic tooling which definitely has the ability to specify branches and better not have hardcoded assumptions by the time this actually happens, or it’s just some in-house tooling which only needs to work on our own repos.

                                                                                                        At any rate, I think why people object so strongly is a resentment over being told what to do. No one really likes that, and a lot of people have the feeling this change is being imposed upon them. Hell, I feel this change is being imposed on me, because I now need to spend time on something I don’t see the point of. It’s not a “passive change” like a project renaming some terminology which doesn’t affect much outside of some documentation or popup.

                                                                                                        I think you’re spot on when you say folks are mostly objecting to being told what to do. I think our perception of the people who (we believe) are telling us what to do is also at play here.

                                                                                                        Personally I think all of this is wasting a lot of political capital on something that’s … just nowhere near the top of the priority list, even if you agree it’s a problem in the first place. This seems to be a pattern I’ve seen over the last few years; this lack of focus, prioritisation, stubbornness, and tendency to divide people in camps is why I find American liberals so incredibly frustrating to deal with 🤷‍♂️

                                                                                                        I’m not sure I deal with American liberals much (I honestly don’t know the political leanings of the few American colleagues I have), so I defer to you here. My staggeringly obvious observation is that lately there’s a whole lot more dividing people into camps going on, by seemingly everyone.

                                                                                                        Thank you, sincerely, for taking the time to reply to me. What started as an off-the-cuff comment while I ate my sandwich has snowballed into quite the thread (by Lobsters standards anyway). I’ve spent more time thinking about this topic in the last 24h than I ever have before, that’s for sure :-) I think I’m done with this thread; my guess is most folks reading this, regardless of their thoughts on git’s default branch name, think it’s a garbage fire.

                                                                                                        1. 4

                                                                                                          I also have 70 git repos or some such I now need to rename (or stick to “master” which might be misconstrued as making some political point) and probably a script or three.

                                                                                                          This reads to me as emblematic of a certain paranoia in the id of this community that I really think we ought to call attention to (not you specifically, but this fear more broadly). This type of fear is a counter productive projection that we need to let go of because it prevents us from making real progress.

                                                                                                          I guarantee you that nobody is going to come across one of your git repos and call you out as a racist/colonizer/white supremacist/you name it. The vast majority of people calling for a better default branch name are reasonable and morally centered people who simply want to speak to their terminal without unnecessarily charged metaphors. They themselves almost certainly have git repos that will continue to use the branch master. People are not the personification of the “wokes” that the OP feels the need to fabricate.

                                                                                                          People all over this thread are afraid of the scary “woke mob” bogeyman, but if they were to get off of twitter and have an actual conversation with real antiracist people, they’d probably realize they’re normal people with strong moral values who spend energy on constructing a more just world. What’s funny to me about this whole “master” debate is that I think the folks making the most noise are the ones fighting against the change. Those pushing for it have bigger fish to fry.

                                                                                                          1. 8

                                                                                                            In this particular case I don’t expect people to come in and start accusing me of anything, but they might see “master” and misconstrue that to mean something even though it doesn’t. Of course, if I do change it then other people might also misconstrue it to mean something. I kind of feel a bit stuck here; as this politicisation of a bloody branch name is forcing me to take a position where I don’t really feel comfterable with either side (you can’t really inject nuance in a branch name). Although I obviously feel significantly less comfterable with all the “SJW cultural marxists!!!” idiocy, that doesn’t automatically mean I feel comfterable with the other side.

                                                                                                            I also don’t think that the “woke mob bogeyman” is quite as paranoid as you make it out to be; I’ve definitely seen quite a few incidents first-hand – and even been subjected to some – where people were beleaguered over a triviality, which sometimes resulted in some downright bullying. I know this isn’t the majority of people, but as the same time there definitely is a subgroup of what we might call “toxic SJWs”, for lack of a better term, which reflects really badly on the entire cause.

                                                                                                            What’s funny to me about this whole “master” debate is that I think the folks making the most noise are the ones fighting against the change. Those pushing for it have bigger fish to fry.

                                                                                                            I think that’s kind of a strange sentiment; do you expect people to just accept anything uncritically? And if there are bigger fish to fry, then why not fry them instead of wasting all this goodwill and political capital on this?

                                                                                                            1. 3

                                                                                                              I think that’s kind of a strange sentiment; do you expect people to just accept anything uncritically?

                                                                                                              Of course not. Critical thinking is required to reflect on the value of language in this context. It’s precisely a lack of critical thinking that leads to knee-jerk reactions, projections, straw men, overemphasis of the technical implications and these wacky slippery slope arguments I am seeing up and down the thread.

                                                                                                              And if there are bigger fish to fry, then why not fry them instead of wasting all this goodwill and political capital on this?

                                                                                                              Because people who care about social progress are pretty good at walking and chewing gum at the same time. You can go to the local DSA meeting, take part in a protest, read books from the library, and also send emails about git. You yourself mentioned having 70 git repos. Is it hard to imagine that a large group of people are capable of multitasking?

                                                                                                              1. 4

                                                                                                                And if there are bigger fish to fry, then why not fry them instead of wasting all this goodwill and political capital on this?

                                                                                                                Because people who care about social progress are pretty good at walking and chewing gum at the same time. You can go to the local DSA meeting, take part in a protest, read books from the library, and also send emails about git. You yourself mentioned having 70 git repos. Is it hard to imagine that a large group of people are capable of multitasking?

                                                                                                                A day still has 24 hours, so there really is a hard limit on things, and more importantly, because you’re asking other people to change with you, you also need to factor in that not everyone is willing to spend the same amount of time on this kind of stuff. This is what I meant with “wasting all this goodwill and political capital”.

                                                                                                                There are also plenty of far bigger issues that see hardly any attention, often because there is far too much focus on much less important matters. I’ll avoid naming examples so this doesn’t turn too political, but the whole “walking and chewing gum” multitask theory is a bit misguided IMHO. It annoys (even angers) me because all of this is standing in the way of actual progress.

                                                                                                            2. -1

                                                                                                              People all over this thread are afraid of the scary “woke mob” bogeyman, but if they were to get off of twitter and have an actual conversation with real antiracist people, they’d probably realize they’re normal people with strong moral values who spend energy on constructing a more just world.

                                                                                                              Is it even possible to have a conversation with these Enlightened Ones, whose moral values are so much stronger than the rest of us?

                                                                                                          2. 4

                                                                                                            You’re not black and represent exactly zero black people in tech.

                                                                                                            1. 2

                                                                                                              Very true.

                                                                                                        2. 7

                                                                                                          Or, perhaps, they are the majority of people who care. Most people don’t care too much about what to call the default branch. For the average person, this is probably a small bit of trivia. The people who care (in either direction) are probably the minority. Of course, the people are care are the people who choose.

                                                                                                          1. 4

                                                                                                            I suspect you’re correct; I’m looking at discussions like this and mistakenly assuming most people are “in the room”, but of course it’s only the people who care either way who bother to chime in. Thanks for reminding me of that :-)

                                                                                                          2. 5

                                                                                                            You you mean the majority of the leaders of large, influential entities in the industry.

                                                                                                            1. 5

                                                                                                              It’s kind of a difficult conversation to have; I think that all things considered, there are very few people who want to be unwelcome, much less (subtly) racist, but once you argue “this is a pointless change” it’s very easy to have the optics of that. This is made even worse by all the “zomg, another example of cultural marxist feminazi SJWs destroying civilisation!!!!111” idiots.

                                                                                                              Most people that I know respond to this with “sigh 🙄”, but don’t really say much about it, and a very small amount of people I know are in favour of this. This is not a very scientific opinion poll of course, but as far as I can see it’s really quite a small minority.

                                                                                                              As I argued last time, I’d personally rather not comment too much on this to give people who are actually affected by this a chance to speak without being drowned out, and in the 5 months since I placed that comment I still see mostly white people (including myself) discus issues that don’t affect them, which makes me kind of uncomfortable.

                                                                                                              1. 4

                                                                                                                How is the master branch unkind? Do you think everyone using git was being unkind until this change?

                                                                                                                1. 2

                                                                                                                  It’s not, and I certainly don’t think everyone using git is being unkind either.

                                                                                                                  I think that changing the default branch name to not reference master/slave terminology (a common thing in IT which I know has made at least one of my friends uncomfortable) shows kindness and empathy. It is a tiny, minuscule such act, to be sure.

                                                                                                                  Not making this change is not an act of unkindness. Using the branch name “master” in your repos is not an act of unkindness. An unkind act would be renaming the default branch to a racial slur. That’s my view on it, at least: not being kind isn’t the same as being unkind.

                                                                                                                  I regret my pretty barbed initial reply to you, and I apologise. Reading it back, I made distinctly unkind assumptions :-)

                                                                                                              2. 36

                                                                                                                Worth to read: The Most Intolerant Wins: The Dictatorship of the Small Minority

                                                                                                                It explains the logic behind it. The funniest part of this is that master as a word predates slavery in the US.

                                                                                                                c. 1200, maistren, “to get the better of, prevail against; reduce to subjugation,” from master (n.) and also from Old French maistriier, Medieval Latin magistrare. Meaning “acquire complete knowledge of, overcome the difficulties of, learn so as to be able to apply or use” is from 1740s. Related: Mastered; mastering.

                                                                                                                https://medium.com/incerto/the-most-intolerant-wins-the-dictatorship-of-the-small-minority-3f1f83ce4e15

                                                                                                                UPDATE: tadzik’s was correcting me on the missing qualifier for which slavery i am talking about

                                                                                                                1. 19

                                                                                                                  master as a word predates slavery

                                                                                                                  I’m pretty sure slavery existed long before the 1200s ;) Did you mean “american slavery”?

                                                                                                                  1. 12

                                                                                                                    Yes, sorry, I mean the slavery why the mob is upset now. Slavery outside of the context of USA is irrelevant to them because it does not fit their narrative. Thomas Sowell writes a lot about this.

                                                                                                                    1. 3

                                                                                                                      No worries, thanks for clarifying – and for the reading links :)

                                                                                                                  2. 6

                                                                                                                    This was an entertaining read, thanks. This should actually be the top comment, since it gives more insight on what’s going on than any ideological comment in this thread (on lobsters, but on other sites as well).

                                                                                                                  3. 45

                                                                                                                    Not only you can’t fight this one, but not actively participating in woke’s narration makes you their enemy. Even expressing dislike about this patch risks being taken as a person who is pro-slavery, which is an obvious BS. But indeed, you can’t fight with angry mob alone.

                                                                                                                    1. 13

                                                                                                                      You misunderstand the primary ‘woke’ argument.

                                                                                                                      The primary argument is that encountering the word ‘master’ reminds people of the enslavement of their ancestors, the related stories of suffering and the discrimination and oppression they are still being subjected to. It’s what is called a micro-aggression: something that isn’t a problem in small doses, but that adds up when experienced over and over again. Death by a thousand cuts.

                                                                                                                      What this change, and others like it, intend to accomplish is not unnecessarily subjecting people to such reminders.

                                                                                                                      1. 13

                                                                                                                        Guess we gotta remove it from the dictionary too, lest they chance upon it and feel hurt.

                                                                                                                        1. 6

                                                                                                                          That would be the logical conclusion from the argument, save for the word ‘unnecessarily’.

                                                                                                                          The question is when it is appropriate to not be accommodating to those that claim being hurt, because the cost of accommodating them is too high. And it bears mentioning that the cost effectively, indirectly, causes others to suffer.

                                                                                                                          It’s not all or nothing. You don’t have to reject the argument to reject the conclusion, as it hinges on costs and thus trade offs. There should be a few Schelling points here and I agree that it seems unreasonably difficult to defend some of those points.

                                                                                                                        2. 12

                                                                                                                          Well, my homeland has suffered a communist dictatorship and invasion for decades. Reading the cultural marxism here and there reminds me of the terrors my people, and specifically my family has suffered from communism in the last hundred years.

                                                                                                                          What could be changed, to unnecessarily subject me to these micro-agressions?

                                                                                                                          1. 12

                                                                                                                            cultural marxism is a conspiracy theory invented by the american far right. Go complain to them.

                                                                                                                            1. 7

                                                                                                                              Actually it’s reinforced by former USSR KGB agents ;).

                                                                                                                              1. 4

                                                                                                                                totally a reputable and unbiased source on this topic

                                                                                                                                1. 5

                                                                                                                                  Well, can’t deny that they actually had much experience with it (Stalin, Lenin), unlike USA

                                                                                                                              2. 9

                                                                                                                                sure, whatever different opinion appears it is fake news, conspiracy theory, or simply wrong, not worth consideration or discussion.

                                                                                                                                1. 9

                                                                                                                                  When there is:

                                                                                                                                  • kids being threatened
                                                                                                                                  • jews in disguise
                                                                                                                                  • any flavor of progressive agenda threatening the lifestyle of conservative or reactionary white people
                                                                                                                                  • loose attacks on intellectuals

                                                                                                                                  Yep, it’s probably a conspirancy theory. QAnon is the same, just more loud and with sweatpants instead of cheap fedoras.

                                                                                                                                  1. 4

                                                                                                                                    nah, you’re just wrong. the origins of cultural marxism

                                                                                                                                2. 2

                                                                                                                                  That one group was lucky enough to get their cause taken up by a larger group of activists doesn’t entitle any other group to get their cause taken up as well. But the arbitrariness doesn’t imply anything about the reality and worthiness of the cause (neither in the positive nor in the negative direction).

                                                                                                                                  You could start a movement to try and get your cause taken up by as many fellow activists as you can find to spread awareness so broadly that it leads to changes like the one we are discussing here. An outcome could be that promoting communism becomes something that is considered shameful.

                                                                                                                                  1. 1

                                                                                                                                    Frankly, comparing the suffering of the victims of Communism to having to make a minor change in a software workflow strikes me as wildly hyperbolic.

                                                                                                                                    1. 11
                                                                                                                                      1. If I was comparing the suffering of victims of communism to anything that would be the suffering of the victims of slavery in the USA in the context of my comment.
                                                                                                                                      2. What I was comparing is that the micro-agressions I am subjected to by some comments on the internet, are of the same category, as the micro-agressions one has to take when reads the master word while working with version control.

                                                                                                                                      If you think I should not be reminded of that, and the above is a hyperbole (not what you said), that is an opinion some share about the case about the push to remove the word master.

                                                                                                                                      1. 3

                                                                                                                                        Thanks for clarifying your position.

                                                                                                                                3. 17

                                                                                                                                  I think you can make this point without using such charged language.

                                                                                                                                  I happen to agree with the change, but I don’t consider myself a “self-righteous woke”. I read your post and felt uneasy.

                                                                                                                                  1. 4

                                                                                                                                    The obvious solution is to fork git, keep master as the default name, and give it a nice new name, like… Consolidated Source Association, or similar…

                                                                                                                                    1. 3

                                                                                                                                      So in summary, you think that master in git is not offensive, and you think that people who do find it offensive are ridiculous. Curious, how many of your coworkers are black?

                                                                                                                                      1. 71

                                                                                                                                        Curious, how many of your coworkers are black?

                                                                                                                                        This feels a bit like “what do you even know about being offended”. I share /u/y0ssar1an’s viewpoint, so let me tell you how it looks from my perspective. I have zero black coworkers as I live in a country that barely has any black people in it at all (Poland). The word “master” doesn’t hold have any negative meaning to people around here. But there is another: “Collaborator”. Used very widely in VCS-related software, in our cultural context it immediately reminds people of the old meaning: “the one who collaborated with the nazis during WW2”.

                                                                                                                                        My ancestors fought in WW2. Am I now smearing their name because I have myself become a collaborator? Should I now feel uncomfortable because someone on the other end of the world came up with a word that makes me slightly uncomfortable? No, that’d be absolutely ridiculous. Every cultures has words that make some people uncomfortable, and trying to please everyone by making the subset of the language we use smaller and smaller is not just futile imo – it’s also pointless, and arguably a detriment to diversity by itself.

                                                                                                                                        The implication that slavery is somehow inherently connected to racism is by itself an ameri-centric idea. This whole master->main “diversity theater” feels like a symptom of a particular culture being unable to deal with their past (or largely their present, afaict) and thus resorting to empty gestures rather than trying to deal with real problems – last I checked, Github, the champion of the “master bad” movement was still working with ICE who’s basically building concentration camps for minorities. But I guess it doesn’t bother people as much since it’s not so well entrenched in american culture.

                                                                                                                                        1. 1

                                                                                                                                          The implication that slavery is somehow inherently connected to racism is by itself an ameri-centric idea.

                                                                                                                                          I could not imagine what exactly it is that make America, slavery, and racism so connected! Words have meaning which are inherently connected to history. Just because you want to pretend that they always mean what makes you feel best doesn’t mean everyone is going to harbor the same narrow viewpoint as you.

                                                                                                                                          1. 10

                                                                                                                                            Outside of the USA slavery has been a think before, and at some unlucky places after the abolition in the USA. It did not generally have a racist motivation: debtors could sell themselves as slaves, prisoners of war were sold as slaves, and in many feudal states serfs had so few rights and possessions, that they were basically slaves.

                                                                                                                                            It is ironic, but in Tibet actually the invading communist chineese have abolished slavery, where it had no racist character.

                                                                                                                                            In the USA, and the Americas generally slavery did have a racist character, as the slaves sold by the Netherlander, English and Arabic slavers were mostly of African origin.

                                                                                                                                            1. 5

                                                                                                                                              Totally correct. Historians very regularly caution against comparing the brutality and sheer scale of the transatlantic slave trade to earlier forms of slavery. A great way to understand why is to go back to the fall of the Songhai Empire for it is through the unfolding of that empire and the colonial fire that engulfed its ruins that the taking and trading of slaves exploded violently and grew to dispossess, dislocate, and traumatize millions of families.

                                                                                                                                          2. 1

                                                                                                                                            The use of the (American) English language can be seen as a form of cultural imperialism, but it also allows people like you (not native English speakers, but part of the global computing community) to reach markets previously unimaginable. I think putting up with the occasional linguistic disruption that emanates from the dominant market should be worth it.

                                                                                                                                          3. 34

                                                                                                                                            I wonder how many of them have MSc degrees. You know, Main of Sciences degree.

                                                                                                                                            1. 12

                                                                                                                                              The two definitions of the word “master” for “owner” and “teacher” are a doublet, they come from different etymological paths that converged. Git derives its use from the former.

                                                                                                                                              1. 7

                                                                                                                                                And where they keep the main copy of their diplomas.