chowells

Tied test scores to what outcomes? Bush the second tried tying test results to one kind of outcomes (school funding), and the result was schools getting worse.

You're right. I didn't enumerate every way UB can make a program go wrong. I'm sure I don't even know every way that can happen. But "UB doesn't happen at run time" is an assumption that lots of "optimizations" are based on.

That sounds like 1.5 decades to me...

Not only that, the code was wrong. The specification is quite clear that correct programs don't cause UB to be executed at run time. If your wrong code now produces wrong results, that's because it's wrong. That your compiler allowed you to get away with it for decades is a compiler bug, not a feature.

Do I fully believe all of the above? Not exactly. But compiler authors do. Does it make a really good argument to never use C or C++? Yes. If only we had 50 years of optimization work in any language with better semantics.

People still believe this? Google pays their ISP. I pay my ISP. Google does not pay my ISP. Why is my ISP's response to the amount of traffic I use demanding to bill someone other than me?

To be clear, Google was doing this out of self-interest. Paying user ISPs for access to those users is not a cost they want to pay. But it's the same as any other protection racket. A local shopkeeper has personal reasons to not want to pay off the mob, but that doesn't mean their position is wrong.

It's not difficult to communicate the difference between losing all future rights and settling a dispute over an incident that has already happened. I don't know why you'd act like it's a huge challenge to understand the difference.

But yeah; don't join the military.

No. C is a language with a specification independent of implementation. If you write correct C code (according to the specification, which no one does), it does not depend on any of those factors. C is almost uniquely bad in terms of accepting broken programs and just compiling them differently. But that doesn't change the fact that the language has semantics, even if most code that violates the documented preconditions those semantics depend on.

It's nothing at all how like C runs on top of assembly. C has semantics. Code means something without ever being run. You can check in your source code and (assuming it actually follows the C standard and your compiler's documented extensions, which almost no real C code does - C was a horrible example) it will work just as well in a year as it does today.

Try checking in only your prompts and nothing else. Just the parts you actually typed. See how well it works to regenerate the same application next week, let alone next year. Prompts are fundamentally a different sort of thing from code. Do not mix them up.

Eh. A quick scan of steam reviews shows a clear pattern - the game has been in decline ever since Yegge took over, well before LLMs were a product. It seems he started upsetting people with a capitalist-brain insistence on extracting value, and nothing has changed since. As long as he doesn't understand that his goals are contrary to building a game people enjoy, quality of the code is completely irrelevant. I don't think this one works as a test case on the value of programming like this, as the intended audience just isn't interested.

Yes, I know they're orthogonal. But every example of using macros I see in lisp is either some horrendous non-local logic, or something that can be done better using simpler tools. Where's the killer use case that clearly is good software engineering and not papering over the lack of another feature?

That's not at all what local reasoning means. Local reasoning is the property that a piece of code contains (when including the call graph) everything that can affect what it does. All mutation of a value is kept within some scope of ownership of that value. If you want to understand a piece of code, you can do it by understanding that piece of code, not the program as a whole.

Assembly makes non-local reasoning mandatory, as any code can update any location in memory without restriction. All memory accesses are global. References need not even be by name - they can be via computed addresses. There are no restrictions in place allowing the structure of the program to provide boundaries on what pieces of code may be understood as units.

Yes, you're describing cosmology. We can't create separate test universes, so all we can do is argue over which model is the best way to explain our observations. The difference from ad-hoc reasoning is the exact same as any other science. You make predictions based on models and then try to find places where those predictions hold - or are broken. In either case, you're testing the validity of a model. And when something isn't good enough, you either adjust the model or find a new one that works better.

This isn't some slapdash random patching. Everyone involved knows that assuming that the λ in λCDM is a constant is shaky. It could be a function of time, or even location in some way. But it's simplest if it's a constant. So you start by modeling the universe as if it is. Then you determine what sorts of observations would support or contradict that, and you start making them. When you get results, you start examining what version of the model best explains those observations. And someone somewhere goes off to try find a better model than any version of λCDM. If they succeed, their model will eventually supplant it. This is how science progresses, even if the experiments are less under the control of the experimentors than they'd like. The important part that you make revisions in response to observations.

