16,934 karma · joined September 12, 2011
I am interested in programming languages, functional programming (especially Haskell), domain-specific languages, static analysis and program synthesis.
I am working on apply programming language ideas to supply chain planning.
I worked on supply chain optimization at Target for several years, and co-authored a textbook on reinforcement learning based on that experience.
contact: http://jelv.is, tikhon@jelv.is
The bad posters are absolute disasters in this regard. (And completely irredeemable in general! They are not "OK" in any way.)
But the better-stylized examples in the article aren't much better! Most of them have the same tendency. Only the minimalist Japanese and 40s Cubist styles do much better, and even those aren't structured amazingly. If you tried to add more information, I bet even the minimalist styles would become a flat and confusing.
This is the same problem I have with stock Claude prose and code. It's verbose, sure, but worse is that there's no quick way to tell what is and isn't important. In good code, you can understand the shape of the code at a glance; AI code is pretty much the opposite of that. And so are AI posters.
Like, if I had an AI detector that actually worked—and all the other ones didn't, which they don't—I'd put it exactly the same way.
I'm also a fan of effect systems, although I haven't used them as much. Having an IO type in Haskell is great, but the ergonomics aren't (among other things, you get async-like function coloring). Effects seem like a much nicer, more composible way to get the same benefits.
Getting rid of almost 10 different proprietary charging cables for pre-smart phones and some old laptops felt great though :P
And, of course, to support the policy choices that reduce how much we subsidize driving and improve infrastructure for those alternatives.
The point of Prop 13 is to let people have their cake and eat it too: you get to keep the equity you gain from increased housing prices, but not pay the property tax that comes with them.
It's pretty clear that this kind of tax policy is going to totally mess up the housing market. It's not the only factor, but it's a big one.
And reading some lack of empathy into a comment about the banking system is wholly unwrannted.
Which really just goes to show that the "legible" aspects matter far less than the illegible aspects. It's easy to say "hey, this startup is using boring technology and deploying a monolith, great!" or "Kubernetes and a bunch of services, over-complicated!". It's hard to say "hey, this startup's codebase is awful and it's an unforced error slowing them down" vs "hey, these guys are taking some shortcuts but it makes sense in context".
But a mess built on "boring", simple tech is going to derail you far more than a needlessly complex but well-executed setup.
Ideally, the code can actually help you structure that information. I've written a bunch of Haskell and OCaml like this, where the types in each module let me structure my documentation in a way that is actually easier for people—and maybe also LLMs—to track. As a bonus, it makes it more natural to keep the two in sync.
(And sometimes just leaving really is the best step!)
This seems like a pretty big problem. A lot of tasks should be put down. And, on the flip side, you absolutely need room for people to do things without needing to publicly justify themselves ahead of time.
I've been in places that try to approximate this sort of tracking, and I never felt like they were free of blame, I felt like blame was the default. There's no need to play the "blame game" if the whole system makes people feel blamed automatically!
That said, I've found a variant of this works: give people ownership of general areas, with well-defined but permeable boundaries. You only need to track the details at the interaction points, and only a subset of the work has to happen at those points. This also gives you a lot more room for overlap between people and teams; an interaction point naturally has at least two "owners" and, in a pinch, either side can come up with a (possibly sub-optimal) solution on their own. Or people can shuffle interaction points around—stop depending on one thing, move to some alternative—to work around problems.
It's amazing how much easier gamification can make it for me to stick with something.
(This is something I've repeatedly noticed in discussions about getting people in-office, and about open office plans vs individual offices: the same managers who push these changes through in the name of "collaboration" create a bunch of other management processes that strongly disincentivize collaborative work.)
But in environments where I've been able to do this effectively, it's always been great, far better than going of totally on my own!
(Not to mention that, in both contexts, it's very hard to pull apart being remote vs in-office from other aspects of the work and culture.)