aes

Yesss… You’re not wrong, but I really do believe the solution we want is to be found somewhere in that direction. Considering the Google graveyard, the faang crowd isn’t all that reliable either.

This is a somewhat surprising position to see in the fediverse…

(I mean, I get what you’re saying, and I guess someone should bring that to the party, but there is s different way)

Sounds reasonable, but a lot of recent advances come from being able to let the machine train against itself, or a twin / opponent without human involvement.

As an example of just running the thing itself, consider a neural network given the objective of re-creating its input with a narrow layer in the middle. This forces a narrower description (eg age/sex/race/facing left or right/whatever) of the feature space.

Another is GAN, where you run fake vs spot-the-fake until it gets good.

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…”)

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.

Turn the mouse upside down.

Also, check your BIOS settings. Turning it on from completely off also sounds sus, surely it’s ‘hibernating’ or something, right?

A terminal is the thing that looks like it might be a computer, but nobody is home, it’s just connected to a modem. Or, maybe, if you’re lucky, The Computer of your university.

A terminal emulator is, well, an emulator, so you can use a 1970’s shell, right there on your computer, just like you can emulate and play Pong or Space Invaders…

Hope that helps

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

Well, I guess I have two thoughts on that. For one, what you’re probably thinking of is seen as basically qanon freaks. The other is that of course there’s a political right, and of course there is a social conservative current.

The right has traditionally been a coalition of liberals and conservatives, but the Christian conservatives are actually Christian. (They command a certain degree of respect, even though I don’t agree)

As for the social conservatives, they’re to a large degree absorbed by either the traditional social democrats (or “total autocrats” as I like to call them) or the nazis.

The WHAT?

Yes. The left was so busy suppressing racism (real) that they made it basically impossible to have adult conversation about the problems inherent in eliminating low-education jobs and, at the same time, accepting a lot of illiterate refugees. And as the reality of taking from the middle class boomers (who strongly identify as working class) to fund the result, the nazis were there, and they’re scary huge now.

Idk, there’s a lot to unpack and explain here, and I’m sure others have other angles, so I’ll leave it at that.

Oh, you mean a mass movement of anarcho-communist activism would slash the tires of private cars?

No.

It’s even wilder. This is just normal people having a union.

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

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.