The types look great on remeda, but one thing that looks intriguing about SuperUtilsPlus is the focus on being tree-shakeable. Lodash's lack of tree-shake-ability is a drawback to using lodash on the frontend.

edit: the types on remeda look great though! If I were doing a backend-only NodeJS project, I'd be super tempted to test it out.

Just import what you use for lodash?, the theres not need for a treeshake situation?

State-based ACT scores are also highly influenced by who takes the ACT. If more students choose to take the ACT, the scores might go down even it's because your education system is doing a better job because more kids are trying for college.

For the same reason, you'll see some surprising state scores for SAT/ACT. If you're in a state that prioritizes the ACT, the main students taking the SAT are the strongest students who are looking at out-of-state schools.

Aside from the time lag, I don't think you can look at voluntary test scores and draw many useful conclusions from it.

I write a lot of JS/TS for my day job, so zx (https://github.com/google/zx) has been a nice tool for bash scripts that start getting a little too complex.

Should probably say "most engineers I've worked with," but I think that's mostly a testament to the git workflows where I've worked (lots of small commits and short-lived branches).

Plus, once you pair with one person with snazzy aliases, it might make you want to make your own

> Nowadays I instead just clone a repo to a ramdisk, purge the .git folder and then rsync it to my hoarded stash of git repos.

You're probably already doing this, but if you do a shallow clone (git clone --depth=1 ..) you'll limit the amount that ends up in .git that you need to purge.

Even with shallow clones, I'm still surprised that it ends up with a .git that's a decent percentage of the total. I just tried it on a repo and ended up with 16% of the total size being .git. I would have guessed that it'd be much smaller than that.

I had also tried that but some repos still get fairly big and all I wanted was the code not the .git since I am not a proper developer. To your point they can still be quite large.

    cd /dev/shm/block && git clone -j4 --depth=1 --branch=master https://github.com/firehol/blocklist-ipsets.git

    du --max-depth 1 -hc
    24M ./ipip_country
    4.0M ./ipdeny_country
    9.6M ./ip2location_country
    6.9M ./geolite2_country
    25M ./.git
    140M .
    140M total

It's not awful but I currently keep up to date copies of about 300 git repos and if I keep all the big ones it can add up to several GB of data I do not need. For now I just clone to a ramdisk and whack the .git directory for several of the big ones before I rsync back to disk. I probably lose some interesting history doing that.

locate is nice, but I think that on most distros its index is only updated once/day (unless you adjust the cron job that updates it more often). Most of the times I'm trying to find something, I haven't modified it recently, but it can definitely lead you astray.

One can just run 'sudo updatedb' to refresh it. Super fast if it's already on a schedule. I think mine is set to update every system update, so I just have a habit of running that before I use locate each time.

I love the look of `just` and have been meaning to try it out, but this feels like one of those examples where Make's dependency management shines—it lets you specify that many of these commands only need to run when particular files change:

    node_modules: package.json yarn.lock
         yarn install --pure-lockfile

    prettier: $(shell find src -type f -iname "\*.ts")
         prettier --check src

    ...

    ci: node_modules prettier eslint vitest

And as time goes on, I always end up wanting to parallelize the commands that can be parallelized (citest, lint, eslint), so I'll turn `make ci` (or `just ci`) into its own little script.

I think sometimes "clever" is just a term for bad code that you don't like. The clever-code react example doesn't seem like a good example of clever code to me—it just seems awful! If you were do something clever for that function, it could look like this:

  function extractDataFromResponse ([Component, props]) {
    return _.pickBy({Component, props}, Boolean);
  }

I'm cheating by using lodash, but I think this code is a fairer comparison to the unclever example that's given in the article.

Nice simplification of the “clever” code. Lodash docs for anyone curious: https://lodash.com/docs/4.17.15#pickBy

Here’s my version of the “clever” example that doesn’t depend on Lodash. It’s longer than your version but still simpler than the article’s:

  const extractDataFromResponse = (response) => {
    const [Component, props] = response;
    const dataIncludingUndefinedValues = { Component, props };
  
    return Object.fromEntries(
      Object.entries(dataIncludingUndefinedValues).filter(([_key, val]) => val)
    );
  };

Could you link to some examples of your cards? Your usage sounds cool, but I have a hard time picturing what cards I'd actually want to make.

Absolutely bonkers. It can even ^C its way out of loops.

> while true; sleep 1; echo "yay"; done

> yay > yay > yay > yay > yay > ^C