1. 12

    I feel like this misses the mark at a basic level: I don’t want to write async rust.

    I want to write concurrent rust and not have to worry about how many or which executors are in the resulting program. I want to write concurrent rust and not worry about which parts of the standard library I can’t use now. I want to write concurrent rust and not accidentally create an ordering between two concurrent functions.

    1. 19

      I feel like those wants don’t align with rust’s principles. Specifically rust has a principle behind making anything that comes with a cost, explicit. It doesn’t automatically allocate, it doesn’t automatically take references, it doesn’t automatically lock things, etc. What you’re suggesting sounds like making transforms that come with costs implicit. That’s a reasonable tradeoff in many languages, but not rust.

      1. 12

        Sure. This initiative seems really great for people who end up choosing to use async Rust specifically because they need it for their high-performance application, and it sounds like they’ll really get a huge benefit out of this sort of work!

        But I feel like a lot of people don’t actually want to use async Rust, and just get forced into it by the general ecosystem inertia (“I want to use crate X, but crate X is async, so guess I’m async now (or I’m using block_on, but that still requires importing tokio).”). These people (hi, I’m one of them!) are going to be difficult to win over, because they don’t actually want to care about async Rust; they just want to write code (for which async Rust is always going to be net harder than writing sync Rust, IMHO).

        1. 5

          I think you’re describing a desire for the Rust ecosystem whereas the proposal in the OP is about the language. I’ve also been there, wanting to use library X but it turns out its async. This, to me, isn’t a language problem, it’s that someone (including myself) hasn’t written the library I want in a sync context.

          I don’t believe anything in the proposal is going to directly related to the situation you described.

          1. 1

            That’s a very fair point! :)

      1. 3

        I am currently experimenting with TiddlyWiki and its journal feature which has a stated goal of being self-contained and staying usable for the long term. And has many options for storage.

        1. 2

          What mechanism do you use to save (and sync across machines) tiddlywiki pages?

          1. 2

            I would be interested in this as well unless op is thinking about using a hosted tiddywiki instance.

            1. 1

              I have Caddy with the webdav and jwt plugins. It works great until the jwt expires, so turning off autosave is a must.

              1. 1

                I am still experimenting. Right now I use the node based server on my laptop, running against a data directory in a Dropbox folder. But this is more for backup than sync.

                1. 1

                  My ideal case would be any solution that involves each save directly writing to the local file (a Chrome extension, perhaps?), so I can just sync that file in Keybase filesystem, and get automatic sync as a result.

              2. 2

                a lot of people complain that tiddlywiki becomes unusable once you have too many tiddlers. I’ve tried it out and it works but i’m backing out for this reason

              1. 2

                I would use acme via plan9port, but my current workstations run fedora silverblue, which is wayland based and Xwayland makes a bunch of features break.

                1. 2

                  Fedora Silverblue, Gnome Terminal (although I’ll probably be switching to Tilix to make better use of bigger screens), Firefox, and vim.

                  I would like to go back to using acme, but it doesn’t work correctly in XWayland and I haven’t yet bothered to try to port devdraw to Wayland. I assume that’ll be a giant pain and not work correctly.

                  1. 17

                    Boot Stomping Human Face: Faces Deserve to be Unstomped

                    1. 1

                      I just got an ergodox ez, and… man, I do not like the column layout.

                      I’m undecided on whether I should attempt to power through what feels like typing through sludge, or if I should just eat the cost of shipping it back :/

                      1. 3

                        Give it at least two weeks. It took me about that long to unlearn my bad habits from decades of typewriter-style staggering, and once you do it’s so much more comfortable.

                        1. 1

                          I might buy that, but even then, I have to/will use other, normal keyboards in the interim.

                          1. 5

                            Yeah, you should give it more time. When I first used the Atreus I was afraid my fingers would break, and was really slow. But that turned upside down when I got more comfortable with. Typing now is faster, more accurate and a lot more smooth then with the classical typewriter layout.

                            And surprisingly, typing on a normal keyboard is not going to much worse when you get used to ortholinear. Although, for some reason, I mix up ‘c’ and ‘v’ on regular keyboards much more often now.

                          2. 1

                            This is the thing I keep trying to do with my Ergo EZ, I will use it in bursts but then switch back to my staggered so I feel productive. I just need to be super strict for longer and completely embrace it

                          3. 3

                            It took my about six weeks to get used to the ortholinear layout on my DIY board. Now that I am used to it I much prefer it to a normal row staggered keyboard. But it was very much a slog for the first several weeks to a month.

                            1. 3

                              do some typing tutorials / games, deliberate practice

                              it was very uncomfortable but i got used to it very quickly with a bit of practice

                            1. 6

                              So… is the modern part that javascript and several network interactions are in between the “store some markup” and “write html into a file” steps?

                              1. 13

                                I find the single most useful thing has been using it as a place to ask myself questions, and answer them.

                                This has been a revelation for me over the past few months. I’d heard people say things like this in the past, but I never quite clicked that they actually meant “ask yourself a question” rather than “think about something”.

                                If I ask myself a question, out loud if possible, and then attempt to answer it, I’m often surprised by the outcome. Half of the process is iteratively refining the question itself, the other half refining the answer.

                                1. 6

                                  There’s probably psychological research on this but I’ve been thinking that maybe thinking itself is meant to be collaborative or competitive, at least in a lot of contexts, and that’s why language is such a big part of thought. And if dialogue is linguistically, rhetorically, communicatively a good way to explore a topic or question, then I should probably have dialogues with myself too. Like, why would an inner monologue be better than an inner dialogue?

                                  1. 2

                                    Dialogue is a very natural thing as well, have you ever argued with yourself over a purchase? How about an implementation?

                                    1. 2

                                      I think this technique ties in to the same brain machinery as Rubber duck debugging, with similar good effects.

                                      1. 1

                                        As far as I’m aware, thinking evolved from language, so it being “naturally” collaborative absolutely makes sense.

                                        Part of it (at least for me) is that it’s far easier to stay on topic when I’m participating in a dialog; even when that dialog is with myself.

                                      2. 6

                                        It also reminds me of one of my favorite papers that I re-read often (although not often enough): https://www.microsoft.com/en-us/research/uploads/prod/2016/12/State-the-Problem-Before-Describing-the-Solution.pdf

                                        1. 2

                                          Good callout. I thought this was one of the key insights in the article as well.

                                        1. 1

                                          Can it really be “introducing” when it doesn’t say anything?

                                          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

                                                              I’d like the benefits sans the inane ideology, thanks.

                                                              1. 2

                                                                I wish Silverblue were ready for primetime. Hopefully within the next release or two.

                                                                1. 2

                                                                  I thought this was the release that was going to have async/await?

                                                                  1. 3

                                                                    Looks like it was never going to be.

                                                                    That’s a shame, too, as rust’s current solutions of “write pthreads but with fewer features” or “chained call hell” are both underwhelming.

                                                                    1. 1

                                                                      Do you know if the 1.31 beta (TBA on Monday, according to the article) is going to have them?

                                                                      1. 1

                                                                        I don’t think so, the tracking issues I found are nowhere near completion.

                                                                        1. 6

                                                                          async/await is pushed to next year. Sadly. I’m also very annoyed by this :/. I support the why (the wish to deliver a very good feature) and see why it doesn’t happen, though.

                                                                          The syntax will be blocked on edition 2018.

                                                                  1. 6

                                                                    I’ve wanted a laptop with an eink display for a long time now, and was disappointed to see the kickstarter to being over the pomera DM-30 fail. The possibility of hacking one together myself is appealing.

                                                                    1. 4

                                                                      This seems like the Gerrit approach.

                                                                      Every day I have to use Github, I long for Gerrit’s embrace.

                                                                      1. 14

                                                                        It’s a little bit like forming one major workers’ union for open source maintainers.

                                                                        It’s not at all like that. It’s a de-productized Glassdoor (which does sound good) glued to some sort of coop/corporation/nonprofit.

                                                                        Virtual penny for your thoughts.

                                                                        It seems like all this is re-inventing “taxes” and “regulation” but with less teeth and more computers. If we instead forced these companies to pay just amounts of taxes, made the companies worker-controlled, and provided social services such that people didn’t need a job just to exist, all these problems would also be solved. And, as a bonus, it’ll be solved for people that aren’t professional computer botherers.

                                                                        1. 3

                                                                          Well sure, let’s take it all the way to Universal Basic Income while we’re at it, I’m with you all the way! But that’s no doubt decades away still. Don’t dismiss a solution viable in the short-term just because there’s a better way to solve it in the long-term.

                                                                          1. 4

                                                                            Don’t dismiss a solution viable in the short-term just because there’s a better way to solve it in the long-term.

                                                                            I’d hesitate to call it a “solution” when I don’t see it as engaging with the real problem, namely extracting value from a de-commoditized commons. Getting compliance with the scheme would be a huge lift with a fairly narrow focus. The political infrastructure required (unions, guilds, activism, etc) needs to be built in both the private governance model and the “traditional” governance model, so why not embark on the project that has a larger pool of people to draw from?

                                                                            1. 2

                                                                              If it’s decades away then solving the problem is decades away. It gets further away every time someone dismisses it in favour of some short-term ‘solution’ that doesn’t solve anything.

                                                                              Don’t dismiss a solution viable in the short-term just because there’s a better way to solve it in the long-term.

                                                                              I don’t think this solves anything. I think it makes everything worse, just like everything that isn’t actually free software.

                                                                            2. 3

                                                                              made the companies worker-controlled

                                                                              Let’s not…most workers have the business sense of a stoned rabbit.

                                                                            1. 3

                                                                              Baking It’s like programming, but with matter. And also everything is rife with side effects.

                                                                              Running I find running very meditative. I did have to learn how to not gas myself immediately.

                                                                              Other than that, various entertainment like books, TV, games. I keep meaning to read more. I’ve largely stopped programming in my free time and may come back to that.

                                                                              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. 3

                                                                                              I would like nix so much more if I didn’t end up with 6 copies of gcc and a texlive install every time I installed something nontrivial.

                                                                                              1. 1

                                                                                                Yep. I wondered “where did that texlive install come from” recently too.

                                                                                                1. 2

                                                                                                  There’s a few tools for this. For example, you can ask where it’s installed:

                                                                                                  $ nix-store -q --roots $(which ghc)
                                                                                                  /nix/var/nix/profiles/per-user/brian/profile-377-link
                                                                                                  /nix/var/nix/profiles/per-user/brian/profile-378-link
                                                                                                  /nix/var/nix/profiles/per-user/brian/profile-379-link
                                                                                                  /nix/var/nix/profiles/per-user/brian/profile-380-link
                                                                                                  

                                                                                                  Or if it’s just alive from a shell or something, you can ask what referred to it:

                                                                                                  $ nix-store -q --referrers $(which ghc)
                                                                                                  /nix/store/kjxr0bm87jljb91qd7k47cqiknnxdknx-ghc-8.2.2-with-packages
                                                                                                  /nix/store/1djxkifaxmz940x571ab4ndfmvmb1lh5-env-manifest.nix
                                                                                                  /nix/store/crxhjrgkngwk8bv77sy6bxl19k6id2f3-env-manifest.nix
                                                                                                  /nix/store/50rbrla0m0819wr788gs588qi7yl6vxy-user-environment
                                                                                                  /nix/store/7wqjzgci6v9fnhgs0zsvxhhc6hzjczfv-env-manifest.nix
                                                                                                  /nix/store/i3gz4d3jkqkh4v9vscx7s2fa0q7wll3q-env-manifest.nix
                                                                                                  /nix/store/f53kz6isz60xr83yiwvl7xw0b2v5k5pg-user-environment
                                                                                                  /nix/store/wc037in1jmkdwxj1hhjhbih5arwazrcw-user-environment
                                                                                                  /nix/store/zismyry5a61xwpvnkvdidiqgvcrqwg04-user-environment
                                                                                                  
                                                                                                  1. 1

                                                                                                    Thanks, I’ll look into that. I’m curious why things even need texlive in the first place - seems like it’s unnecessary to have for a running system.

                                                                                                    Personally, I’d love to see NixOS be able to meet requirements like this - the Nix store seems like it would facilitate reduction of attack surface if derivations could either be written in a more minimalist way or if containers (or the system in general) could include only the smallest set of software they need to run.

                                                                                                    (edit)

                                                                                                    OK, I tracked it down:

                                                                                                    $ nix-store -q --referrers /nix/store/h610l0v3b3d6mqfwapgd8jb0jxilbd47-texlive-combined-2018.drv
                                                                                                    /nix/store/f0ir4m0ww8qjbialvjxrv7zzlmhsmrjc-dwarf-therapist-41.0.2.drv
                                                                                                    

                                                                                                    A package I maintain apparently used it as a build input… sigh

                                                                                                    Does this mean dwarf-therapist is still referencing texlive as far as the GC is concerned, even though it’s already built? A nix-collect-garbage -d didn’t clean it up.

                                                                                                    1. 2

                                                                                                      Seems relatively pointless, if an attacker can write source code to disk they can also just write precompiled binaries to disk (or just keep shell code in memory and never touch disk).

                                                                                                      1. 1

                                                                                                        Yeah. Requirements sometimes are that way. :-(

                                                                                                        More to the point though - it’s the same “if your users don’t need it, don’t include it” approach hank mentioned. You probably won’t need to compile programs on a production system, so why include a compiler, even one that a user would have to manually spelunk through the Nix store to use?

                                                                                                        1. 1

                                                                                                          Nix detects dependencies automatically and sometimes package maintainers don’t notice they accidentally did something to include one. It could be considered a bug with a ticket if it isn’t necessary for a program to function.

                                                                                                          1. 1

                                                                                                            I’m seeing a lot of things that use nativeBuildInputs sticking around in the Nix store on my setup.

                                                                                                            From the manual:

                                                                                                            since these packages only are guaranteed to be able to run then, they shouldn’t persist as run-time dependencies. This isn’t currently enforced, but could be in the future.

                                                                                                            And, indeed, I’m seeing them ref’ed by certain packages that needed to be compiled locally:

                                                                                                            $ nix-store -q --referrers /nix/store/imfm3gk3qchmyv7684pjpm8irvkdrrkk-gcc-7.3.0/bin/gcc
                                                                                                            /nix/store/imfm3gk3qchmyv7684pjpm8irvkdrrkk-gcc-7.3.0
                                                                                                            /nix/store/8xfm1g4vbv0mv0mn7zlny85dhmw3djvm-dfhack-base-0.44.12-r1
                                                                                                            /nix/store/fj0qxv4lqrgnva1yhn09f641373rbjvy-dwarf_fortress_unfuck-0.44.12
                                                                                                            

                                                                                                            So, it sounds like nativeBuildInputs should be GC’ed, but currently aren’t for some reason. I just assumed they would be. I’d be curious to see what’s producing extra copies of texlive for hank as well.

                                                                                                      2. 1

                                                                                                        You’re asking which derivations mention your TexLive derivation. You’re not asking what references the TexLive output. I wouldn’t worry about disk usage of these small derivations.

                                                                                                1. 4

                                                                                                  I use ledger, but I’m not quite happy with it.

                                                                                                  Data entry is labor intensive, there’s no good mobile story, and my bank’s export data is a pile of slinkys and not easily scriptable. Once my ledger files look like reality, though, asking questions is something like Pareto optimal. 80% of my queries are builtin commands with few flags, the rest are a bit tougher. I’d estimate a handful are impossible/broken for various implementation or modeling reasons.

                                                                                                  Edit: I started porting over to beancount on my lunch break. Fava is a killer app for beancount.

                                                                                                  1. 2

                                                                                                    “pile of slinkys” !!

                                                                                                    1. 1

                                                                                                      Seriously. Simple’s json format radically changed when they changed backing banks and there’s at least 3 different kinds of credit/debits with different ways of specifying when things posted. I was completely unable to fix it with jq.

                                                                                                    2. 1

                                                                                                      This is my experience as well. I even spent a couple days automating the process of data entry as best I could. I think it ended up in a good place, which I achieved by enforcing idempotence and by making it easy to define regexes to match transactions from the source to turn them into the proper Ledger accounts. But, I haven’t been keeping up with the data entry. I have several sources I need to add, and it’s just too labor intensive to manually go through every source’s abysmal web UI, point and click to get a csv or a PDF or whatever.

                                                                                                      1. 2

                                                                                                        It’s amazing that it’s $YEAR and there’s no way to get an oauth token and read-only my transaction activity.