By this reading if you can argue if you’re not a stupid person ripping it down actually is permitted.

I hyperfocused on “maximizing” and “safe”. The concept of “safe” in the context of electoral districts has a real definition in political science. Which is probably exactly why they put it in quotes.

It’s like calling a Chihuahua “big dog”.

OK yeah, it just really hits my eyes and ears strangely.

Like that spinning ballerina silhouette… I really gotta squint and fold my brain to make her spin the other way kinda thing.

you’re right though: those quotes do heavy lifing and in a specific direction.

They could, but they won’t.

The major way they broke capitalism was by not going public. Gabe has to answer to nobody, so the usual gang of corporate fucking idiots can’t force him to do short sighted shit to make a short term squeeze at the cost of long term viability.

This is the key. It’s the WHOLE thing. A runaway cap table destroys companies, always. Investors have different exit horizons and they are fundamentally incompatible with long term viability.

All you need to do to compete with a publicly owned company is capitalism is wait for their investors to get too greedy.

Exactly the opposite.

Instead of winning one district by a lot and losing 2, you redraw the map to win all three by a little.

The result isn’t more safe districts, it’s less.

I think he misunderstands the role of the secret service, especially for an ex president. Especially for a recent one.

That’s a lot, so I’ll be forthright that I’ll probably be giving a relatively terse and gappy response, but that’s more because of my own limitations as a mobile user.

Fundamentally every test unit, integration, ui, manual is still the same thing:

Given X do Y expect Z.

Mocks, fakes, whatever you want to call them, they’re fundamentally the same concept too: “given some idealized version of P”

All you’ve done is pushed where that line sits. If I update my company writer to prospend all my company names with “corp.”, and my company read API test seeds without it and something at your read service layer strips “.”, if I forget to update the “given” in my read test seed data, that bug stays invisible.

It’s the same class of issue. We just kicked the can down the road.

You could do writes and reads in the same test, but even then you’re still kicking the can down the road that your front end is calling the API correctly at all. Maybe that the buttons even render to an end user given their authority.

One might then conclude, then, that everything should be an automated UI test.

But would it catch a bug where the bottom collapsed to 1PX? Is that part of the test too? Maybe manual testing is the real way to go.

A further step back why do we even test anything at all? To provide some ultimate guarantee that everything works perfectly at all times? Is that the gate for a PR? A deployment to prod?

There are various gates, at different levels of certainty, and there is an economic scaling for the different levels of assurances. AND they scale with the overall complexity of the system.

And that isn’t a bug, that’s a feature.

It’s ALL behavioral contracts, up and down the pyramid.

There is a bang, there is a buck. Get the most bang for your buck. The distribution will vary by complexity and structure of your project.

That being said, I’ve said it before and I’ll say it again: int and UI tests make it very very easy to write fucking garbage code, the VALUABLE architectural pushbacks on poorly patterned code that unit tests avail is AT LEAST as much value to the overall tech debt accumulation of a project as the results themselves.

Please don’t read this as me shitting on int tests. It’s me trying to impress that unit tests are worth writing, and justifications for forgoing them usually are fundamentally driven by an underlying code smell. Sometimes the smell is “our architecture is already so fucked that writing a meaningful unit test would involve re architecting large swathes of our system”.

And in that case I’d say “it is what it is”, recalibrate the testing posture towards int tests, and accept that is the reality.

But I would NOT conclude on the blanket statement that unit tests SHOULDN’T be at the bottom of the testing period generally. Just that I’d inherited or failed to maintain a strong system design, and take the opportunity to reflect on how things came to that state for the purposes of becoming wiser.

Addendum:

Even int tests can reveal insane system architecture, just at a different layer and scale. I worked on a system at a fortune 500 company where the architecture was too far gone to even have meaningful integration tests. They were too far gone to even have automated front end tests. All material testing had to be done by hand. They had engineered their system with that staggering level of incompetetence. At the risk of making a slippery slope argument… It’s a slippery slope.

Alphabet shares record? That’s nice, I wonder if its 45 or 78RPM.

The degree to which share price discovery is fundamentally rooted in optimistic speculation, as opposed to any actual evidence… at some point talking about “value” becomes a little weird. “Overvalued by 15%” reads like a chemist doing a titration.

People were more interested in selling than buying yesterday.

There is a lot to unpack there, but it sheds a lot of light onto the popularity (and depending who you ask, the subversion) of the work.

I’ll start by saying that people joke about how school doesn’t prepare them for the real world, where was “doing my taxes” class, amirite?

Fundamentally I think that an even more critical and teachable skill missing is how to be empathetic. Not like “I have the capacity to feel bad for people”, but a more general form of “I can abandon my own preconceptions to allow myself to accurately view the world through their eyes”.

That relative illiteracy leads to exactly the longing you express: how to understand what are theople are going to do, and why.

This couples with another favorite observation: when the only tool you have is a hammer, every problem is going to look like a nail.

