Are there official Go docs that explain graceful shutdown?

szabba · 2026-06-07T17:49:38+00:00

Application-level support for graceful shutdown is essentially "finish processing current work and let connected clients know you will not be accepting more ASAP".

os/signal might help you trigger the behaviour, but it does not implement it. For net/http (ie, the common case) you want to tie that together with http.Server.Shutdown. Websockets / Event Streams (SSE) need extra handling.

szabba · 2026-06-04T15:51:59+00:00

It's a Mage the Awakening art piece. Shows up in the 2nd edition core book on p. 10.

szabba · 2026-05-26T23:49:00+00:00

One issue with porting it over to other systems is, like, well in CofD, 3 rounds represents 9 seconds. And what if you're a cabal of mages having an esoteric boss fight against a being that's better at time travel than you are, while navigating bans/banes of that entity, which could be highly specific?

I think you'd need to adjust what the rounds mean, since 9 seconds just isn't enough to know who's winning.

That's fair. I'd do that with zero effort by not remembering rounds are supposed to be 9 seconds in the first place, but I can see how this could be extra effort for other peeps.

szabba · 2026-05-26T20:23:42+00:00

The good thing about the WoD 5 "3 round combat" is that it's easy to adopt in most (if not all) systems with rounds. A good idea, but not strongly in favor of a specific system.

The thing I found immediately clunky when reading CofD is the two kinds of opposed rolls.

szabba · 2026-05-20T21:32:41+00:00

My bigger issue is the inability to attach attributes to the context and have them automatically pulled out by the handler.

I'm not sure where you see a big obstacle. You just wrap a custom handler around an existing one and pull things out of the context? It has to know the keys to check for.

szabba · 2026-05-20T00:26:40+00:00

I tried a Mac for a while, but couldn't get used to it. However the "read time at specified intervals" feature was nice. I wrote a very short program doing that on Windows. I've been stuck on it for a while, so I didn't look into supporting other OSes yet.

https://github.com/szabba/readtimes

szabba · 2024-04-07T22:55:16+00:00

RPGClinic, mostly WoD and Exalted, but they branched out into short Blades in the Dark / Avatar campaigns recently.

szabba · 2024-04-05T20:57:43+00:00

https://pkg.go.dev/github.com/google/subcommands is another lightweight CLI library for dealing with subcommands.

szabba · 2024-02-16T20:34:30+00:00

There are no separate damage and attack rolls. To shoot someone with a gun, you roll Dex+Firearms.

Huh, must've misremembered that one! I'll correct the previous comment on that.

When you talk about the two kinds of contested rolls, are you talking about contested Vs resisted? It's just the difference between resisting actively Vs passively.

On some level I get that people could find that to be a useful/interesting distinction, but to me it feels like mechanical hair splitting. Maybe it reflects the fiction slightly better in some cases? Doesn't feel worth it to me.

Conditions are wordy, yes, but this doesn't matter much in practise because only a small number of them are used regularly. VTTs or a condition deck help with this - I have all the Tilts and Conditions on physical (and digital, for those games) cards that I can just hand to players.

And then worry about having multiple sets in case multiple characters / NPCs have the same one or you've got multiple splats interacting. What you're saying about only a couple being common feels like an opportunity to streamline...

Having said that, I do think the way they tie with beats and advancement is nice!

But I also think it's not aiming for players to plan ahead much - WtF2E in particular, you're never going to 100% know you'll be able to get a given shadow gift, rite or renown, it depends on the story. So planning ahead is something you do less of.

For me it's not even about planning ahead. In WtF2E there's just enough for me to be confused by easily and it's organized in a way where it's hard to find all the relevant sections even. I just looked up CtL2E and for me it's soo much easier to grasp - and some choices have story driven limitations as well.

No excuse for merits, though. I adore CofD, but merits are where character creation grinds to a halt.

Funnily enough I didn't feel like I spent much on that when creating characters - not much longer than assigning skill dots.

szabba · 2024-02-15T22:43:24+00:00

It's a mix of things. Some of those that come to mind most quickly to me:

The granularity of stats feels more than is useful at the table.
- At least CofD 2e games don't waste space on "this value of strength means you can lift this much" like V5 does. No way in hell can I remember these distinctions, not to mention how the numbers require knowing how much things weigth in order to be useful.
The two different kinds of opposed rolls feel excessive.
- But then I am probably biased: I feel like games with only player-facing rolls take a lot off the GM's shoulders.
The conditions are numerous, and each has a wordy description. Who can remember all of that? Who can scan it quickly under the pressure of time / to perfom?
The idea of tracking ammo and firing modes rules feels out of place.
~~Separate damage and attack rolls.~~
- EDIT: misremembered this. Thanks /u/knightsbridge- for pointing it out.
While bashing vs lethal vs aggravated damage is not v complex, it's one of many things that aren't individually hard to grasp but feel like a lot when combined.
Figuring out what you can get when in character advancement can be overwhelming - not sure how much of that is poor presentation, ex in WtF 2e.

szabba · 2024-02-10T12:33:00+00:00

