achou

Y'all are sleeping on custom lint rules.

Every time you find a runtime bug, ask the LLM if a static lint rule could be turned on to prevent it, or have it write a custom rule for you. Very few of us have time to deep dive into esoteric custom rule configuration, but now it's easy. Bonus: the error message for the custom rule can be very specific about how to fix the error. Including pointing to documentation that explains entire architectural principles, concurrency rules, etc. Stuff that is very tailored to your codebase and are far more precise than a generic compiler/lint error.

One thing to watch out for when using debounce/throttle is the poor interaction with async functions. Debounced/throttled async functions can easily lead to unexpected behavior because they typically return the last result they have when the function is called, which would be a previous Promise for an async function. You can get a result that appears to violate causality, because the result of the promise returned by the debounce/throttle will (in a typical implementation) be from a prior invocation that happened before your debounce/throttle call.

There are async-safe variants but the typical lodash-style implementations are not. If you want the semantics of "return a promise when the function is actually invoked and resolve it when the underlying async function resolves", you'll have to carefully vet if the implementation actually does that.

Sure, I think what I noticed was that even idiomatic OCaml code was relatively fast, maybe 2-3x slower than C, but plenty fast enough. Whereas I was under the impression that idiomatic Haskell was far more likely to have unexpected and harder to fix performance issues (e.g. requiring more of an architectural rewrite) because of its lazy evaluation model.

What about performance? I wrote my thesis in OCaml and my recollection was that it had an amazing native code generating compiler that not infrequently output code that was almost as fast as C if you wrote it the right way. The story I heard about Haskell was far different at the time (admittedly decades ago).

Keep in mind that "avoidance" in this context refers to not confronting one's own feelings and intuition. After grappling with that feeling explicitly, avoiding overt conflict can certainly be an adult decision to make.

This is a useful analysis of what "being an adult" means. I've noticed that the moment when I feel like avoiding social discomfort or potential conflict as the precise moment when I have a choice: either be an adult and understand what I want and communicate it, or avoid it and dislike myself and project those feelings onto others.

Invariably when I choose to behave like an adult I feel empowered and ultimately at peace with myself and others in the end. If I choose avoidance, resentment builds, and further avoidance follows.

The idea that avoidance behaviors can be selfish or agreeable cuts through much self-deception. This can be helpful when I tell myself "I'm just being nice" because it adds the proviso: "yeah, but I'm not being an adult." Which I could see being a really helpful inner monologue in those situations.

This is also intimately connected to the concept of "taking responsibility", which begins with not avoiding something which "someone else" might deal with so you don't have to.

How does this culture work at the boundary? How does it work when meeting with people outside Amazon? I'm all for this idea but I can see it quickly breaking down for certain key roles, like product managers, who often interface with customers.

How do CodeTours handle drift as the code base changes?

In the last 18 months I've lived with 2 kids in a condo in SF with a car, a downtown condo in an Asian megacity without a car, and in suburban silicon valley with a car and large yard. For us, by FAR the best quality of life has been in the suburbs.

Having a yard is exceptionally valuable with kids. They can be free to run around, play yard games, explore - all without draining the emotional reserves of parents. You can do this while you make dinner, work, or do other things that are unrealistic at an urban park. And you can play with them too. It is not that expensive to get someone to care for your yard if you have some financial flexibility.

In a family there are many kind of resources - time, money, energy, emotional reserves. Scarcity in the first two are easy to focus on because they're quantitative. But scarcity in the latter two - especially emotional reserves - is actually the limited resource in many families. Having to deal with the stresses of children (even if they are mostly well behaved!) puts a real strain on relationships. And the friction from an urban environment, especially one like SF which is not child-friendly, or a giant megacity that has very high density, just drains away the scarcest resources that a family like mine actually has.

If you have some financial flexibility and need serenity and quiet to be your best, combining kids with an urban environment in exchange for spending less is a very poor allocation of resources. It's an example of optimizing for the thing you can easily measure, instead of what's truly important.

Linux isn’t all of open source, nor likely to be the most attractive vector of infiltration for any given target, and not all of even Linux is examined with the same level of scrutiny.