(FWIW, particle physicists are constantly frustrated that they can't find counterexamples to the Standard Model. They know it has to be incomplete, but the lack of contradictory observation leaves them no direction to try to improve it.)

This doesn't strike me as better than the alternatives. In Haskell, it's just a few different functions to handle the different use cases. That strikes me as far better than one "function" that magically does different things depending on how it's called. It is local, I'll give you that. But it still seems bad because you have overloaded the semantics along multiple axes simultaneously. I prefer building blocks with only a single set of semantics each. I believe it's better to write precise code than DWIM code.

What makes this a desirable feature? From the perspective where local reasoning is the most desirable property a language can have, how does homoiconicity support that?

I honestly am curious. I've seen a few examples presented for it, but they always seem like bad software engineering to me. Where's an example that does something in a cleaner way than alternatives present in other languages while remaining compatible with local reasoning?

The ideal would be to go into swap without becoming unresponsive, so that the user can quit a program of their choice to free memory. If you really want to make an issue out of it, do something like pre-X macOS, where it would provide a warning when you are getting close to running out of memory, so that a user might have the chance to do something before the current process starts getting swapped out.

Following this argument to its natural conclusion, we should tell LLMs to generate the binary directly. It's still an abstraction, but it's the lowest level we can go to on current consumer hardware.

I don't think raw machine code (not even assembly) is the best form to reason about program logic. It just takes too many steps to execute sophisticated processes to keep them all in your head at once - or keep them all in an LLM context at once.

Good lord, the damage LLM use has done to deep thinking is amazing for such a short time. Maybe if it stayed hard to find your phone, you would have put some time into considering the root cause of the problem: you put an employer MDM on your phone. Except, well. Now it's their phone. You just pay for it.

The expressed (not implied) alternative in the post is for those people to stop pretending they care, and start actually caring. Stop trying to save the world. The world doesn't need an invention to save it. Just put that energy into caring about others.

Yeah, there's actually been a lot of research on that. 100ms is generally considered to be the threshold between perceiving a delay or not. But even that needs some additional context. That's the threshold for feeling like you're waiting to get a response after completing an input. But a 100ms round-trip delay on a mouse cursor would feel like you were using a broken computer. And when you're doing something where you're used to continuous feedback from your input, you can sense incredibly small changes in the response time. +/- 10ms from what you're familiar with is noticeable for almost everyone. There are people who consistently notice half of that - but remember that's in the context of difference in latency of continuous feedback. 100ms is a pretty good rule of thumb for the threshold of "why am I waiting for this?"

The underlying issue here is that addresses created by the tool at fault can have their private key derived from public data. If you send it back, it'll just get stolen again. Furthermore, the typical way that someone proves ownership of an address is by making a transaction from that address with parameters set via private communication with someone else. But since the private key is knowable, anyone can do that. There's no generic way to prove ownership of an address if the private key associated with that address can be determined by an attacker.

That's not what it says. It says that as long as the logic is rich enough (first-order isn't enough) and consistent there are statements where neither the statement nor its negation is provable. You may choose to create a new logic by adding either the statement or its negation as an additional axiom, and it will (obviously?) remain consistent.

Truth is some sort of value judgment that is outside the scope of formal systems. And looking at how bizarre Gödel statements are, it's unclear if there's any particular justification for declaring them to be true or false.

It might damage Google's reputation with advertisers in the long term. I'm not convinced Google would even care about it, given their other behavior.

Double dash -> emdash is a default autoreplacement in OSX. That's why a lot of people think it's the default everywhere.

This is a description of one portion of math... one that's very easy to get tunnel vision towards when undertaking a very formal undergraduate mathematical education. And that's especially true if it was alongside a computer science education, which is precisely the branch of math concerned with formal systems being used in calculation.

I've done both of those things. I know what you get taught. But I've kept my math education going for the 25 years since then. I've talked to practicing mathematicians about what they do. I've learned a lot about the scope of math.

As an aside: most people really dislike it when I say that they should be much more precise about different numerical systems. The integers are not a subset of the rationals. They are entirely different constructions, but there is an isomorphism between integers and a subset of the rationals that preserves the integers' ring structure within that subset of the rationals and a few other aesthetic concerns. You can see why no one wants to communicate like this, even if they acknowledge it's technically correct. So I know all about pushing symbols around.

But I also know that pushing symbols around isn't the whole story. Pushing symbols around is only useful as a final check. Do you want to validate that 1+2=3? Pushing symbols around can help. But how do you decide that the ideas behind 1, 2, 3, +, and = are worth having precise and compact representations?

Math doesn't just use formal systems to generate proofs. It's not enough for symbols to be arranged neatly according to some rules. Math is also the process of creating the sets of symbols and their rules and communicating to other people why this set of rules and symbols is interesting. What ideas get preserved when you are working with this system? What is it an abstraction over?

You have a weird definition of "smuggling". I say it outright. Because I follow it up with a description of the actual practice of math: it's the study of abstraction. That's not a frame. That's just what math is.

It's elegant if all you're concerned with is whether a conjecture is true or false. Answered, move along!

But mathematics is not a collection of facts. Mathematics is the study of abstraction. And what do you learn from a single data point? What can you abstract from that?

That's why just being a counterexample isn't really interesting. There has to be more than "counterexample" for there to be something to abstract. Was it generated from an analysis of the problem? Can the counterexample be generalized to explore the problem further? Is the counterexample a surprise in a way that suggests something is missing from current understanding?

Being a counterexample doesn't mean that something isn't interesting to a mathematician. But it's also not the interesting part.

The slowest multiplications are always when the two numbers are about the same size... That is to say, the case you're talking about doesn't happen.

Bluesky has a data store, handles account authorization, and runs a web app that provides a UI to access the backend services. That's an instance, whether they call it one or not. Refusal to admit this is obfuscation for reasons I cannot understand.

As Led Zeppelin once said, "you know sometimes words have two meanings". That definition of wealth is all well and good for books about how markets are magical fix-everything pixie dust. But it's not the definition of wealth that applies when used to describe a person. A wealthy person is not someone with a lot of things. That's a hoarder. A wealthy person is someone who can use their economic power to shape the world around them.

It is literally impossible for everyone to obtain wealth. Wealth isn't a number or physical circumstances. Wealth is having economic power over the people around you. Success is a little more nebulous, but when thought of as a relative of wealth it's similarly contextual.

The danger isn't everyone but you getting wealthy. The danger is that wealth tends towards concentration. And it tends to concentrate around people who are already wealthy. The danger is, bluntly, that things will get worse for all but a few and most people will be so caught up in a red queen's race that they can't see how to stop.