Teams I've worked on for the last several decades aim to push 10-20 builds per day to external alpha testers, so any downtime in Github is going to be an impediment.

Food logging is a ridiculously complicated task. Starting from "I ate chicken with rice, some salad, and some ice cream", this leads to myriad questions:

- What part of the chicken? Breast is lower fat than thighs.

- Did you remove the skin?

- How much chicken did you cook? Did you eat all of it, or leftovers?

- Did you cook it in oil? How much oil? What kind? Cooking temp & duration?

- You added some spices, right? What kind? How much?

- What kind of rice? White, Brown, Arboreal, Jasmine? White rice is basically sugar, might as well have a can of Pepsi.

- Was your salad a real salad with vegetables, or a tepid Caesar salad of iceberg lettuce, cheese and croutons. Did you have dressing? I hope you had vinagrette, but probably ranch.

- Be honest, you horked down the entire container of ice cream, didn't you.

- etc.

My job was to build an app that made it easy for a family member to log their consumption for everyone in the family, in just a few minutes, because the longer it takes, the less likely it is that they'll log anything.

I was given the source code to a previous project from another Stage 1 research grant that had a food/nutrition database (using BTrieve, a Terminate-and-Stay-Resident DOS application).

At the end of the summer, I had a working program that showed it was conceptually possible to do this, if you were a really good typist. While it was a Windows GUI app, using buttons and dropdowns was way too slow for data entry, so the app was designed to make it easy to enter data by typing and tabbing.

I convinced them to use MS Windows 3.0 instead of OS/2 because even then it was clear (even to me, a dumb college kid) that no one would ever use OS/2 in the home market.

Re-envisioning the problem as one where users take pictures is a big step forward, but there's still going to be a whole lot of approximation on calories and nutrition because it's necessary to guess what's inside the food concoction.

On the other hand, just using an app like this to track is great for users just to create more visibility and awareness of what they're actually eating.

While they’re busy fixing their own problems, the teams that wrote outage-free code get first dibs on writing new systems.

On the (online game) teams I worked on there are an infinite number of new & exciting systems needed, so this approach means that the best developers are the ones building them.

- end-with-blank-line: normalize file endings

- find-do-not-commit: do not commit files that include "DO NOT COMMIT"

- lint-code: run `$REPO/scripts/lint` if it exists

- lint-nodejs: run `$REPO/{pnpm/yarn/npm}` lint if `package.json` exists

- lint-shellcheck: shellcheck all the files that have no extensions or end in `.sh` that have a shell-shebang

- lint-swift: run swiftlint

- prevent-commit-secrets: run ripsecrets to avoid committing secrets and credentials

- validate: run `$REPO/scripts/validate` if it exists

By default all of the scripts check the files in the git staging area, but they can also be run standalone to check everything. You can find them here: https://github.com/webcoyote/git-multi-hook. Glad to take suggestions for more.

> Native Git traditionally executes hooks sequentially. However, you can achieve parallel execution by leveraging dedicated third-party hook managers or using built-in shell background processing

.. and that's what git-multi-hook is: a third-party hook manager, that uses shell background processing :)

Git-multi-hook predates that, but I updated it to use the new 2.54 config-based format.

The significant advantage of git-multi-hook is that they all run in parallel. I run eight hooks on precommit, so parallelism is a big win.

I will update the README to make note. Thanks!

- sandvault https://www.codeofhonor.com/projects/sandvault/ runs agents in a separate macOS user account, hardened with sandbox-exec. It also supports headless browsing and iOS Simulator from inside the sandbox for testing web and iOS apps.

- clodpod https://www.codeofhonor.com/projects/clodpod/ agents run inside a macOS VM.

- git-multi-hook https://www.codeofhonor.com/projects/git-multi-hook/ git only allows one script per hook event; this is a dispatcher that discovers and runs every script in a hooks dir, in parallel, for both global and repo hooks.

- TubeGate https://www.codeofhonor.com/projects/tubegate/ Chrome extension to block YouTube videos based on keywords (like “sponsored”).

- push10k https://www.codeofhonor.com/projects/push10k/ iOS app to track my progress toward 10,000 push-ups.

My blog is AI-coded: Zola static site, Sveltia CMS, Cloudflare Pages/Workers, with GitHub Actions handling builds and syndication. https://www.codeofhonor.com

There are 20,000 games released per year that split all that revenue, minus the cost of building those games.

The solution I'm using is certainly not as mature and featureful as WordPress, but I don't have to patch it for security holes so frequently either.

I use it every day. The #1 reason is because it never loses unsaved files (though I'm still working on breaking the habit of typing a few characters and pressing Ctrl-S). Column editing! Macros! Record/Playback! Configuration! Plugins! Responsiveness! Low resource utilization! Etc!

Why wouldn't I pay for it? I've bought all four versions. The author deserves to be paid.

I guess the question is: why don't you want to pay for it? Assuming here that you're a professional coder being paid a reasonable, US-equivalent salary. I understand not everyone fits that situation; plenty of us pirated software as starving college students / interns, folks in other countries don't get the same pay for the same work, etc.

We should all want to pay the authors of great software. We're on HN, which is a celebration of creating great code and awesome businesses.

"Pay him. Pay that man his money" - Teddy KGB

And in the "this is why we can't have nice things", that also introduced problems, because we didn't want a player who was losing to keep pausing the game until the winning player quit out of frustration, so I think we kept a per-player pause counter, which would only be restored if other players also paused? (I don't quite remember all the details, just that we had to prevent yet another abuse vector).

    // for each palette entry:
    pal.r = pal.b = pal.g = (byte) (0.299 * pal.r + 0.587 * pal.b + 0.114 * pal.b)

Since the game uses a 256 color palette, it was only necessary to update a few bytes of data (3x256) instead of redrawing the whole screen, so the effect was quick.

I also used this trick when the game stalled due to missing network packets from other players. Initially the game would still be responsive when no messages were received so that you could still interact and send commands. After a few seconds the game would go into paused state with grayscale screen to signify the player that things were stuck. Then several seconds after that a dialog box would show allowing a player to quit the game.

This was much less disruptive than displaying a dialog box immediately on network stall.