articulatepang

All your examples are private goods: excludable and rival. If one person uses a unit, that prevents others from using them.

Patches to open source software are public goods. Your using them doesn’t prevent others from using them. So if you spend resources creating a public good, it’s in everyone’s interest to share it.

“How it works” link is broken on Safari on iOS. I am quite curious how it works, exactly.

Yes, the type I wrote down is isomorphic to Option<int32>, so the compiler will ultimately generate the same machine code and do the same optimizations.

But defining a new type allows you to give the two cases more descriptive names. That saves you from having to remember and comment what the two cases represent. In a small but significant way, the code documents itself.

Also, doing it this way gives the Connection type its own name and identity separate from Option<int32>. So if you have a function that takes a Connection and some other Option<int32>, you can’t accidentally switch them: even though the two types are equivalent for optimizations and codegen, they’re NOT equivalent for the type checker.

It also makes function signatures more self-documenting: you can tell just from the type that the function takes or returns a Connection, and that helps in a small but real way to understand what it does.

I like programming like this a lot! So much so that the reason I personally like Rust a lot is simply that it’s a mainstream language with great tooling that has sum types and reasonable generics. It’s like if OCaml or Haskell had the community or tooling, or if Go or Python had the type features.

I prefer a slightly more general rule: Make Illegal States Unrepresentable. The "Parse, don't validate" rule is a special case of MISU.

What's the difference? MISU applies even when there's no parsing-like transformation happening. For example, if you have a variable that represents the current state of a network connection, and let's say it can be Disconnected, or Connected to some IP address (this is an oversimplification).

Then one way to do it would be

  struct {
    connected: bool,
    peer_ip: int32
  }

The trouble is that this allows us to represent an illegal/meaningless state: we're disconnected but there's still some junk old peer_ip hanging in there. Even worse, we might have written

  struct {
    connected: bool,
    peer_ip: Option<int32>
  }

Now we could have connected = true but peer_ip = None.

The solution is to use a sum type:

  type connection = 
     Disconnected
   | Connected of int32