What you’ve described, roughly, is the concept of a breadth-first search. It’s a general workable algorithm to establish the type of thing you want to do.

It’s inefficient, and especially in the context of a human brain with finite working memory, still prone to suboptimal results. Still better than nothing, but suboptimal given the constraints.

So it’s a solution. And, if you didn’t have one before, the temptation is to treat that like the hammer.

Because it “works” without a moral evaluation, one might conclude that the moral evaluation isn’t important.

And then it’s a classic case of the inevitabilities of staring too long into the abyss

That’s a fascinating observation about the synopsis, seems to lend credence to my musing that Wikipedia editors may drop or include key points which betray their own reading. Probably not a malicious act, but evidence that varied weighting of events can result in divergent interpretations.

That being said, a framwork for evaluating actions in the absence of moral evaluation is, in my opinion, fundamentally flawed. The explicit absence speaks just as loudly as any prescription. And I do think Picard would have my back on that one.

Which, I stress isn’t a condemnation of the source itself: it’s a warning that such a source can be hijacked for nefarious purposes; intentionally or otherwise.

Just the Wikipedia one. I absolutely admit that not having read the source material (and that the synopsis is crowd sourced and easily could be written through the lens of someone seeing what they want to see) I can’t make a real assement.

But yes, death is the ultimate enemy… But, given the synopsis that appears to “rationally” entail that as such, any means justify the ends, and that if you accept the fantasy of a mechanic for resurrection then that gives broad latitude for moral justification for pretty much anything. Even one step further, a moral obligation to do pretty much anything.

I’d argue that Dr. Soran couldn’t delineate the fantasy afforded by the nexus from reality: whomever he killed could be conjured back by him in the nexus. The problematic actions could be “morally deferred”.

Regardless of any interpretation of the material, I (like Picard) reject the premise that death is the ultimate enemy. And, like Picard, I am very uneasy with any philosophy that claims to have simple derivable moral evaluations, especially if when you pull back the curtain the underlying mechanics boil down to “the ends justify the means”.

If these dont apply to the source, then it was a bad synopsis. Or It was a good synopsis and I’m bad at reading.

I gave my team the explicit instruction to call me out if I ever did anything that they’d estimate would make Picard disappointed in my leadership.

Someone brought up some harry Potter fanfic which apparently and bizarrely motivating the philosophy of peter thiel and his ilk.

I read the synopsis, and (regardless of your feeling on generations) is essentially extolling the philosophy of the bad guy in that movie.

Picard, reflecting: “Someone once told me that time was a predator that stalked us all our lives, but I’d rather believe that time is a companion who goes with us on the journey and reminds us to cherish every moment, because they’ll never come again. What we leave behind is not as important as how we’ve lived. After all Number One, we’re only mortal.”

Opposition is the easiest fucking job in the world

Awesome and well articulated response. Love it.

There are a few threads to pull here:

Is an integration test the best way to test the full e2e behavior of an api call? Yep.

Now, depending on the size (and architecture) of your system, the full test suite of into tests could take like, 10 hours.

And even then, you’re STILL probably mocking something (direct seeding bombs into the db). Full setup of all life cycles of all your entities using their associated entities (bombs, wires, wire clippers, bomb diffusers, their rank, their bosses, their diffusion history, etc…)

So they’re expensive, and if you really look you’re probably still cheating some steps anyways.

Another thread to pull on is what are you mocking in your tests to begin with, and if they’re not resulting in valuable test results then that goes back to one of my original points being that you might have suboptimal patterns in your production code.

Like, what logic governs bomb diffusion and where does it live? Are you mocking the right thing? If you have to mock the wrong thing… WHY? The ritual of writing those tests give you the first whiff of a potential smell.

I tell my guys not to test implementation: test behaviour. Test contract adherence. If that’s hard, no problem, message me let’s review it. Maybe a behavior they’re trying to test legitimately should be an int test. More often than not, their design is demanding to mock something that should be decomposed further, and then composed with dependency injections that are where the units that should ACTUALLY be mocked are the things that get mocked and injected, so the unit tests are actually testing the BEHAVIORS we want to pin rather than implementations. Composition and single responsibility principal are what enable unit tests to pull their weight.

Edit: I’m so passionate on the subject that if you scribbled up a scratch example and pinged me a github link I’d genuinely review it.

IMO C# properties are great for exactly this reason.

Curious how bad they’d have to be to land you at that position.

If they’re hard to write, it’s kinda a red flag about the overall code itself. Forcing people to write them tends to force people to use better patterns just so the associated tests aren’t a bitch.

And they pin behavior more than strict correctness, in my experience, but that’s a valuable signal. Canaries in the mine.

You can be much more bold when you’ve got strong coverage.

So I do admit some of the benefits might feel intangible… But boy howdy you’ll miss them if you move to a shop that never bothered. You’ll see the dumbest fucking patterns and be kinda handcuffed to do anything good.