Probably obsolete and broken by now, but one of my favorite mini projects.

(And I just realized the graph is all but impossible to read in dark mode)

https://github.com/pmahoney/fastup

I'm not an expert here, but this is not generally true. See "giftcard escheatment laws". I think these vary by state, but see e.g. https://legalclarity.org/when-do-gift-cards-become-subject-t... The value of abandoned cards goes to the state.

My speculation: it was intended to mean: use it under terms of GPLv3 (for commercial purposes or not), OR contact to negotiate different terms.

But there's a built-in assumption that no commercial entity would _want_ to use it under GPLv3 terms.

There are ppx things that can automatically derive "to string" functions, but it's a bit of effort to set up, it's not as nice to use as what's available in Rust, and it can't handle things like Set and Map types without extra work, e.g. [1] (from 2021 so situation may have changed).

Compare to golang, where you can just use "%v" and related format strings to print nearly anything with zero effort.

[1] https://discuss.ocaml.org/t/ppx-deriving-implementation-for-...

> Scavenger is a cool arcade/thinking game very much like Lode Runner. You've got to run around and collect objects while avoiding enemies. Some objects are buried and you've got to dig down to get at them. It's an addictive game and some of the levels are devilishly (cruelly) complicated to solve.

https://linuxmotors.com/linux/scavenger/index.html

With that, you can do

    $ zbarimg -q --raw qrcode.png | pass otp insert 
    $ pass otp   # or pipe to xsel

> How do you as a method author opt in to distinguishing between [break and next] after yielding to a block?

I don't use Ruby much lately, but if I yield to a block which calls break, control will pass to the code following the block (and not back to my method). If the block calls next or simply finishes, control passes back to me though I cannot know if next was called or not (but do I care? I can go ahead and yield the next element of a collection either way)

https://www.gocomics.com/calvinandhobbes/1993/04/20

That is, while vitamin D can be used to deduce someone's amount of sun exposure, the benefits of sun exposure are not coming from the vitamin D.

[1] https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7400257/

https://news.ycombinator.com/item?id=32005421

However, we also ran into many problems that felt like we were the first to encounter them (few or no similar reports on project bug lists or StackOverflow etc.) which is never fun if you're under any kind of pressure to deliver.

In hindsight, if I had something small and reasonably isolated (a microservice?), it could make sense to use JRuby or Truffle (if you need some JVM lib; if it's purely for performance reasons I'd just grab a different language for that microservice). But for a larger app that pays the bills, I'd stick with the well-trod path (at the time that was MRI, Unicorn, single-threaded).

Sounds dystopian. Hustle and bustle of life aside, physically cooking things can be enjoyable. On the other hand, when I cook "from scratch", I'm buying conveniently packaged ingredients (I don't grow or grind my own flour for example), so maybe I'm happy with my current level of effort from simple familiarity.

> While the other competitors stopped to sleep for six hours, Young kept running. He ran continuously for five days, taking the lead during the first night and eventually winning by 10 hours

https://en.wikipedia.org/wiki/Cliff_Young_(athlete)

I suppose an upgrade would still result in two copies of everything, at least temporarily, but at least the target system doesn't need source code, compilers, etc.

https://nixos.org/manual/nix/unstable/command-ref/nix-copy-c...

For example, RESOLVE_IN_ROOT "is as though the calling process had used chroot(2) to (temporarily) modify its root directory (to the directory referred to by dirfd)".

[1] https://man7.org/linux/man-pages/man2/openat2.2.html

    thingThatCanFail() {
      echo "step one succeeded"
      echo "step two failed"
      false
      echo "step three was run too"
    }

    if ! thingThatCanFail; then
      echo "thingThatCanFail failed!"
    fi

If "thingThatCanFail" is called _outside_ of an if statement, then `set -e` causes different behavior (i.e. step three _is_ skipped).

I instead use lots of chaining with && (as in the article), or explicit checks after each command. I have two utility functions I define in nearly every script:

    warn() { >&2 printf "%s\\n" "$*"; }
    abort() { warn "$@"; exit 1; }

    stepOne || abort "step one failed"
    stepTwo || abort "step two failed"
    ...

    let my_regex =
      let open Re in
      seq [
          bos;
          opt (str "0x");
          repn (
              alt [
                  rg 'A' 'F';
                  rg 'a' 'f';
                  rg '0' '9';
              ]
          ) 4 None |> group;
          eos;
      ]
      |> compile

One advantage of the expanded syntax is that it's a bit nicer to incorporate a string variable, e.g. "str some_string" vs. "/#{Regexp.escape(some_string)}/" (to borrow Ruby's syntax).

[1] https://github.com/ocaml/ocaml-re