HN user

smcameron

1,973 karma

Author of Word War vi, Space Nerds in Space, and gaseous-giganticus

Posts1
Comments517
View on HN

No, you don't commit trash to a public branch, EVER, if you can help it. Your commits are as perfect as you can make them, and that does not mean squashed in a trash compactor. That means one logical idea per commit, compiles and works as perfectly as you can make it. Use stgit, and this is easy. You do not break git bisect. No need to squash your trash in a trash compactor. Your standards are lower than mine, not higher.

At my local hackerspace, people sometimes laser cut solder stencils out of transparencies -- the plastic sheets you use with overhead projecters. The trick is to put a piece of paper under the transparency when laser cutting, otherwise they tend to melt too much and deform, but somehow the piece of paper prevents this, maybe the laser needs something non-transparent to interact with to get the heat in quickly and move on quickly. Anyway they worked pretty well, but obviously not as durable as steel, so after some number of uses they start to wear out. (Can't remember how many really, but probably something like 20? more than just 3 or 4 I think. Probably also depends on the density of holes, a big swiss cheesed area will fail sooner.) If the circuit's not too big you can cut several stencils out of one transparency all in one go.

Working with lots of changes in parallel on git can be painful. You end up juggling branches and commits, and running scary rebase -i commands that can leave your tree in a half-broken state if you so much as sneeze.

I mean, just use stgit[1] to maintain a stack of patches instead of parallel branches, it's so much better. You can easily wrangle thousands of patches (aka commits) with stgit.

A lot of people, on first encountering stgit, read a bit about it, think "why do I need this? I can do the same thing with just plain ol' git.". Yeah, you can. But not at scale. Not practically. Not with thousands of commits. And it makes the case when you just have a few tens of commits absolutely trivial. Try it for awhile and you'll find it indispensible.

[1] https://stacked-git.github.io/

My own efforts in this area amount to creating the game, Space Nerds in Space[1], which is a LAN game in which everyone gathers in a room with their computers, and each computer acts as one of the stations on the bridge of a starship: navigation, weapons, science, comms, engineering, damage control, etc. Multi-bridge is supported as well, so if you can overcome the insurmountable task of gathering enough people together, you can indulge in that luxury. This is in the same genre as such games as Artemis: spaceship bridge simulator and Empty Epsilon, but with the additional hurdle that it's linux only. Good luck mustering enough spacenerds. If there are missing features, well, it's open source, so it's got that going for it, which is nice.

[1] https://smcameron.github.io/space-nerds-in-space

The TI99/4a version of the Logo language which has turtle graphics used user defined characters to implement them. There were only (I think) 128 user definable characters, and when the turtle graphics had redefined all of them to create its output, it gave the user a message, "out of ink".

PRs can contain multiple commits. You need something like stgit to make it easy to make a bunch of small commits that appear to be the work of an omniscient genius who knew exactly what they were doing. Try using stgit for awhile, and you'll wonder how you ever lived without it.

Something like those switches might be made very cheaply with a 3D printer, possibly a laser cutter, some transparent or semitransparent acrylic sheet, tactile switches and some LEDs. I designed a cheapo replacement for $50 tellite switches and got the price down to about $0.60 Not quite the same, as these are a lot bigger, and getting things down to the desired size might be troublesome. Anyway, here's a little video of my fake cheapo tellite switches: https://www.youtube.com/watch?v=LaenrgPVCjc

Using LLMs at Oxide 8 months ago

I found it funny that in a sentence that mentions "those who can recognize an LLM’s reveals", a few words later, there's an em-dash. I've often used em-dashes myself, so I find it a bit annoying that use of em-dashes is widely considered to be an AI tell.

I've got an internal alarm that starts to go off somewhere around 72 hours.

Nah, in my experience, if you've got good commit hygiene you can often merge even ancient commits.

Here's a pretty hefty commit I merged five years after it was originally written, converting a ~100k line codebase from GTK to SDL2, written in 2015, committed in 2020, with tons of development in between, with "10 files changed, 777 insertions(+), 804 deletions(-)"

https://github.com/smcameron/space-nerds-in-space/commit/4ab...

I was expecting it to be a bit of a nightmare, but it really wasn't bad at all.

- “every commit must compile” - again, unnecessary overzealousness.

So you're the one breaking git bisect all the time. Grrrr.

Use stgit and make decent commits instead of rolling in the dirt like an animal.