narnarpapadaddy

This is about guiding principles, about personal liberty, and about freedom from tyranny.

The point he’s trying to make, as I understand it, is that states adapt. They don’t just throw up their hands and say “guess we can’t do anything about that encrypted traffic.”

The response to distributed kinetic kill capability in the US, for example, is for police to become more militarized and treat every encounter as a potentially lethal one.

There's private, and there's not private. There is nothing in between

It’s not an argument about privacy per se, it’s highlighting that the stronger the protections against state surveillance and intervention, the stronger the state becomes. By taking an absolutionist stance, we push our institutions to towards the same in response.

I’m not making an argument or against encryption or privacy, just pointing out the systemic effects.

No disagreement in principle; in practice taking that approach in Zig is safer than in Rust, because in Rust it’s “all or nothing.”

I agree that it’s not inherent to emitting machine code but I do think it reflects a different set of priorities.

In extremely high performance code you use different data structures and algorithms and change your approach to memory allocation. TigerBeetle famously does all memory allocation once on startup.

Roc is attempting to make a similar set of trade-offs in their compiler as Zig, so it makes sense that the author finds many shared patterns.

It’s probably too little too late in the age of Claude…

C# grew all those features over time. It had to leave syntax to support old patterns to preserve backwards compatibility. Thus, the syntax has grown a bit noisy over time to support all those features. This is reboot keeping the newer ergonomics and streamlining the syntax.

I probably wouldn’t adopt it for existing projects or use .Net for any future project, but it looks really nice for what it is.

No, I’m not. I’m explicitly differentiating between those two perspectives and which corporations care about. “Blame” doesn’t exist in most corporate vocabularies.

It’s possible.

Effects allow more aspects of computation to be represented/generalized, but as the author has noted concrete implementations have already been tried in some cases. Rust’s ownership, Java’s exceptions, Typescript’s async are all instances where the language made a choice about and provided syntax for some effect.

Generalized effects are not yet proven (IMO) to improve developer ergonomics for rank-and-file devs. It may be the case that most devs need most decisions to be made for them, and the power of effects is just lost to them. That may also apply to agents. They don’t _need_ to encode the constraint. The constraint was decided when the language was picked.

Because it’s their job to fix it. If they don’t, the axe falls again.

Humans often think in terms of deontological ethics. Corporations operate in terms of consequentialist ethics, and the only consequence that matters is that the numbers go up.

I feel the author’s pain. LLMs take over right as we’re finally figuring out the unifying models and algorithms for programming languages.

Some time back I went on a tour of the fort at Dry Tortugas. Largest brick masonry fort in the world. Many innovations of the form. It was abandoned right as it was completed because barrel rifling had just been invented, dramatically increasing the penetrating power of artillery, rendering brick masonry forts obsolete virtually overnight.

This project evokes a similar feeling.

I buy that markets are like a traveling salesman problem. “Impossible” in the general case, but good enough could algorithms exist. Where’s the economist formulation of that algorithm? What are the policy implications that fall out of that?

I admit I’m not particularly well versed in this space, but I’ve never come across that formulation, only the “pure” one the original researcher says is internally inconsistent. I don’t necessarily buy “it’s close enough it doesn’t matter” given what I perceive as many notable exceptions.

Rules are only “good” or “bad” in the context of the alternatives. What’s the alternative?

Way above my pay grade. I’m not an expert in game theory, economics, warfare, or nuclear proliferation. :)

Game theory here is applied to two fundamental market theorems. It’s a way to analyze the validity of those assumptions, rather than to build a new model. Empirical evidence to the contrary is expected given mutually inconsistent premises, which is what the author’s results predict. The author has simply used game theory math to disprove economist math.

Are securities regulations so lax that pump ‘n dump schemes on a global scale get IPO’d? Are conmen so sophisticated that their plans take decades to mature and require sending rockets to space?

Either or both of those being true is almost as mind-boggling to me. How is one supposed to navigate that world?

Mass delusion seems like the most likely answer to me. I can point to instances of that at similar scales outside of tech/investing.

If this happened it would make Elon emperor of the known universe. Can’t imagine the level of influence this would buy.

It also seems impossible. What are people seeing that I don’t?

Same, I care little about NSFW. We used to all live in caves together where kids saw adults having sex, in conflict, and cleaning game.

But I also grew with a different internet than we have now. There’s a level of targeted manipulation that’s novel. I’m not sure the cat goes back in the bag no matter what we do.

Not to mention if “borders” is part of the continuity definition the US is younger than my parents.

That’s not the premise people are building on though.

Any particular model almost doesn’t matter at this point. Harnesses are built around them. OpenAI and Anthropic are basically interchangeable in an open-source harness like OpenCode; the switching cost is virtually zero. Local models are improving rapidly and are already “good enough” for many use cases already. The bet that LLMs will continue to exist as an algorithm is pretty solid.

