“Thanks for sharing your story, which nobody knew to ask for”, perhaps?

https://open.spotify.com/episode/3umFrR0Bpu1fmXpO1PzDdh?si=NPMlzRCtTZGakiuikO8GEw

This. So much this.

I’m a member of Sveriges Ingenjörer. Fortunately, I’ve never needed serious union help, but it’s probably because the background threat is more than enough. And the salary statistics alone are worth the dues!

Well, Rust has a lot of string flavors, and I like utf-8 being the norm, but there are a bunch of cases where enforcing utf-8 is a nuisance, so getting string features without the aggro enforcement is nice.

There’s probably some fruity way to make this a security issue, but I care about ascii printables and not caring about anything else. This is a nice trade off: the technical parts are en-US utf-8, the rest is very liberal.

Protein / calories, and glycemic index, right. There are a few other considerations, but primarily these, for me

Rust implementation of the Meta-II meta compiler. I used bstr, which was interesting.

Backstage has become quite misaligned to what we were originally trying to do. Originally, we were trying to inventory and map the service eco-system, to deal with a few concrete problems. For example, when developing new things, you had to go through the village elders and the grape vine to find out what everyone else was doing. Another serious problem was not knowing / forgetting that we had some tool that would’ve been very useful when the on-call pager went off at fuck you dark thirty.

A reason we could build that map in System-Z (the predecessor of Backstage) is that our (sort of) HTTP/2 had a feature to tell us who had called methods on a service. (you could get the same from munging access logs, if you have them)

Anyway, the key features were that you could see what services your service was calling, who was calling you, and how those other systems were doing, and that you could see all the tools (e.g. build, logs, monitoring) your service was connected to. (for the ops / on-call use case)

A lot of those tool integrations were just links to “blahchat/#team”, “themonitoring/theservice?alerts=all” or whatever, to hotlink directly into the right place.

It was built on an opt-in philosophy, where “blahchat/#team” was the default, but if (you’re John-John and) you insist that the channel for ALF has to be #melmac, you can have that, but you have to add it yourself.

More recently, I’ve seen swagger/openapi used to great effect. I still want the map of who’s calling who and I strongly recommend mechanicanizing how that’s made. (extract it from logs or something, don’t rely on hand-drawn maps) I want to like C4, but I haven’t managed to get any use out of it. Just throw it in graphviz dot-file.

Oh, one trick that’s useful there: local maps. For each service S, get the list of everything that connects to it. Make a subset graph of those services, but make sure to include the other connections between those, the ones that don’t involve S. (“oh, so that’s why…”)

Could ‘push’, yes, as in, “we mentioned it in passing when rock and roll grandpa wasn’t paying attention, so he wouldn’t throw a hissy fit and withdraw from the service”. Oh, you meant to the labels? Ha ha ha, NO. The labels have basically nuclear option veto powers.

As for changes, well, updates get delivered all the time, for various reasons. (The scratched Turbonegro album being one frequent flyer.) I think a lot of those are bullshit SEO-like reasons, but it is what it is.

Which artist appears in most frequent releases? I forget, but I think it’s Elvis. Possibly Johnny Cash. Why? Because some material has gone out of copyright in some jurisdictions, and so people have the idea to upload them again in ‘new’ compilations. (The content team don’t even beat these down personally – that’s machine work)

I worked on exactly this for a while, a long, long time ago. It turns out to be an annoyingly difficult bag of problems. The record companies don’t really care, they sell (sold, I guess) pieces of plastic. (Idk if they fixed it yet, but the same Turbonegro album kept getting sent with the same scratches, kept getting taken down a while later, for years.) So, good luck trusting them to label anything.

Puritans are so much more aggressive than sane people that making mistakes one way is much more expensive than the other way.

Anyway, we ended up trying to work out which tracks are actually the same song, (Easy for you, harder for friend computer, yes?) and then if one of them is marked explicit, they all are, unless marked “radio edit” or “clean”, or whatever. If you think about this for a minute, if one track is labeled “radio edit”, maybe the other ones should be marked explicit…

It’s a deep rabbit hole, is what I’m saying.

And the people with the pitchforks are never happy.

Ok, so it’s to hear from people building stuff, but isn’t it maybe a little light on details? I feel the consultancy contact details to profound insights ratio is a bit underwhelming.

Ok, TIL there’s a thing called Required, but otherwise, one way to do this is to rename the other part/field/key(s), so that old code reveals itself in much the same way as using a deleted field (because it does, actually)

Another way is explicitly have a separate type for records with/without the feature. (if one is a strict subset, you can have a downgrade/slice method on the more capable class.

Lastly, I would say that you need static typing, testing, both. People from static-land get vertigo without types, and it does give good night sleep, but it’s no substitute for testing. Testing can be a substitute for static typing in combination with coverage requirements, but at that point you’re doing so much more work that the static typing straight jacket seems pretty chill.

Yes, typo

Yeah, that. Typo. It had grown by a factor of 7 or so. So, basically, that part of the pay was cut by 85%

Going all in on the stock option program, even if it was a little risky. I remember the argument: There’s no lottery or casino that’ll give me odds like these. I also left when we’d grown to the point where middle management didn’t want to understand that when the program ran out (4 years) and had to be restarted at the new validation, that was basically a static pay cut for me. I get paid a lot more now, but I still made more from stocks than work last year.

Second, our apartment. It’s a lot like a row house, except it’s in the city. The other part backs right up to the park.

Third, maxing out parental leave with both of our kids at a company that (as, more or less, a recruiting gimmick) topped up parental leave pay from the capped 80% to, iirc, 100% with no cap. They turned out be quite dumb about this and had shuffled me into a corner when I came back. I was ready to put my back into it, but well, I guess not then.

(The one without the parentheses is older Python 2, the example with is newer Python 3)

“Appendable” seems like a positive spin on the “truncated YAML-file is frighteningly often valid” problem…

Iirc, the company faltered and floundered very badly afterwards. The (now unionized) workers had to say, “it’s OK now, we got a contact!”, but that message was hard to get out, since it’s a lot less sexy than the strife.

They basically wrecked the company, trying to fight the union

Yep. I even got this back when cleaners moved my mouse from in front of key keyboard spacebar to the right of the keypad, until I noticed what had happened.

I put my mouse between my body and the keyboard and it goes away.

Good luck!

It was harder to explain why picking on Python for this is dumb, before gotofail… (Not saying that’s what you’re doing, but it feels close, so this is relevant.)

For whitespace, my rule is this: If any level of indentation depends on the length of any word or name, you’re doing it wrong. If using a more descriptive name causes indentation where previously there was none, that’s fine, but if moving the opening parens causes the interior to be indented more, less so. (Yes, Golang’s structs)

Well, with the newer optional typing, it became def foo(name: Optional[str]) -> Optional[str]: ... and now def foo(name: str | None) -> str | None: ... (No need to import Optional) It’s quite nice.

As for Rust, recall that Result is also a very similar union type. I think a lot of the aversions people have had to static typing have mostly just been about poor expressiveness in clunky type systems.