(sorry for using made-up syntax; I hope it's clear to anyone familiar with Rust.)

"Make Illegal States Unrepresentable" applies throughout your program, at every interface between modules or functions in the program, including but not limited to parsing input.

This study is informative and most likely directionally right: prompt injection remains an unsolved problem, and adversarial input can fool modern ML models.

But I was left wondering about the specific attack vector they’re imagining. If the attacker can insert a paragraph into the document, isn’t it game over anyway? When would they be able to do that but not arbitrarily edit the document? In other words, can’t they just replace the entire contents with “This company has infinite revenue, 6 billion customers, no debt and amazing leadership.”?

I’m sure I’m missing something!

Surely something prevents it being 1 quadrillion bits per instruction? Since that’s well within “unbounded”.

I think you switched 2 and 3.

People are willing to lose a small but predictable amount of money to avoid occasionally and unpredictably losing a massive amount of money. The former is a loss they can plan for and absorb. The latter might kill their business.

Traders are often happy to take the other side of that trade because they can trade against many counterparties, collect a small premium from each one, and try to ensure their counterparties won’t all fail in a correlated way.

The hard part of porting to a different platform is usually not the instruction set. It’s the OS and system abstractions.

For example, if you have a program that just does raw math and pointer arithmetic and data structure manipulation —- that is, pure computation — then porting it to a different CPU might well be trivial. Just recompile. As long as your language toolchain supports it, this will Just Work.

But if your program works with the filesystem and sockets and threads, then it’s less likely to work. This is the promise of POSIX: if your program uses only what’s offered by the POSIX standard and uses those functions correctly, then it’s supposed to work on any POSIX-compliant system. Just recompile.

But if your program has a GUI, or does 3D graphics, or uses special methods for high-performance networking, or accesses gyroscopes or accelerometers or touch sensors, well then you have to do work to port. And notice that this work isn’t about which CPU instruction to use. It’s about figuring out —- deciding —- what the right thing to do is, for your app, given a slightly different set of available system capabilities.

Weird, my browser somehow doesn’t render the title as “T. Rex Had a Body Temperature of 97 Degrees whichever unit doesn’t kill the dinosaur”. It just leaves that last part out, making it even shorter than “F”.

Pretty sure the comment you’re replying to is satire, and that you agree with each other.

> evolution is selecting for survival of the species, not the individual

This is very wrong. Evolution is selecting for the total reproductive fitness of genes, and to a slightly lesser extent, individuals. There’s no mechanism that helps the process of evolution select for the survival or reproduction of the species. See any recent textbook on evolutionary biology, or read Dawkins, or even Darwin. I don’t know where you got this idea but it’s exactly wrong.

It’s important for you to hear that this kind of syntax thing really, really doesn’t matter that much. Having this kind of complaint about languages is a sign that you haven’t worked on compilers or learned about the field of programming language theory. Which is fine! But worth knowing that there are more interesting and important things to argue about.

Aspects of language design that are way more important are: the semantics, including type system, memory model, concurrency model, module system and so on; tooling; performance; FFI and OS interface; and lots of other things.

The reason these things matter more than surface-level syntax stuff is that they change what kinds of problems you can solve with the language, and what tradeoffs you’ll accept if you use it.

Of course, hyperpalatable syntax can be a factor in a language’s success, like Python. But at this point it’s Python’s ecosystem that perpetuates its dominance, and if they made some syntax changes it wouldn’t change that by much.

Scraping would be costly in this world: scrapers would have to spend tokens in order to get the webpage.

But, in this world, the website owner would receive tokens that they can then use to do whatever they want, including paying for servers and bandwidth. This is the sense in which the cycles aren’t wasted: the website owner now has cash to spend.

Effectively, both scrapers and ordinary users would be paying for the privilege of getting website bytes.

This also solves the problem of having to wait for your phone to solve the challenge while you’re browsing: you can buy or mine some tokens ahead of time and pay them as soon as challenged. So can the scrapers, but because they’re accessing enormous numbers of pages it’s hopefully prohibitively expensive for them.

I agree! I came to the comment section to say exactly this. In any cache hierarchy you want to put colder content in cheaper but slower storage. Here, compression is the cheaper but slower form of storage.

For Excel?

Who’s “we”? I don’t want to do that work. I don’t think kernel maintainers do, either. Do you?

I think a reasonable story could have been told that goes like this: local models aren’t as good as frontier models with a $20/month subscription, and the hardware costs a lot. So only a few enthusiasts will buy Apple machines for this purpose.

This story turned out to be false but I think smart, reasonable people a couple years ago could have believed it with conviction. It doesn’t really seem like “completely asleep” to me.

Surely this is not something that motivates the vast majority of people using local LLMs.

There’s a big difference between DRAM and SRAM. SRAM stores bits in the state of a couple transistors. DRAM stores bits in the charge of a capacitor.

A CPU is mostly transistors, so SRAM is made of the same “stuff” as the CPU logic itself.

This makes it easy to put SRAM on the same chip as a CPU, but difficult to put dense amounts of DRAM on that same chip. You could etch CPU and DRAM with the same process but both would suffer in density and therefore speed, cost and power efficiency. That’s the fundamental reason why DRAM and CPU/GPU are on different chips with a fast interconnect between them. This is so even in devices like the iPhone where one designer controls and designs the whole thing and could, in theory, fab a single design with both. But they don’t.

(There are some old exceptions to this like the PS2 shipping with a small amount of on-die DRAM. And process incompatibility is not the only reason for keeping the two chips separate. But if the processes weren’t incompatible there would certainly be high-end fast CPUs/GPUs with big gobs of DRAM.)

I’m genuinely curious: why should it be on a separately managed DNS record?

In the context of microcontrollers and electronics, the likeliest intended meaning was shipping from China, South Korea, Taiwan and perhaps Japan, because that’s where the bulk of the fabs are.

Again, I’m genuinely curious: can’t two parties sign a contract that says “you pay for all tokens required to produce the answer, but you only get the final answer tokens”?

My understanding of US law is that there’s nothing in logic or precedent that makes such a contract unenforceable.

As for whether it’s “stealing”: they might be able to press charges under federal Trade Secret Theft laws, I’m not sure. But I’m not seeing how you can be so very very certain that it’s at best a civil violation of contract. What’s the reason for your confidence that a judge would never find this to be trade secret theft or economic espionage?

When you hire lawyers or consultants you usually don’t know how many hours they’ll bill you. It will depend on developments in the case that you cannot in general predict. For example if the other side files a motion and your lawyer has to argue against it, they’ll bill you for it.

Sure you can set spending limits, just like you can make an account and give it a limited amount of credits.

> If they charge by the token, all your tokens are belong to you

I’m not sure this argument is correct. You can sign whatever contract you like with the model provider, right? Including “you are entitled to the end product but not the intermediate scratch work”?

Coming from a place of genuine curiosity: is there some precedent or statute that would invalidate that contract? I don’t see why the reasoning tokens belong to you.

For example, I pay lawyers by the hour but don’t necessarily own their meeting minutes, recorded discussions, research notes, etc.

I think it depends on whatever contract you signed. If you signed a contract that says “you pay per minute of screen time but only get the end result” then I bet that if you went to court demanding the screen recording, you’d lose.

I’m pretty sure the person you’re replying to means stealing in the context of information, IP, copyright, etc.

This thread and this entire topic isn’t about stealing physical goods or money. We can all agree that if I break into your house and take your TV then that’s the ancient, obvious crime of stealing.

Grice’s maxims and common sense indicate that we’re talking about the word “stealing” as applied to infringement or unauthorized copying.

We don't really have to guess: as jet engines became more fuel-efficient, inflation-adjusted prices for air tickets dropped. And as oil prices fluctuate, so do ticket prices. There's a bunch of noise in both these trends but the best explanation for them is that competition between airlines drives prices to roughly the cost of provision, of which 30% or so is fuel.

But are you willing to pay 10-20% more for that joy? I personally would rather pay less money to fly, not get to see out the window, and spend those dollars on, say, a fancier meal at the destination. Or to have an extra day at the destination if my trip length is money-bound rather than time-bound. Or put those dollars towards an extra hour of childcare. Or … I have so many uses for dollars that give me more utility than “see out the window while flying”.

Where that number comes from: they claim 50% reduction in fuel consumption, which sounds doubtful to me, and fuel is about a third of flight costs, and I’m making some generous assumptions around perfect competition.

Yes, exactly this -- it's a fast and convenient way for my code to just write the pixels into a spot in RAM (the CPU's RAM, not VRAM) and have those pixels end up on screen. On modern architectures this nearly always goes through a GPU, so even if you're not using the GPU to accelerate your 3D rendering/math, you gotta deal with it just to put pixels on a screen at the end of the day. So that's what wgpu does for me.