My version of this is the “N+1” principle. Build for one more foreseeable use case than you currently have. The domain model will click in when you need to generalize a solution, and you’ll gain the ability to see your particular solution as one of several to the problem, and thus evaluate fit and tradeoffs more clearly.

Don’t do N+2. The goal isn’t to predict the future, nobody can do that. The goal is a durable understanding of the domain and the best fit implementation you can get with that current understanding and resources.

That said, SQLite passes that bar for me in most use cases.

In the case of concrete there’s also a time component. Once you mix the cement and aggregate you have a few hours before it begins to set. The cement itself is already typically trucked in (a relatively small amount of dry, easily transportable powder).

Anecdotally, my take on this is that biggest value lever is strategy and alignment, not implementation. The typical company is dozens of little vectors pointed in different directions, and they cancel each other out. Scaling up the magnitude of each is still net zero.

I was recently consulting at org where two separate engineering teams were all in on two different, incompatible deployment platforms and using AI to accelerate adoption of each.

Management was mystified why their engineering leads kept telling them they couldn’t deploy a complete implementation of their solution.

Imagine you initialized 10,000 NPM repos identically simultaneously. Then had 100 different teams each take of 100 those repos for 10 different projects, and let each repo run for 1,000 commits. How distinct would each of those repos be? How might have they evolved independently? What types of interesting patterns might be adopted to improve development experience, or detect bugs by each team? What packages at what version might be most popular?

Now imagine you had the tools to do a diff across all those repos simultaneously, and classify, group, and review those patterns. What could you learn NPM teams and practices?

Now imagine you could pick best of breed, and propagate those back to all the other projects automatically to improve their productivity, security, etc. How fast would your productivity improve and your engineering culture change if everyone could automatically learn the best of what everyone else had to offer?

Companies like Spotify have sophisticated tooling for detecting repo changes and enforcing policy like that, and they run that experiment 1,000 times a day. Small evolutions in what was an identical build script, like a version bump, are detected, and if it passes a threshold it can be rolled out everywhere else immediately.

Having all the copies that you can sync up centrally periodically puts natural selection to work on internal best practices.

Basically, things work differently at scale. When the number developers you employ approaches a meaningful percentage of the total number of developers globally, your internal diversity starts to mirror the global diversity. So you have to manage that diversity. If you freeze policy entirely, you fall behind the global average. If you let things run wild, your company fractures technologically.

So, make a 1,000 copies, see what pops up, adopt and enforce things that look good, then do it again. Evolve to the next best place you can be from where you are.

So, depending on someone else’s shared library, rather than my own shared library, is the difference between a microservice and not a microservice?

FWIW, (I have one Clojure project I inherited at work that my team maintains) I love this direction.

One addendum / clarification:

It may also be that "space" and "time" are emergent properties, much like an "apple" is "just" a description of a particular conglomeration of molecules. If we get past Planck scales it may turn that out that there are no such things as "space" and "time" and the Planck constants are irrelevant. We currently don't know but there _are_ a few theoretical frameworks that have yet to be empirically verified, like string theory.

Any given model has less fidelity than reality. An atlas map of the US has less detail than the actual terrain. The Planck constants represent the maximal fidelity possible with the standard model of physics. We can’t model shorter timeframes or smaller sizes, so we can’t predict what happens at scales that small. Building equipment the can measure something so small is difficult too… how do you measure something when you don’t know what to look for?

It may be that one day we come up with a more refined model. But as of today, it’s not clear how that would happen or if it’s even possible.

Imagine going from 4K to 8k to 16k resolution and then beyond. At some point a “pixel” to represent part of an image doesn’t make sense anymore, but what do you use instead? Nobody currently knows.

The fact you can’t pretend _is the point_. A blanket policy of “no and never” that works well for other addictions or compulsions can’t be applied to food. :)

As a counter-factual, imagine if every time you wanted to smoke you had to decide if one particular type or brand of cigarette was good for you.

The point is that black and white, all or nothing is easier for many to stick to. It’s easier to not be tempted by a cigarette if you never see one or hang out with someone who smokes. With food, you can’t take approach.

Yes, but we had that problem before when somebody would farm out coding assignments to a friend. I couldn’t say yet how it’s impacted the coding assignment’s effectiveness as a filter yet. We still do get crap code just sometimes it’s obviously AI generated.

We still do a coding assignment, but a significant chunk of the technical interview is dedicated to a walkthrough of the code. Thus far, that’s been able to detect those who relied solely on AI.

…If you used AI and can still explain to me why code works and what it does, even better. You have learned how to use new tools.

(have not tried the randomized question approach to compare, but I’m curious to try it and see what happens)

Appreciate the charitable interpretation. Both “complexity“ and “abstraction” take many different forms in software, and exceptions to the rule-of-thumb abound so it’s easy to come up with counter examples. Regardless, thinking in terms of complexity ratios has been a useful perspective for me. :)

IMO, a function _can_ be an interface in the broadest sense of that term. You’re just giving a name to some set of code you’d like to reuse or hide.