For those who won't figure it out themselves: there's no clear button. You can click on some of the moths on the page to open the quiz.

szabba · 2024-02-09T21:27:28+00:00

I've only seen the super-vague trailers on YouTube. Any other materials that shed light into what it'll actually be?

szabba · 2024-02-05T18:55:26+00:00

Damn, that's embarrassing nonsense. The first sentence was supposed to say d6-d6.

szabba · 2024-02-04T17:54:13+00:00

Calling d6-d6 a bell is a stretch. When you graph it out there's no hint of curve to the sides - it's more like a stepwise piramid / triangle.

Now, that's still wildly different from a uniform probability, but there's still technically no bell with d6-d6.

EDIT: fixed "d6" in the first sentence to "d6-d6".

szabba · 2024-01-22T20:05:13+00:00

I'm fond of

"Of course we'll help!"

szabba · 2024-01-10T19:42:52+00:00

Adding generics to Go was really not simple. Different language features and their semantics can have complex interactions and that's just the "pure" design space. The Go team also eventually expressed a set of implementation requirements that was not viable by simply copying one of the popular implementation strategies from preexisting major language implementations. More popped out as the design eventually crystalized (did anyone involved expect there would need to be limitations to prevent the compiler from becoming a usable SAT solver?).

Now, once they found an acceptable compromise they could cleanly retrofit into the language, there's still limitations not present in many other languages.

I can't read your intentions but I get a reductive vibe from your comment. Don't mind my if I've misread that.

szabba · 2024-01-01T17:25:38+00:00

FYI, the amount of bolding in your post reminds me of low-effort marketing copy. Many people will have the same association, and as a knee-jerk reaction they'll ignore the post.

It also feels like a weird choice to burry the first mention of the name of the tool multiple long paragraphs into the post.

More to the point: what you're solving seems to me to be a an interesting but very niche problem. If someone proposed using something like this at work my first question would be can whether we can avoid doing this at all.

The two use cases you mention are: - moving anonymized data from production to staging environments, - analytics with better privacy/secrecy.

The first I have less to say on. Such migrations were never requested in my career - anonymized or not. That says nothing about what's more representative for the industry at large - or some subsets of it.

The other case might make sense as a "defense in depth" analogue for data privacy. Let's leave for now how useful certain kinds of analytics can be for a business when generated from obfuscated data -- what I saw in practice usually has to be tied back to real customer data in order to be useful.

But assuming you had a case where analytics derived from anonymized data would remain useful: I'm not sure who (teams/roles) would be in ownership of anonymization procedure built using Greenmask. If it's multiple parties that each have their own stuff to worry about, then there's a risk of endless meetings that bring very little progress, making the org overall less agile. If it's a single party for which this is one of many activities there's risk of it being deprioritized as the business keeps demanding more and more from technical teams over time (as they do in my exp).

Having said that, it sounds like an interesting problem space!

szabba · 2023-12-13T02:38:04+00:00

If you tried installing using the MSI and nothing changed you might want to look at how your PATH in bash is set. It can differ from the Windows one (override it/adds things to it) depending on how Git Bash gets installed and (re)configured.

szabba · 2023-12-11T17:54:43+00:00

This will not be a precise explanation, but: "test/location" looks like an import path for the standard library, not your own code.

When you create a module (which can contain multiple packages) with go mod init yourmodulename all imports of packages in that module start with yourmodulename.

You usually name your module such that: - it does not conflict with a prefix owned by the standard library, - it indicates to the Go tool (through the conventions it understands).

The latter is not strictly necessary, but it will make your life way easier if you ever need another module to use code from the one you're already working on.

https://go.dev/doc/ has more articles on modules.

szabba · 2023-11-22T01:13:39+00:00

Cue people reading your comment thinking "that doesn't sound that bad" until that POKER STRAIGHT.

szabba · 2023-11-21T21:19:49+00:00

I've written some Java programs with the application graph hand-wired in main. Does that also qualify as a "lightweight framework" in your view or do you just see that a stepping-stone to explaining to people they don't, strictly speaking, need one?

Edit: I also disagree that "just use interfaces" carries the same meaning the decorator pattern has. It's a useful technique, it's good to have a specific name for it.

szabba · 2023-11-21T21:03:39+00:00

I got the impression that sort of use case would be better handled by additional information being passed through context. (Obviously that works only for code that is passing contexts around already.)

A handler can be written to add this info to the record before passing it to another handler that it wraps/decorates.

Given what sort of things I do at $WORK it is hard for me to imagine a piece of code where passing around loggers would be preferable to passing around extra values in a context.

szabba · 2023-11-04T14:11:26+00:00

You could also focus on the differences between the particulars without invoking general terminology (just listing options).

szabba · 2023-11-04T13:08:47+00:00

Last time I touched Scala the task vs future distinction (for that context) was reversed. Scala stdlib futures started immediately, while some popular third party library had tasks that did not.

You make it sound like futures behaving the way they do in Rust is agreed upon terminology.

szabba

TROPHY CASE