riwsky

HLA

A much better test, which dynamically adjusts difficulty level: https://www.myvocab.info/en

git let me make changes to local files without fear, since version control let me undo those changes easily.

jj let me make changes to my git commits without fear, since version control of the git state itself let me undo those changes easily, too.

That’s, uh, exactly how jj works!

I’ll just leave this here: https://www.businessinsider.com/grok-ai-elon-musk-is-more-fi...

With jj worktrees, you can even have agents working on each of those sub-megamerge branches in parallel.

My gRPC point is that it already gives you a language for describing interfaces and support for generating client types from it, and already abstracts the connection management[1]. If OBI just generated a gRPC ClientConn implementation to map the Invoke calls to eg REST paths, it’d inherit the large existing gRPC client ecosystem. That ClientConn interface can already technically capture what OBI calls binding executors. People don’t do this though because it’s not worth it.

[1] https://github.com/grpc/grpc-go/blob/06fc26a196350499dd0cf2d...

You’re still not getting it. Duck typing comes from the phrase “if it looks like a duck, and quacks like a duck, then it must be a duck”. The Wikipedia page contrasts it with nominative typing that requires a declaration, and calls out that duck typing does not need the adapter pattern. What you are calling duck typing is just “interfaces”.

Also “tasks.create” is morally a route. Eg grpc has web transports and autogenerated CLIs too; even without those, there’s no particular reason why the OBI “client layer” couldn’t just be, say, gRPC under the hood, with the OBI specs just being used to codegen adapters from the source protocol to gRPC. It would then immediately have a much more widely understood and supported client layer, with better performance, while remaining as simple to implement as the adapters to this new custom OBI runtime protocol.

Artificial intelligence predates computers.

Ad-hoc duck typing—“if it looks like a duck[…]”—is the only kind that exists! The point of the term “duck typing” is that it doesn’t require explicit declaration of the contract by implementers, it’s not synonymous with polymorphism or with interfaces in general. Haskell type classes are not duck typed, nor are Swift protocols; Go interfaces are.

OBI is a boilerplate generator for the adapter pattern for service communication; its contracts are just another set of their own paths, payload shapes, and protocols. The distinction between “protocol” and “contract” in this context is nonsense.

The web IS the duck typing equivalent at the network boundary! That’s why plenty of alternative service providers can and do implement eg object storage APIs that work with aws s3 client libraries, or LLM APIs that work with Claude Code. The reasons these use cases are standardized (while others remain fragmented) are economic, not technical (lock-in isn’t as profitable for these alt services as raw adoption)—and so a purely technical solution like this is unlikely to address the crux of the problem.

Even purely on the technical level, this seemingly hasn't internalized the lessons of https://xkcd.com/927/

Might makes right; brains hold reigns.

Sure—but that’s a property of the inferred types moreso than the mere application syntax. It can be hard to revisit or understand the type of JS or unannotated Python expressions, too—but unlike those cases, the unknown-to-the-reader type of the Haskell code will always be known on the compiler/LSP side.

The functional programming take is that “the result of foobinade-ing an and b” IS “foobinade applied to two of its arguments”. The application is not some syntactic pun or homonym that can refer to two different meanings—those are the same meaning.

cries in google wave

In fairness to the skill author, this is indeed what Elon did to the US government with DOGE

Am I the only one who finds this material rather dense?

1. The collaboration and notation app for rock bands that I’d wished existed already: https://bandwith.rocks/about

2. A “runtime scheduler for humans” that I wished existed, too (think morning routines, travel checklists, and pomodoros in the same abstraction—but also a lot of support for ad-hoc rearrangement and addition of the task queue).

I agree that the font and emoji hops aren’t great for complexity or performance, but the problem in the post was in the rendering of a tiny SVG; serving it directly would not have avoided the problem.

Damn, wait: you mean the random HN commenter didn’t magically solve a difficult problem that has long-confounded experts, simply by bringing their unique insights and thirty seconds to bear?

What's missing is a widespread replacement for XSLT

jq says hello!

"I give it a hot minute before this type of task tracking lands in Claude Code."

aaaaand right on cue: https://github.com/anthropics/claude-code/commit/e431f5b4964... https://www.threads.com/@boris_cherny/post/DT15_k2juQH/at-th...

“I’m going to go lay down and, uh, think about the problem with my eyes closed”

Oh good, mainstream coders finally catching up with the productivity of 2010s Clojurists and their “Hammock Driven Development”! (https://m.youtube.com/watch?v=f84n5oFoZBc)

The underlying guiding philosophy isn’t relativistic, though! It clearly considers some behaviors better than others. What the quoted passage rejects is not “the existence of objectively correct ethics”, but instead “the possibility of unambiguous, comprehensive specification of such an ethics”—or at least, the specification of such within the constraints of such a document.

You’re getting pissed at a product requirements doc for not being enforced by the type system.

This is an extremely uncharitable interpretation of the text. Objective anchors and examples are provided throughout, and the passage you excerpt is obviously and explicitly meant to reflect that any such list of them will incidentally and essentially be incomplete.

Simon Willison: How this Devastating Perfect Reply Changed my Publishing Workflow, featuring Claude Code

Dude, what? The fuckers set up an automated system that found people’s private email addresses and blasted them with unwanted emails. The outrage is exactly that they built a line-crossing machine. Your moralizing is incoherent.

part of the problem was caused by bad design

The entirety of the problem was that the design was bad! Adding a layer of abstraction is a design choice.

I heard that Google and OpenAI also make coding models, but I’ve never bothered to confirm.

Would be more maintainable if they injected the loading strategy to be used as a dependency from config instead of hardcoding it :/