The common threads were:
- incredible ICs
- founders who spiked in the most important areas for that market
- a mission that everyone truly believed in
- a culture of people who deeply cared about one another but were comfortable pushing back (as you said!)
It's incredibly rare to find all of these together. I agree that management is responsible for helping others thrive, but not necessarily that they should shape the environment to fit any engineer. Some people want things (projects, challenges, roles) that don't make sense in that company's context. It's okay, especially when it's hard, to agree that this isn't the place for someone.
All your competitors are in the same boat, so consumers won’t have options. It’s much better to minimize the risk of blowing up by sticking as closely to spot at possible. That’s the whole idea of lean. Consumers and governments were mad about supply chains during the pandemic, but companies survived because they were lean.
In a sense this is the opposite risk profile of futures contracts in trading/portfolio management, even though they share some superficial similarities. Manufacturing businesses are fundamentally different from trading.
They certainly have contracts in place that cover goods already sold. They do a ton of preorders which is great since they get paid before they have to pay their suppliers. Just like airlines trade energy futures because they’ve sold the tickets long before they have to buy the jet fuel.
But I'm hoping to have it out by the first week of December.
The compound predicate in my example above coupled with the fact that the compiler doesn’t reason about the precondition in the prior assert (y is non-negative) means this specific example wouldn’t be optimized away, but bluGill does have a point.
An example of an assert that might be optimized away:
int addFive(int x) {
int y = x + 5;
assert(y >= x);
return y;
} Add(x,y):
Assert( x >= 0 && y>= 0 )
z = x + y
Assert( z >= x && z >= y )
return z
There’s definitely smarter ways to do this, but in practice there is always some way to encode the properties you care about in ways that your assertions will be violated. If you can’t observe a violation, it’s not a violation https://en.wikipedia.org/wiki/Identity_of_indiscerniblesSome languages (java) really need the extra horizontal space if you can afford it and aren’t too hard to read when softwrapped.
I've frequently argued to my organization's leadership that the product could be open source on GitHub with a flashing neon sign above it and it wouldn't change anything about the business. A competitor stealing our codebase would probably be worse off than if they had done anything else. Conway's law and all that.