1. 1

    Following some links from that post, I discovered that Microsoft is finally updating the default console palette to something a little nicer than the traditional Windows VGA 16-color palette.

    If only it were easier to load custom palettes into GNOME Terminal…

    1. 3

      This repository has been disabled.

      Access to this repository has been disabled by GitHub staff. Contact support to restore access to this repository.

      *sigh*

      1. 5

        Parsing Models Cheatsheet

        I recently got the Earley parsing religion, which is O(n³) worst-case just like everything else, but can handle most sensible CFGs in linear time and space, even with infinite lookahead. No shift/reduce errors like yacc, no accidental infinite recursions like PEG parsers, just reliable operation.

        1. 1

          By the way, I think that GLL parsing can be similarly elegant and concise as that of Earley. I haven’t gotten around to translating that to Python though.

          1. 1

            The religion has its appeal… but doesn’t get the job done on its own. Can you recommend some implementations?

            1. 2

              If you are looking for a simple well-explained Python implementation that does the related optimizations such as Aycock’s fix and Leo’s right-recursion optimization, do look at ours. We are writing this as part of a larger book on fuzzing with grammars.

              1. 1

                Thanks! That book looks quite useful. I will share it around.

              2. 1

                The industrial-strength implementation is Marpa, which is a C library. There are bindings for various languages, but the original author’s Perl binding is the most complete.

                Searching for “earley” on nearly any language package manager will probably give you a bunch of implementations of varying quality.

                Naturally, I’m writing my own: as a learning exercise, and because I’ve got Strong Opinions about documentation quality I’d like to demonstrate. I haven’t yet got it to the point of public presentability, but it’s coming along nicely.

                1. 1

                  Would love to see your progress. Are you going the SPPF route or are you building the trees after the Earley algorithm has completed?

                  Here is our attempt at explaining Earley parsing in Python.

                  1. 1

                    I currently have zero documentation, but if you’d like to take a look at the source, I put it on sr.ht.

                    I confess I don’t know exactly what SPPF actually is, except that Loup Vaillant couldn’t understand Scott’s paper about it, and Jeffrey Kegler independently invented something equivalent which he doesn’t really explain. Basically, I build a parse-tree node for each completed item by stitching together parse-tree nodes for non-terminal symbols that appear in the right order and cover the required span. I happen to do it while the parse is in progress, but I think the same approach would work if done afterward.

                    Thank you very much for that link! I just discovered the hard way that the Leo optimization breaks naïve parse-tree construction, and yours is the first document I’ve seen that seems to acknowledge that’s an issue. Unfortunately, it only mentions it in an exercise, so there’s no worked solution, but at least there’s a hint which is more than I’ve found anywhere else.

                    1. 1

                      Unfortunately, it only mentions it in an exercise,

                      The solution is there! Look at the LeoParser using Tagged class. (Most exercises do come with a worked solution.)

                      Thank you for your link.

                      1. 1

                        Ah, right! It was late at night when I first looked, now that I’ve had some rest I can see the solution.

                        Although I’m sure I’d fare better if I’d used your tutorial from the beginning, I’ve had some trouble following the code examples:

                        • Exercise 5 has a big block of text describing the concept of a deterministic reduction path, and then it has a block of code that adds a tag field to the State class. Nothing in the text motivates this addition, and it’s not actually used in the following LeoParser class.
                        • The tag field is eventually used in the solution to that first exercise, but very subtly: inside the new leo_complete() method, a single call is changed to have an extra parameter. That’s the only change to the previous leo_complete() function, and it doesn’t have a comment pointing out the change or even a keyword argument tag=state.name to highlight that something is being done with tags
                        • It turns out that tags are not even necessary to make a right-recursion-optimised recogniser, only a parser, so this is all distraction from the idea (“deterministic right reduction”) that the text is trying to convey and it would be very easy for a reader to ignore this scaffolding and assume they’ve understood the material.
                        • By the time we get to the hint that says “any time you see a tagged state, look at its end point”, there hasn’t been any discussion of how, when or why a state gets tagged, or what a state gets tagged with. It turns out that the code does provide answers to most of those things, but (as I said) it’s pretty subtle.
                          • EDIT: Now that I look more closely, the state is tagged with the LHS of the production that was originally produced, but the code never examines the tag content, so effectively the tag is a boolean “produced by Leo reduction” flag. Is that right?
                        • Another thing that confused me: inside the parse() method of the final LeoParser, it starts by calling parse_prefix(), checking the result, and then calling chart_parse(). If I understand correctly, that code will recognise the whole input string, then throw away the intermediate and final results, then start parsing again from scratch?
                        1. 1

                          Thank you for the detailed review. While the rest of the text has gone through multiple revisions, the exercises hasn’t received as much care as the main body other than checking that the idea is correct and the implementation works. I will go through the exercise again, and clarify the points you have noted; and update you.

            1. -1

              The encryption law in question was passed.

              If you’ve got any kind of political sway in your organisation, you might want to encourage them to not buy software from Australian companies (hi, JIRA!) or at least not security-relevant software.

              1. 8

                I think it’s irresponsible to make this claim because I don’t believe the legislation in any way forces or even encourages Australian companies to produce software that is in any way less secure. I think there are some parts of the legislation where are questionable but this particular claim (that it forces the creation of back doors) is FUD.

                1. 1

                  Page 8 of the Explanatory Memorandum, emphasis as per source:

                  Allow the Attorney-General to issue a technical capability notice, requiring a designated communications provider to build a new capability that will enable them to give assistance as specified in the legislation to ASIO and interception agencies.

                  With the following “safeguard”, whatever that means:

                  A technical capability notice cannot require a provider to build or implement a capability to remove electronic protection, such as encryption.

                  1. 5

                    A technical capability notice cannot require a provider to build or implement a capability to remove electronic protection, such as encryption.

                    Right; i.e. it can’t force the creation of a back door. That’s what I’m saying.

                    1. 2

                      You can (eg) add a hidden participant to a whatsapp chat whilst keeping it E2E encrypted (not hypothetical; has happened).

                      That leaks the content to whoever holds the extra participant key. I’d call it a backdoor even if the encryption hasn’t been removed.

                      You can’t make them remove crypto, but you can make them build tech to give you the keys.

                      1. 1

                        Wording is that it can only be specific, not “systematic” - if an agency asks for you to systematically weaken security, you can’t be compelled to comply. This doesn’t apply for the “voluntary” Technical Assistance Requests.

                        1. 1

                          Per my other reply - getting yourself inserted into one conversation unlikely to be called a ‘systematic’ weakening in the eyes of the law (even if the practical outcome is that security is weaker across the board).

              1. 3

                The sea-steading on the internet crowd are entertaining, but I never see a good explanation as to why people would actually choose to live in their personal utopia.

                1. 1

                  There’s actually a good answer to this towards the end of the video - Justin Murphy mentioned at around 2:00:00 that he was running a discord server that got shut down, possibly because someone reported it maliciously to discord. Or, more accurately, he was using a server that discord ran to chat, until they suddenly decided to stop running it. One of the reasons I think Urbit is an interesting project is because it potentially offers a way for individuals and communities to run their own internet infrastructure, rather than relying on a potentially-hostile 3rd party to do so.

                  1. 8

                    That’s great & indeed running your own servers does give you (some) independence from censorship by US corporations, but that doesn’t seem to justify the whole “buy into our property owning infrastructure” thing. It actually feels very bitcoiny to me - people are buying into it in the how of being able to be on top in some future feudal society.

                    1. 5

                      My understanding was that the Urbit ecosystem was designed in a feudal hierarchy where early-adopters get huge chunks of the universe that they can sub-let to other people. So while you’re not beholden to a company like Discord to run a particular service, you’re beholden to somebody else for access to the medium at all.

                      1. 4

                        Isn’t the solution to just run discord on your own server? That seems an easier jump than going full urbit.

                        1. 1

                          I think the Urbit team is planning for a future where the very roots of the web (DNS etc) are under government control.

                          1. 2

                            Even something dumb and blockchain, like Namecoin, would be better in terms of promoting freedom. Compare the philosophical goals of Urbit with something that’s not a neoreactionary, right-wing authoritarian daydream:

                            https://safenetwork.tech/

                    1. 2

                      It’s been a while since i used Twisted Python in anger, but I vaguely recall their justification for the “one event loop per process” rule was that their event loops involved significant process-wide state, like signal handlers. Also, if you had a server socket on one event-loop and another event-loop wound up trying to trying to connect to the server, I can imagine some kind of deadlock would surely follow.

                      I think Rust’s async framework makes event-loops thread-local, so perhaps if you need your own temporary event-loop you can spin it up in a new thread?

                      1. 11

                        I kinda wish I hadn’t learned Vim — just so I could learn a more modern modal editor, Kakoune. Relearning the commands to be pretty much in reverse order (”word delete” instead of “delete word”) sounds like hell. Now, I did learn to type on Colemak after QWERTY.. but the Vim Muscle Memory™ seems much stronger than the QWERTY one was.

                        faking multiple-cursor support by coloring parts of the buffer to look like cursors and then repeating the actual cursor’s actions at those regions

                        Oh that’s how it’s actually implemented!! Dang, that’s pretty clever.

                        1. 7

                          After using Vim pretty much daily for nearly two decades, a month or so of light Kakoune usage was enough to wean me off Vim entirely. Vim’s a big program with a lot of features, so maybe I wasn’t using the really addictive ones, but I’ve seen similar comments from other people in #kakoune, so I’m not alone.

                          1. 2
                            1. 2

                              The key-chording thing is definitely an issue, but one that can be worked around to some extent with mappings. I don’t think there are any two-modifier keystrokes I use regularly, so it takes me at least as long to remember them as it does to type them.

                              I was actually pretty impressed with how string-quoting works in Kakoune. Although normal quoting works as you’d expect, the nestable quoting syntax %{} is, well, nestable, which means it almost never needs escaping and so deeply-nested string quoting is just about as natural as {} blocks in C.

                              That said, Kakoune’s “scripting” is definitely unusual… it’s very much in the vein of basic Unix and Plan9 tools where it’s blissfully easy to hack together a solution that solves a specific problem, but trying to generalise that solution is nearly impossible. I do find that frustrating, but would I be more productive with an editor scripted in.. say, Haskell? Probably not.

                              I can navigate by paragraph with [p and ]p. I don’t think I’ve ever deliberately used , in Vim or Kakoune, but for any kind of repetition I generally hold down ‘X’ to select a bunch of lines and the s command to create a selection for each thing I want to change. If I hit wi, that starts inserting before the word I just moved over; wa starts inserting after the word I just moved over (including the trailing whitespace). If you want to insert after the word but before the whitespace then yes, you’d need w;i… or just ea. I remember when I started using Kakoune, moving the selection around to the place I wanted it to be felt a bit like a sliding block puzzle, or a game of Snake, where I had to think about where my tail was going to end up as well as getting my head in the right place. I got used to it pretty quickly, though.

                              In Kakoune as well as in Vim, I tend to open an editor session in the root directory of my project and open files with relative paths from there (unless I can get there with gf, or I have a handy “find” command that autocompletes all the filenames in my project so I can just type a few letters of the file I want to open). I guess I can see the appeal of having a current directory per buffer, but I guess I’ve learned to think of my projects’s structure from a top-down perspective rather than bottom up.

                              At the end of the day, though, Kakoune’s got multiple cursors, and I don’t think I’ll ever be able to give that up.

                          2. 1

                            Why would you want to switch from modal vim to Kakoune? After browsing the top features of Kakoune, I didn’t see anything there that’s either not supported natively in vim, or couldn’t be enabled by a plugin or two.. So I’m genuinely curious what the motivation is behind the desire to switch.

                            1. 2

                              It’s not about features, it’s about this:

                               Faster as in less keystrokes

                              https://kakoune.org/why-kakoune/why-kakoune.html#_improving_on_the_editing_model

                              1. 1

                                Thanks, wow, that is an incredible concept. I guess I should have spent more time clicking around. Seems like they’d want to call that out on the front page!

                                1. 1

                                  “Faster as in less keystrokes” is what’s on the front page. Yeah I guess they could’ve linked that text to the why page..

                                  1. 1

                                    Sure, but it literally does not describe wtf that means. I had assumed they were just referring to macro support…

                          1. 6

                            At the processor level, all of this indirection is completely eliminated. One word structs get passed in registers, and the compiler will eliminate the redundant temporaries and conversions.

                            Apparently this is not always the case. Rust has the #[repr(transparent)] annotation to guarantee that a one-member struct gets treated the same way as its member, since some ABIs (ARM64 being the motivating example) treat them differently.

                            1. 4

                              It seem even arm64 guarantees that small enough structs are passed via register. From Procedure Call Standard for the ARM 64-bit, section “5.4.2 Parameter Passing Rules”:

                              If the argument type is a Composite Type whose size cannot be statically determined by both the caller and the callee, the argument is copied to memory and the argument is replaced by a pointer to the copy. (There are no such types in C/C++ but they exist in other languages or in language extensions).

                              And:

                              If the argument is a Composite Type and the size in double-words of the argument is not more than 8 minus NGRN, then the argument is copied into consecutive general-purpose registers, starting at x[NGRN]. The argument is passed as though it had been loaded into the registers from a double-word-aligned address with an appropriate sequence of LDR instructions loading consecutive registers from memory (the contents of any unused parts of the registers are unspecified by this standard). The NGRN is incremented by the number of registers used. The argument has now been allocated.

                              More details obviously at the link :)

                              1. 2

                                Those excerpts you quote guarantee that a struct containing a double would be passed in a general-purpose register (“NGRN” is “next general-purpose register number”), but stage C.1 of that section says that a bare double of a struct would be passed in a floating-point register.

                                So wrapping a primitive in a 1-member struct can introduce inefficiency, at least on ARM64 when that primitive is some kind of floating-point value.

                                1. 1

                                  Good point, so callee will have to move that double from GPR to simd/fp register before doing any operations on it, right?

                                  It’s a shame that rfc you mentioned is so lacking in details in the motivation section :(

                                  1. 2

                                    Imagine an API like:

                                    typedef struct { double x; } Metres;
                                    typedef struct { double x; } SquareMetres;
                                    SquareMetres area(Metres width, Metres height);
                                    

                                    The caller has two dimensions as doubles, it has to move them from FPRs to GPRs to make the call, area() moves them from GPRs to FPRs to do the multiplication, then back to a GPR to return the new value, and the caller moves the result back to an FPR to use it.

                                    It is a shame the motivation isn’t more detailed, but I guess it’s really a document for building consensus about how the Rust language is going to react to a problem, not describing where the problem comes from.

                              2. 2

                                That’s interesting. I admit to only checking disassembly for amd64.

                              1. 14

                                I do something like this as well, with the added layer of crazy that my dotfiles are a nix package which is installed and then linked into place.

                                But really, all I want is unprivileged union mounts that work.

                                1. 7

                                  But really, all I want is unprivileged union mounts that work.

                                  Plan 9, where art thou?

                                  I seriously don’t understand why Unix hasn’t evolved to be more like Plan 9 over the last few decades. It’s so clearly the right direction!

                                  1. 5

                                    Hey, do you have like a 10-second primer on plan 9? I always see people talking about it but have no idea how it differs from Unix.

                                    1. 7

                                      It’s sometimes said that in Unix, everything is a file. In Plan 9, everything is a filesystem, and they can be transparently or opaquely mounted on top of one another to customise the environment for each process.

                                      For example, where Unix has a special API for making network connections and configuring them, Plan9 has a particular filesystem path: write a description of the connection you want to make, read back a new path. Open that path, and the resulting file-descriptor is your TCP socket. If you want to forward your connections via another computer, you don’t need a special port-forwarding API or a VPN, you can just mount the remote computer’s network-connection filesystem over the top of your own, and everything that makes a network connection from then on will be talking to the TCP stack on the remote computer.

                                      1. 2

                                        I think Redox’ “Everything is a URL” is a nice improvement on Pan 9’s idea.

                                        1. 1

                                          Very interesting. Thanks!

                                        2. 1

                                          That’s a great question!

                                          I guess the big thing about Plan 9 is that it really tried to make everything a file. So using the network was just opening files, writing to the GUI was just writing to files &c. Really, the differences from Unix are mostly a result of that goal, e.g. in Plan 9 any user can create his own namespace of files & directories from other files & directories.

                                          The longer version would go into detail about how that actually worked (short version: really well).

                                      2. 4

                                        Do you have your Nix/dotfiles code somewhere?

                                        1. 3

                                          A more radical approach would be using rewritefs.

                                          1. 2

                                            I use home-manager, and mine looks as simple as:

                                                  home.file = {
                                                    ".stylish-haskell.yaml".source = ../stylish-haskell.yaml;
                                                    ".spacemacs".source = ../spacemacs;
                                                    ".ghci".text = ''
                                                      :set prompt "λ> "
                                                    '';
                                                  };
                                            
                                            1. 1

                                              Me too! Some more stuff I do to manage simple scripts/aliases:

                                              let
                                                script = text: {
                                                  text = ''
                                                    #!/usr/bin/env bash
                                                    ${text}
                                                  '';
                                                  executable = true;
                                                };
                                              in {
                                                # ...
                                                  home.file = {
                                                    "bin/gd" = script ''git diff "$@"'';
                                                    "bin/gds" = script ''git diff --staged "$@"'';
                                                    "bin/gf" = script ''git fetch --all "$@"'';
                                                    "bin/glg" = script ''git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr %cd) %C(cyan)%an%Creset' --date=format:'%d.%m' --abbrev-commit "$@"'';
                                                    "bin/gl" = script ''glg --all "$@"'';
                                                    "bin/gs" = script ''git status "$@"'';
                                                    # Show git branches in ~ "most recently used" order
                                                    "bin/git-bs" = script ''git branch --sort=-committerdate "$@"'';
                                                  };
                                                # ...
                                              };
                                              

                                              What I especially like about home-manager, is that it allows me to try and gradually migrate stuff to Nix, but I still can do e.g. nix-env -iA nixpkgs.umlet for quick additions/tests, and still have an escape hatch of sudo apt-get install ... if something is not available (or broken for me) in nixpkgs.

                                              1. 1

                                                You don’t need that script function. viz.:

                                                      programs.bash = {
                                                        ...
                                                        shellAliases = {
                                                          copy = "xclip -i -selection clipboard";
                                                          g = "git";
                                                          e = "emacs -nw";
                                                          ee = "emacs -nw $(fzf)";
                                                        };
                                                      };
                                                
                                                      programs.git = {
                                                        ...
                                                        aliases = {
                                                          co = "checkout";
                                                          ci = "commit";
                                                          s = "status";
                                                          pr = "pull --rebase";
                                                          l = "log --graph --pretty='%Cred%h%Creset - %C(bold blue)<%an>%Creset %s%C(yellow)%d%Creset %Cgreen(%cr)' --abbrev-commit --date=relative";
                                                        };
                                                      };
                                                
                                              2. 1

                                                I remember finding home-manager and was unsure if it worked or was testing on a not-NixOS system, so I kept using my Rube Goldberg setup :/

                                                1. 1

                                                  I can confirm that home-manager works on OSX. The home.nix file I linked to above is used both on my Thinkpad running NixOS and my Macbook running macOS (via nix-darwin).

                                                  1. 1

                                                    I’m using it succesfully on Ubuntu 16.04.

                                                2. 1

                                                  Oh, hey, I’ve been meaning to do that. Would you be willing to share your config?

                                                  1. 4

                                                    Here’s my nix expression which, in true FP style, is completely inscrutable:

                                                    { stdenvNoCC, stow, src ? ./. }:
                                                      
                                                    stdenvNoCC.mkDerivation {
                                                      inherit src;
                                                      name = "common-configs";
                                                      propagatedBuildInputs = [ stow ];
                                                      propagatedUserEnvPkgs = [ stow ];
                                                      buildPhase = ''
                                                        wd=$(pwd)
                                                        mkdir $wd/live
                                                        find . -maxdepth 1 -mindepth 1 -type d | \
                                                          grep -v 'work\|scripts\|nix' | \
                                                          while read d; do
                                                            stow --dir=$wd --target=$wd/live --stow $(basename $d)
                                                        done
                                                        echo $out > $wd/live/.config/store-address
                                                      '';
                                                      installPhase = ''
                                                        mkdir -p $out/etc/profile.d $out/cfg
                                                        cp -Lr . $out/cfg
                                                        mv $out/cfg/live $out/live
                                                        cat <<'EOF' >$out/etc/profile.d/stow-configs.sh
                                                        export PARALLEL_SHELL=/bin/sh
                                                        [ -e "$HOME/.config/store-address" ] && stow --dir=$(cat $HOME/.config/store-address) --target=$HOME --delete live
                                                        stow --dir=$(dirname $(realpath $HOME/.nix-profile/live)) --target=$HOME --stow live
                                                        # need to make sure systemd is using the latest unit files
                                                        systemctl --user daemon-reload
                                                        test -f $HOME/.nix-profile/live/.Xresources && xrdb -merge $HOME/.nix-profile/live/.Xresources
                                                        EOF
                                                      '';
                                                    }
                                                    

                                                    The src argument is a directory arranged like “programname/.dotfile”.

                                                    And this is called from a script I call nix-up:

                                                    #!/bin/sh
                                                    nix-channel --update
                                                    test -f "$HOME/lib/$(hostname).nix" &&
                                                    	nix-env --no-build-output --keep-going \
                                                    		--remove-all --install --file "$HOME/lib/$(hostname).nix"
                                                    if test -f "$HOME/.nix-profile/etc/profile.d/stow-configs.sh"; then
                                                    	echo swapping configs...
                                                    	. "$HOME/.nix-profile/etc/profile.d/stow-configs.sh"
                                                    fi
                                                    

                                                    That $(hostname).nix file has a list of packages and hooks the overlay that contains the above expression.

                                                    1. 1

                                                      Thanks! I’m excited to set it up.

                                                1. 1

                                                  To summarize, and to help myself understand:

                                                  • This about openness in the domain of communication platforms
                                                  • A platform has a community, and operates on a technology
                                                  • Some people say a platform is “open” if anyone can join the community and have a positive experience, even if they have little or no control over the technology
                                                    • for example: Salesforce (I dunno, it’s an example the article gives), maybe MetaFilter?
                                                  • Other people say a platform is “open” if anyone can set up their own instance of the technology and tinker with it, even if that means they require special skills to have a positive experience in the community.
                                                    • for example: IRC, Mastodon
                                                  • Some platforms have neither form of openness
                                                    • for example: Twitter
                                                  • However, it’s probably impossible to have both forms of openness, since something has to filter the signal from the noise of the howling void, and if it’s neither the technology nor the community, what’s left?

                                                  Homework exercise: Does Lobsters have either form of openness? Should it?

                                                  1. 5

                                                    Only tangentially on topic: I hadn’t noticed there’s a Talos II in a more hobbyist affordable price range now. Last time I looked the complete-system prices were $7k or so, and that’s still what the flagship one goes for, but now they have a $2k “Entry-Level Developer System” with one 4-core/16-thread CPU. For $2.5k you can bump it to 16G RAM and 8-core/32-thread. Still not cheap for those specs compared to x86 unless you have pretty specific POWER9-optimized stuff, but it’s at least not an absurd amount of money.

                                                    1. 5

                                                      Rumour is that there’ll be a sub-$1k option along the lines of a Mac Mini at some point, too.

                                                    1. 2

                                                      Is that magicless-fallback generally part of libc, or only in OpenBSD? For some reason I assumed the kernel did the fallback in that case.

                                                      Also, why is it important that shell-scripts can be run, but shell-scripts without a #! cannot? Is it guarding against the case where an evildoer can chmod +x and append evil commands to a non-shell-script whose content the shell would naturally ignore?

                                                      1. 4

                                                        The magic fallback is a defined part of standard execvpe interface.

                                                        It’s not particularly important. It’s a relic of the past where bits and pieces of “do what i want” snuck in. The shell, sh, should probably be just another command, but it’s kind of special, and then it was convenient to make it try interpreting x files without headers, and then people wanted every program to behave like the shell does.

                                                        The net result of littering this feature around is that future compatibility is hard because you can’t really look at or change one piece of code in isolation.

                                                        1. 1

                                                          I don’t know, but if someone’s able to issue chmod +x successfully then can’t they just add a #! at the beginning of the script - whether it’s on disk or in memory?

                                                          1. 1

                                                            Adding +x requires permissions to write the directory inode, whereas adding #! requires write permissions to the file, so it is subtly different.

                                                            1. 1

                                                              Adding +x requires permissions to write the directory inode

                                                              Huh? That’s not the case in any situation I can concoct…consider the existence of fchmod(2), for example.

                                                          2. 1

                                                            I can imagine a case where running certain files through certain shell interpreters, as opposed to a language’s interpreter, can be to the attacker’s advantage.

                                                          1. 1

                                                            I don’t think this particular article, even from a reformed Scoble, is a good fit for Lobsters which tries to maintain a laser-focus on technical issues rather than broader social ones.

                                                            That said, I hadn’t heard of Cake or its founder Chris MacAskill before, and it seems pretty cool. It’s good to hear that there’s people trying to make less-toxic social networks, but I don’t really want to sign up for any non-federated service until I understand its funding model.

                                                            1. 6

                                                              A detailed introduction on how fonts are shown in current Unix-like systems. From the nixer and author of 2bwm.

                                                              By the way, I’m having a hard time sticking with a definitive font to use, mainly because most of the bitmaps I like (dina, scientifica, curie, terminus, uw-ttyp0) are not narrow enough and the two vector fonts I really like, Luculent and Iosevka, do not look good on my T410s default screen with a dpi of 96. Luculent is close to be a winner, but when antialias is on it looks weird on st but looks amazing on Emacs at all sizes, though autohint looks very good for both. Disabling antialias and autohint does the trick on st, but on Emacs, bold, italic and bold-italic variants are still rendered with antialias on (an Emacs’ problem that I haven’t been able to solve).

                                                              I would certainly appreciate some suggestions on any of my problems. Except shooting the machine or buying a new thinkpad with higher DPI (which is on my wishlist nonetheless).

                                                              1. 2

                                                                Have you tried DejaVu Sans Mono? I’ve tried lots of default fonts for Emacs, but I always end up back on that.

                                                                1. 2

                                                                  Thanks for your suggestion. I’ve tried it but I don’t like the way it looks, feels a bit inconsistent on my eyes, I’m happy that you like it though.

                                                                  1. 1

                                                                    I used DejaVu Sans Mono for a long time as my terminal font, because it was the default on my system. Earlier this week though I switched to Inconsolata, and I find that I am personally finding it more pleasant to look at when doing console activities (although that may just be the novelty of a new font after staring at the same one for so long).

                                                                  2. 1

                                                                    I use the same one - because it’s easiest to get the same look in every OS & application for all code fonts. I’m not sure I actually like the look, but consistency is more important for me.

                                                                  3. 1

                                                                    I have no suggestions. I’m just glad to know someone else out there changes fonts as often as I do.

                                                                    (I lied, I do have a suggestion. Go Mono has worked well for me in a variety of situations.)

                                                                    1. 3

                                                                      I’m also trying out Go Mono after this suggestion (I’d never heard of the font before). It reminds me also of FreeMono (typewriteresque).

                                                                      1. 2

                                                                        Go Mono has worked well for me in a variety of situations.

                                                                        I like this one, and haven’t tried it yet. It reminds of the font used on the bootscreen of OpenBSD. I will give it a try for sure, when I get home.

                                                                        1. 2

                                                                          Go Mono reminds me a lot of the serif monospaced fonts I fell in love with on the Sun diskless workstations in uni. Thanks for the pointer!

                                                                          1. 1

                                                                            Too late to edit… looks like the Sun font was called “Sun Gallant Demi”, based on this post:

                                                                            https://unix.stackexchange.com/questions/307356/what-is-the-identification-of-the-font-being-used-for-the-solaris-console-in-tex

                                                                            1. 2

                                                                              I like that one, and I can also notice the similarities with Go Font. Which is the one I’ve chosen, it looks fantastic on my screen.

                                                                        2. 1

                                                                          I’ve settled on M+ 1mn for a monospace font.

                                                                          1. 1

                                                                            I will give that another try since last time I checked it I didn’t quite liked it.

                                                                          2. 1

                                                                            Great crisp truetype fonts (at least, at the correct size):

                                                                            1. 1

                                                                              Thank you very much for your suggestions. The three of them are seriously crisp, and I promise to give them a try when I get home.

                                                                          1. 2

                                                                            despite what ncurses wants you to believe, you do not have to define “”“color pairs””” with each foreground-background pair you’re going to use

                                                                            As someone who never actually touched ncurses as a developer: wat.

                                                                            there should be a modern library to replace curses using the capabilities outlined here

                                                                            People are definitely building these! Not 100% sure about how clean and pure-ANSI they are (seems like most of them do use terminfo, at least), but I know some libraries Without An Ncurses Dependency:

                                                                            termion is a pure-Rust one, and Cursive can use it as a backend (though it’s not the default). tui-rs uses termion by default. termui claims to be pure Go. vty seems to be pure Haskell (idk why ncurses installation is mentioned for NixOS).

                                                                            being compatible only with ANSI-capable terminals is a feature, not a bug, go the fuck away. terminfo is a fucking joke. nobody needs to target obscure dumb terminals from 1983 anymore.

                                                                            Oh yeah. Terminfo causes all kinds of problems. But wait, it’s not just terminfo, there’s also termcap, and I think there’s some kind of abstraction/indirection that uses one of these depending on platform (err maybe that is ncurses, and we have two versions of ncurses, base and ports), and on FreeBSD you can easily end up with some programs looking in terminfo and others looking in termcap! awesome!

                                                                            1. 4

                                                                              As someone who never actually touched ncurses as a developer: wat.

                                                                              “independent foreground and background colours” is a feature of the ANSI terminal model. Other, non-ANSI-compatible terminals existed, and some of them did require colour-pairs to be defined. Since it’s easy to emulate color-pairs on an ANSI terminal and impossible to implment the ANSI model on a color-pair terminal, well, ncurses went with the portable option.

                                                                              Terminfo causes all kinds of problems. But wait, it’s not just terminfo, there’s also termcap, and I think there’s some kind of abstraction/indirection that uses one of these depending on platform (err maybe that is ncurses, and we have two versions of ncurses, base and ports), and on FreeBSD you can easily end up with some programs looking in terminfo and others looking in termcap! awesome!

                                                                              termcap was invented by Bill Joy for BSD Unix, terminfo was invented later for System V Unix to fix a bunch of perceived problems with termcap. These days, ncurses implements the termcap APIs on top of the terminfo database, so they’re always in sync … but if you’re using a BSD, you might be using the historical curses library instead of ncurses.

                                                                            1. 2

                                                                              This link gives me a 404.

                                                                              1. 2

                                                                                same here

                                                                              1. 23

                                                                                I absolutely do not want to be seen as being in the same camp as the low-life scum on the internet that think it’s OK to be a white nationalist Nazi, and have some truly nasty misogynistic, homophobic or transphobic behaviour. […] And those people were […] making [me] look bad.

                                                                                Makes sense.

                                                                                I’m anti-CoC in principle but pro-CoC in practice. Why? Because of those “truly nasty” folks. I’m pro-meritocracy–in principle! But, the word is just a dog whistle now. I am truly tired of randos on the street trying to explain to me why the internet is terrible. Is this famous person publicly distancing himself from them going to help?

                                                                                1. 17

                                                                                  I’m pro-meritocracy in principle too, but I think the belief that an organization is meritocratic can and is used to justify a lot of ugly behaviors. Better to have meritocracy as an ideal and work towards it than ever claim to actually be, because it leaves room cognitively to recognize and correct when it’s not true.

                                                                                  1. 19

                                                                                    Meritocracy is not a fucking dogwhistle. I know I’ll get down voted for saying ‘fuck’ but it’s worth it. The emphasis is worth it. What you said is complete and utter nonsense.

                                                                                    Meritocracy is a great thing. The people calling it a dog whistle are the sort of people that get funded by outreach programmes to add ‘const’ to a hundred lines of code in the linux kernel and call themselves kernel developers then get offended when people suggest that’s not very good use of money. The people calling it a dog whistle are incompetent people and people that listen to incompetent people.

                                                                                    A ‘meritocratic’ country inevitably results in a country that lets poor people die on the street. But a free software project is not a country. The free software community is not responsible for providing a social safety net. Meritocracy - the idea that the people that run things and make decisions should be those with technical merit - is the only way free software works.

                                                                                    I’ve been part of open source projects run by non-technical people that picked and chose leaders and decision makers based on how much they were liked and how long they had been around and how active they were on IRC. It’s a broken model. If you’re interested in free and open source software projects in the sense that you want to actually see them develop the software ever, meritocracy is code for ‘get on with writing code and leave the politics for the voting booth’.

                                                                                    1. 14

                                                                                      Wikipedia’s Criticism of meritocracy section is a good overview of why a true meritocracy is difficult or impossible—but I don’t think you’re actually arguing for meritocracy here. It seems like your main point is that (at least in volunteer efforts like Free Software projects) work should be allocated to the people best able to perform that work, otherwise nothing will get done. That seems like a reasonable approach, and I’ve sometimes heard this described as a do-ocracy, where things get done by the people with the skill, motive and opportunity to do them.

                                                                                      I don’t think it’s strictly-speaking a meritocracy, though, since getting something done requires motive and opportunity as well as skill. Maybe the person with the most skill doesn’t have the opportunity, or they’re just interested in other things at the moment and don’t have the motive. Maybe a particular achievement requires a variety of skills, and the person who gets something done has many weak skills, even though there are many people who are much stronger in any individual skill. I’d be willing to believe that in Free Software projects, the people who get the most done are not the most technically skilled, making them the opposite of a meritocracy.

                                                                                      1. 4

                                                                                        That wikipedia articles goes through multiple definitions of meritocracy – but the first one you come into contact with reads

                                                                                        … should be vested in individuals on the basis of talent, effort, and achievement, rather than factors such as sexuality, race, gender, or wealth.

                                                                                        Talent, effort, AND achievement, which is what I think most people resonate with when they see the word meritocracy. Achievement is the doing of tasks, it takes effort and talent. I never considered a meritocracy to be based solely on skill.

                                                                                        I’ve sometimes heard this described as a do-ocracy, where things get done by the people with the skill, motive and opportunity to do them

                                                                                        Whom, I would think in the context of the project would be those who merit praise and control? I guess it is a question of order to some degree – do you get assigned something due to your merit, or do you get merit based on what you have done? I suspect many people think in terms of the latter not the former.

                                                                                        Maybe the person with the most skill doesn’t have the opportunity, …

                                                                                        Is this going with the definition that merit is only skill (talent) and ignoring effort and achievement? Akin to the referenced “1956 A. Fox in Socialist Comm. May 13/1 The ‘meritocracy’; the society in which the gifted, the smart, the energetic, the ambitious and the ruthless are carefully sifted out and helped towards their destined positions of dominance.”?

                                                                                        I think in open-source, merit in terms of control tends to follow activity, not the reverse. Additionally, if anyone is trying to help people towards their destined positions of dominance – wouldn’t that be people trying to promote certain classes of people?

                                                                                        1. 2

                                                                                          I guess it is a question of order to some degree – do you get assigned something due to your merit, or do you get merit based on what you have done? I suspect many people think in terms of the latter not the former.

                                                                                          In a system where you don’t get authority due to your merit, that’s not really a “merit-ocracy”, is it? The name for “you get merit based on what you have done” is just “remuneration”.

                                                                                          A better model would be a cycle: you attempt a small thing, you earn merit (by your demonstrated effort and achievement) and you get to attempt a bigger thing to earn more merit. But everybody (by definition) starts out with zero demonstrated effort and zero achievement, so a meritocracy needs to be bootstrapped with some other principle.

                                                                                          Since (in a meritocracy) you need merit to earn merit, merit is an inflationary cycle, and a small initial advantage can become a huge long-term advantage. Whatever principle is used to bootstrap the meritocracy can therefore have a greater effect on society than the meritocratic principle, even over the long term. And if “merit” isn’t the most relevant attribute, it seems misleading to describe the result as “meritocracy”.

                                                                                          1. 1

                                                                                            “But everybody (by definition) starts out with zero demonstrated effort and zero achievement, so a meritocracy needs to be bootstrapped with some other principle.”

                                                                                            I don’t think that’s true with code. You get merit when you write useful code in a meritocratic system. You did it here, there, wherever, and you’re a coder now. The more output or impressive designs, the more merit.

                                                                                            I don’t think a bootstrapping phase is needed if it’s really a meritocracy. It might be if it’s not. ;)

                                                                                            1. 2

                                                                                              My point is, you can’t have a true meritocracy where great merit is built on lesser merit, like great turtles stacked on lesser turtles, because eventually the turtles have to be stacked on something. You seem to be saying that one project can start stacking its turtles on some other project’s turtle stack, which while true, doesn’t invalidate my point.

                                                                                              Once you get to the point that you’re comfortable writing code and putting it online for the world to see, congratulations, you’ve gotten past the bootstrap principle and hopefully you can operate by the meritocratic principle from then on. But that doesn’t mean that the bootstrap principle doesn’t exist, or that it has anything to do with merit.

                                                                                              1. 1

                                                                                                That makes sense.

                                                                                        2. 3

                                                                                          This resonates with me a lot. I suggest reading the Walkaway from Cory Doctorow to anyone interested as it elaborates on the difference between just doing and a meritocracy in one of the earlier chapters.

                                                                                          I believe that empowering as many people as possible to contribute in a useful way is better than making it possible for a few competent ones to order the rest around. And by empowering I mean providing processes, tools and communications accessible to anyone willing to volunteer their time.

                                                                                        3. 9

                                                                                          people that get funded by outreach programmes to add ‘const’ to a hundred lines of code in the linux kernel and call themselves kernel developers then get offended when people suggest that’s not very good use of money

                                                                                          Did that actually happen?

                                                                                          1. 1

                                                                                            X, age 22, of India, has had more than 340 patches accepted into the Linux kernel – an accomplishment that contributed in no small part to her receiving one of two Linux Kernel Guru scholarships from The Linux Foundation.

                                                                                            X served as an Outreachy intern earlier this year, focused on the Linux kernel, where she worked on securing the kernel from surface attacks by making the kernel structures read-only.

                                                                                            Name changed to avoid any suggestion I’m trying to publicly shame her or anything like that. But yes, it did actually happen.

                                                                                            1. 4

                                                                                              served as an Outreachy intern earlier this year, focused on the Linux kernel, where she worked on securing the kernel from surface attacks by making the kernel structures read-only.

                                                                                              I looked at the kernel change log. That’s not a trivial project at all. The modifications are simple, but it required reading a lot of kernel code to see what could be done and it looks entirely useful. Pretty good for an intern project.

                                                                                            2. 1

                                                                                              To me, it’s much more common to see libertarian theorists who glomm on to others work, hustle funding from not too sharp corporate programs, and portray themselves as superheros.

                                                                                              1. 0

                                                                                                Of course not. It’s a routine strategy of CoC opponents to invent fantasy grievances and use slippery slope arguments in order to excuse, ignore, or detract from the real challenges a CoC is trying to address.

                                                                                                1. 4

                                                                                                  I really wish they’d knock that off if they’re doing it. It’s much easier to link to the real actions of the person, Ehmke, who wrote Contributor Covenant and pushed for CoC’s. She wrote it specifically to do things like that. In there, she’s slamming a maintainer and project pushing them to reinforce her beliefs and practices about how the project should be run… because that’s what the CoC is designed to do. Not just make people be nice, not total assholes, or whatever. In that example, they did the following:

                                                                                                  1. Show their belief that a person expressing different, political views in any medium is to be ejected from all mediums these people wield influence on, including their own software project.

                                                                                                  2. They demand a key contributor of the project that its survival might depend on be ejected with nothing in return. They expect everyone they target like this to comply regardless of the cost. The maintainer challenges them to pick up their slack contributing to the project. They show no intent to give anything in return for what they demand.

                                                                                                  3. They hit it hard all at once as a crowd ganging up on their targets, relentless, and increasing aggression as time goes on. Imagine a crowd showing up at your door unannounced yelling insults at you telling you all the changes you’ll make in your social circle or hobbies to comply with their beliefs. They want you to tolerate and comply with that situation. Depending on the location, such people would get told to get lost, be arrested, or get shot by homeowner. These people writing and pushing the CoC think it’s mandatory to do it and other accept it.

                                                                                                  4. The CoC pushers show true colors when insinuating the maintainer supports child rapists. Started with a poisoned question followed by some shaming. When I saw that, I dismissed them now and forever if they stay on same path since that’s so low it’s sickening to watch. Not to mention trivializes horrible thing. Even most sophist debaters won’t connect opponents to child rapists. These people are both ideological and “win at all costs” in a way worth stopping fast.

                                                                                                  5. Toward the end, they get into the insults and stuff showing they don’t care about offense, inclusion, etc so long as opponents have different political philosophy. They talk of burning bridges but to who.

                                                                                                  They’re usually a lot sneakier so that people can say what you just said. In that case, they went full on thinking so many people were like them and they were so much better that their plan would work with no problems. Maintainer was expecting an attempt like this, stayed in constant No mode without fighting them, and that strategy outed them better than any other. This behavior, not being transgender or trying to make peaceful communities, is why Ehmke takes so much shit from people on the net, in Github, etc. It’s also why a tool designed for such political attacks and subversion, the Contributor Covenenant CoC, should never be adopted by diverse projects if there’s even a chance such people will be enforcing it or have significant sway. I added diverse since their beliefs seem uncommon to both majority and (in my area) minority members. Latter may or may not be true in other locales, but these people don’t care.

                                                                                                  People should know their goal is to silence and eject everyone that disagrees with them even on their own Twitter account speaking personal opinion. They say they do this to prevent offense and be inclusive. Yet, they’re willing to maximize offense and exclusiveness to anyone that disagrees with them saying the end justifies the means. Even minority members disagreeing are suppressed as deluded by people with such politics. So, going with them is supporting a radical version of leftist politics willing to censor everyone from liberals to conservatives that don’t agree with them, even if otherwise civil. That’s unacceptable for an inclusive, democratic, and/or meritocratic project.

                                                                                                  And to people that think it’s inherently necessary: we disprove the theory of people like Ehmke here on Lobsters regularly with better moderation. There’s rarely bans. The group-oriented censorship that exists is mostly collapsed comments that still allows exploration of unpopular views. The moderators that disagree tolerate it if the person is still civil. The people that disagree a lot sometimes still are helpful to each other. So surprising if the theory is we can’t have a diverse, productive, and enjoyable community without CoC’s and moderators strictly enforcing radical, leftist politics.

                                                                                                  1. 2

                                                                                                    I was actually about to respond to your points, when I realized how deftly you had deflected away from mine, first by pretending to agree, then by denying [“if they’re doing it”—as if it hadn’t been right there in the grandparent post], and finally pivoting to another topic altogether. Specifically, no one claimed that CoC proponents have never acted in bad faith.

                                                                                                    So I won’t engage with that. Nice try though!

                                                                                                    1. 3

                                                                                                      I said the main CoC author and proponent designed it based on her group’s faith, used it to enforce that in many cases, forced others to adopt it with vicious tactics, and continues lie in various articles about its purpose and where the resistance is coming from.

                                                                                                      There’s no try from me so much as showing the CoC inventor using the CoC to do what it’s designed to do with her scheming more visible. Especially that it’s quite different goals and results versus what she tells many projects and companies about when pushing its adoption. That difference is important.

                                                                                                      1. 1

                                                                                                        Great! Go tell it on the mountain! Or the moon for all I care.

                                                                                                        1. 2

                                                                                                          “We are concerned about racist/sexist/immoral behavior in your project/company.”

                                                                                                          “Great! Go tell it on the mountain! Or the moon for all I care.”

                                                                                                          Still accomplishes same thing. Would you want you’re political opposites running projects to stick to those kind of replies?

                                                                                                      2. 3

                                                                                                        Refusing to engage with someone because they didn’t either completely disagree with you or completely agree with you is arguing in bad faith. I have downvoted you and marked you as a troll. I think it’s bad form to downvote without giving an explanation so that’s why I’m giving you one.

                                                                                                        1. 2

                                                                                                          Hi, I upvoted you because who gives a shit and I’m still not going to engage with nick

                                                                                                      3. 1

                                                                                                        All human projects are rift by politics, ambition, honest and dishonest differences of opinion, mistakes, anger, and all those other messy human qualities. Get used to it.

                                                                                                        1. 1

                                                                                                          In another comment, you expressed skepticism about some conspiracy by people to push their agenda with CoC’s. You talked like they’re a neutral tool designed just to get rid of bad behavior we’d all agree on. Many of you either buy into that disinformation or spread it. So, I linked to example of author using her work to do exactly the things people worried about that you dismissed as hypothetical.

                                                                                                          Oh I know people have political differences and it gets messy. Im one of a few people defending our right to on the forum. Then, there’s sneaky, political activists that tell a pile of lies about their goals, try to force their politics on others, and (surprise) pretend they are victims and/or werent doing anything at all when people resist that. Im shining the light on those scheming, lying pricks.

                                                                                                          In case you didnt know, exposing the lies of political aggressors is part of accepting and operating in a world of politics, their ambitions, and their dishonest differences of opinion.

                                                                                                          1. 3

                                                                                                            I have never suggested or argued that human beings are free of bad motives or agendas. But I’m trying to point out that these CoC’s are not being applied to previously angelic communities of disinterested technical enthusiasts - but rather to standard human groups that are already political, influenced by money, full of people who are prejudiced and motivated by all sorts of not necessarily great ideas. I was an early participant in Linux. I heard open racism and sexism plus a lot of corporate bullshit and worse. It was not shocking

                                                                                                            1. 1

                                                                                                              That’s a fair point. I’d still oppose them without modification but they would have new form. Trading one type of politics and risk for another which may be better.

                                                                                                      4. 2

                                                                                                        Of course not.

                                                                                                        Well it did actually literally happen. Would you like to apologise to calling me a liar?

                                                                                                        I’d suggest that if anyone is ‘inventing fantasy grievances’ it’s the people that come up with policies like Netflix’s new ‘you may not look at any coworker for more than 5 seconds at a time’ policy. The ‘real challenges’ a code of conduct is trying to address don’t exist. Having rules is one thing. Online communities have always had rules. Nobody has a problem with having rules. What people have a problem with is codes of conduct, because ‘code of conduct’ means ‘Americanised overly-political unnecessary rules’.

                                                                                                        1. 2

                                                                                                          “Her goal is to become a full time kernel engineer after completing this current project.” [emphasis added]

                                                                                                          Now did you accurately represent that part in your comment? Or did you willfully omit or misrepresent that part?

                                                                                                    2. 8

                                                                                                      I think you had already in mind what you wanted to say before reading what @sebboh wrote and went ahead.

                                                                                                      He is not against any of those just how the words are just thrown around.

                                                                                                      It’s like one being clearly against being a douche to others but still not liking how certain pro-CoC people are behaving.

                                                                                                      1. 7

                                                                                                        “It’s like one being clearly against being a douche to others but still not liking how certain pro-CoC people are behaving.”

                                                                                                        Describes me pretty well. Keep it civil but tolerate differences.

                                                                                                      2. 12

                                                                                                        What part of “I’m anti-CoC and pro-meritocracy” did you miss, milesrout?

                                                                                                        I presume you’re mad at someone else and you’ve simply misidentified me as them. I forgive this. It’s been a long and maddening war; we’re all stressed.

                                                                                                        Now please sit out while somebody answers my question. Will this instance of a famous ubergeek publicly distancing himself from those truly hateful folks do anything to help end the war? Can we yet move beyond Red vs. Blue? If not, what will it take?

                                                                                                        UPDATE: Sorry, I hit ‘post’ too soon. I meant to also say that the word meritocracy is being used as a dog whistle “now”. As in, ever since this current Linus news item and the response. “Used as”. I didn’t start it, I’m just reporting what I see.

                                                                                                        1. 5

                                                                                                          I don’t think meritocracy is used as a dog whistle by anyone though. That’s kind of my point.

                                                                                                          Sorry that my post was a bit aggressive. This whole CoC stuff just aggravates the crap out of me.

                                                                                                          1. 8

                                                                                                            This whole CoC stuff just aggravates the crap out of me.

                                                                                                            In all seriousness: why?

                                                                                                            1. 12

                                                                                                              Of course it is used as a dogwhistle. People have been using meritocracy or similar to justify privilege since the first cavepeople started killing each other. It’s super common for people who have unearned privileges, often unjust privileges, to angrily insist that they got what they have through hard work, God’s will, superior morals or intellect, better heredity, racial superiority (or inferiority of the unfortunate other people) or anything at all. It doesn’t matter whether you are justifying the English ruling class in 1100AD, or google programmers last week, or Tsutsis or Serbians or whaever - it’s all a shoddy bullshit effort to justify the unjustifiable.

                                                                                                              1. 3

                                                                                                                In your definition of meritocracy is it about innate ability, or is it about demonstrated skill/value?

                                                                                                                My point being, someone of privilege might have the ability to spend all their time learning, lets say polo. They become the worlds best polo player. Another human, who through the genetic and birthplace lottery is the theoretical best polo player ever but due to circumstances of birth never even sees a horse.

                                                                                                                The privileged person is the demonstrated in real life best polo player, they have actually done it. The other person while having more raw ability through the genetic lottery did not accomplish anything (in terms of polo). Is this a failure of a meritocracy, should it somehow have found the person with the most potential? Is this person who gets praise as being “the best polo player” unjustified?

                                                                                                                1. 4

                                                                                                                  You can have merit (e.g. acquired through skill and work) and also have unearned privilege. This is not a binary. However, if you are a really excellent, meritorious, polo player thanks to some combination of your skills and your parent’s wealth, you should try not to whine about how you are being discriminated against if the polo league invests in adding training opportunities for less well to do people.

                                                                                                                  1. 2

                                                                                                                    The implication from your response is that you think the merit is based on accomplishment, not potential. I don’t intend to misrepresent you, is that correct? Because if you believe it is accomplishments that create merit, then wouldn’t it follow that regardless of privilege those who accomplish the most merit the most acclaim, money, etc?

                                                                                                                    You could say most athletes at the top level are genetically privileged, they have a natural top level that exceeds that average person due to simple physics. They would likely claim they came to the top of their sport via a meritocracy, they were simply better than others, would you disagree with them?

                                                                                                                    You could easily extend this to wealth, a person with the best coaches and training might have an advantage beyond their genetics over another human being in terms of sport $X. They demonstrated the ability to win, they did so against other competitors – did they rise through a meritocracy?

                                                                                                                    1. 3

                                                                                                                      You’re oversimplifying to avoid the mess. If law/custom prevents women from becoming mathematicians, and you are a man who is one of the top mathematicians of your era, your accomplishments are a mixture of work/ability and privilege. You can’t claim to have risen to the top of the field on your own hard work/smarts, when half the population is prevented from competing. Your field cannot be fairly called a meritocracy. When orchestras started doing blind auditions, they discovered that they had not been, as they presumed, promoting on merit alone.

                                                                                                                      1. 3

                                                                                                                        I am not oversimplifying to avoid the mess, I am trying to reach understanding. We generally try to reach understanding via simplification down to root principals.

                                                                                                                        So by your definition of meritocracy – a field can only be a meritocracy if it has 100% of the population able to participate? Basically 100% EoO (Equality of Opportunity). It would follow then that you believe meritocracies do not exist – as that has never occurred, nor do I think it is likely to ever occur.

                                                                                                                        It seems to me that your point is more forceful and clear if you simply start from “meritocracies don’t exist” – they aren’t a dog-whistle, they are a straight up lie. Anyone referencing them is lying to further their own interests, or defend their status.

                                                                                                                        1. 3

                                                                                                                          I’d generally agree with the claim that “meritocracy cannot exist”; messy real-world issues mean that it can only be approximated.

                                                                                                                          I’d go further, and say that calling something a meritocracy is an attempt to pretend that those messy real-world issues are not at play.

                                                                                                                          1. 3

                                                                                                                            And I would say that is both clear and fairly compelling. I think calling it a dog-whistle is a disservice to that argument.

                                                                                                                            1. 3

                                                                                                                              I remember back in the late ’90s when Ira Katznelson, an eminent political scientist at Columbia, came to deliver a guest lecture to an economic philosophy class I was taking. It was a great lecture, made more so by the fact that the class was only about ten or twelve students and we got got ask all kinds of questions and got a lot of great, provocative answers. Anyhow, Prof. Katznelson described a lunch he had with Irving Kristol back either during the first Bush administration. The talk turned to William Kristol, then Dan Quayle’s chief of staff, and how he got his start in politics. Irving recalled how he talked to his friend Harvey Mansfield at Harvard, who secured William a place there as both an undergrad and graduate student; how he talked to Pat Moynihan, then Nixon’s domestic policy adviser, and got William an internship at The White House; how he talked to friends at the RNC and secured a job for William after he got his Harvard Ph.D.; and how he arranged with still more friends for William to teach at UPenn and the Kennedy School of Government. With that, Prof. Katznelson recalled, he then asked Irving what he thought of affirmative action. “I oppose it”, Irving replied. “It subverts meritocracy.”

                                                                                                                              Attributed to Harry Hopkins.

                                                                                                                            2. 1

                                                                                                                              You can say it can only be approximated about the goals of common alternatives to meritocracy as well. They’re all models we might strive for which will have failures or exceptions.

                                                                                                                              The model did have successes, though, like we saw with blind auditions. That’s a performance-focused technique that ignores people’s differences entirely. That’s what got more women promoted in Navy. Gapjumpers also claimed success with that model.

                                                                                                                              So, meritocracy seems like it can work if it’s blind to our differences. It’s the conscious/unconscious biases that seem to screw everything up.

                                                                                                                              1. 2

                                                                                                                                I agree that creating (or moving towards) a blind meritocracy is generally going to lead to better outcomes. It’s the claim that a group has already arrived there which I object to.

                                                                                                                                The pro-affirmative-action crowd argue that its not possible to get blind enough, so we need active counter-steering. That’s where I think principled debate is possible.

                                                                                                                                1. 1

                                                                                                                                  Another great counterpoint. :)

                                                                                                                2. 3

                                                                                                                  Me too and me too. Gah. I was still thinking about this thread after I signed out and I quickly realized that ‘dog whistle’ is certainly not a good term to describe what I observed… Sorry about that!

                                                                                                                  A dog whistle is, for example, when somebody is speaking to a group of people and they use a phrase that carries extra meaning for a subset of the group and the speaker does it deliberately to “get away with” saying something they aren’t willing to say outright.

                                                                                                                  What I see happening with the Linus-takes-a-break conversation is: folks picking up the thread and twisting it around so that it looks as if the pro-CoC crowd has committed some heinous manipulation. But that is not what Linus said happened. In fact, he said “I absolutely do not want to be seen as being in the same camp as the low-life scum […]”. Oh, ‘spin’?

                                                                                                                  Ok, so I should have said: I’m pro-meritocracy–in principle! But, the idea is being subjected to PR-style ‘spin’ now, as if to force good people to choose between adopting a CoC and opposing meritocracy. Damn the heathens who have constructed this probably false dichotomy!

                                                                                                              2. 11

                                                                                                                Meritocracy is not a fucking dogwhistle.

                                                                                                                It may interest you to know that the term “meritocracy” was invented to be precisely that: a signal that the speaker falsely believes their position of power to be justly earned, as opposed to the product of social stratification: https://www.theguardian.com/politics/2001/jun/29/comment

                                                                                                                1. 2

                                                                                                                  To be fair – words once unleashed are defined by society and not the original authors. I am not sure the average person thinks of meritocracy in terms of what it was coined to mean. Lump it in with hacker, awful, literally, girl, and tons of other words that have completely changed meaning over the years.

                                                                                                                  Possibly “meritocracy” is a poor word to be used if two people will sincerely read it exceptionally differently.

                                                                                                                  1. 1

                                                                                                                    The original definition of racism was a practice done to Native Americans that most minority members have never experienced. Do you think they similarly should stop redefining the word when saying they were victims of racism? Or are terms allowed to evolve?

                                                                                                                  2. 5

                                                                                                                    I’m pretty sure you’re allowed to drop f-bombs on Lobsters.

                                                                                                                    1. 22

                                                                                                                      You’re also allowed to say fuck.

                                                                                                                    2. 8

                                                                                                                      The word “dogwhistle” is a dogwhistle. It’s the magical sauce you sprinkle on somebody else’s words when you want to pretend they mean the most awful thing you can imagine, rather than what they actually said.

                                                                                                                      1. 2

                                                                                                                        People who are making really vile arguments often try to disguise them and then they and others will argue that as long as you don’t openly advocate something terrible, you are not.

                                                                                                                        1. 1

                                                                                                                          Now that you mention it, the radical Leftists do the same thing. Their real, vile argument is all people should be forced to conform to their narrow views by any means necessary and in perpetuity. Then, they try to disguise it when pushing CoC’s by talking about goals and offenses nobody would disagree with.

                                                                                                                          The bad folks in very different groups are a lot alike as usual.

                                                                                                                  1. 2

                                                                                                                    I always wanted to write something like this, but I never managed/bothered to assemble suitable documentation and/or existing implementations to test against.

                                                                                                                    Well done!

                                                                                                                    1. 2

                                                                                                                      Thanks!

                                                                                                                      For both documentation and implementation testing, I used plan9port. It has a one-shot client for simple reads, writes, and stats, as well as a 9p FUSE adapter. Alternatively, there’s 9p client support built into the Linux kernel.

                                                                                                                      I might spin up a 9front VM to do some even more rigorous testing, though.

                                                                                                                    1. 5

                                                                                                                      I use bash on Debian, with whatever defaults it has.

                                                                                                                      A crazy idea: when you get down to it, completion is really about defining a grammar for command-line options - “a command can be the token ls, followed by zero or more of -a, -r, …” where some of the grammar productions are defined dynamically (“filename” being the most obvious example). I’d love a completion system where I can dump grammar files in a standard format (PEG, yacc, EBNF, whatever) into a directory, and executables to produce dynamic productions into another directory; I feel like it would be a lot easier to write completion grammars in a declarative grammar syntax than the imperative-grammar-manipulation system that bash and zsh seem to use.

                                                                                                                      1. 2

                                                                                                                        It looks like this tool is grammar-based, or at least it’s a DSL and not imperative: https://github.com/mbrubeck/compleat

                                                                                                                        I definitely think the imperative model is verbose. But I think you have the classic DSL problem in this domain too: need to be able to “escape” out of the DSL for special cases. @cmhamill, who mentioned compleat in this thread, said that it’s not entirely “flexible”, and I presume that’s what he means.

                                                                                                                        1. 1

                                                                                                                          That’s a pretty cool tool, thanks for pointing it out!

                                                                                                                          It looks like the implemented grammar is a lot simpler than, say, yacc or OMeta, though. While DSLs do often need escape hatches, I’m not sure that the limits of this DSL imply that all command-line parsing DSLs are too limited.

                                                                                                                      1. 1

                                                                                                                        use emacs keybindings everywhere, in the shell, browser, you name it. On OS X, Karabiner mapped those bindings for me and now on linux laptop with GNOME it is a top-level feature.

                                                                                                                        Does anyone know what GNOME feature the author is referring to here?

                                                                                                                        1. 9

                                                                                                                          Along with UI themes, icon themes and cursor themes, GNOME supports “key themes” which determine the keybindings used in text-entry fields.

                                                                                                                          To see the current value, from the command-line:

                                                                                                                          dconf read /org/gnome/desktop/interface/gtk-key-theme
                                                                                                                          

                                                                                                                          To set the theme to “Emacs”:

                                                                                                                          dconf write /org/gnome/desktop/interface/gtk-key-theme "'Emacs'"
                                                                                                                          

                                                                                                                          (the double-quoting means it will be set as a string value)

                                                                                                                          To reset to defaults:

                                                                                                                          dconf reset /org/gnome/desktop/interface/gtk-key-theme
                                                                                                                          

                                                                                                                          There’s also a UI for this option, in the gnome-tweaks tool.

                                                                                                                          1. 1

                                                                                                                            Ahh right. Thanks for the explanation. I see there is an, “Emacs Input”, option in Tweak Tool now.

                                                                                                                            1. 1

                                                                                                                              Brilliant, I must try this, thanks!