js8

But doesn't that justification work for any government, not just Chinese? In fact, it works for any easy-to-copy products, which act as positive externalities. It's just some Americans have this mindset that AI is a scarce good because everything must be.

I think in 2008, it wasn't clear whether cars are going to be replaced by electric and what the final efficiency will be. It could also have been more because you would need to convert electricity to fuel first.

So I think as a conservative estimate, it kinda works.

Love the book, but as others have noted, it is very much dated. Although I believe someone started a project some years ago to update it.

And HF actually tried to use AI to understand what's going on, but they had to use "unsafe" Chinese models since the "safe" ones have been castrated and refused to help. Great plan with the watchdog chip!

And you can't read long texts if there aren't that many to begin with. But it raises a question - why didn't China, which invented printing press earlier, didn't fare better?

> What's so interesting about tiling managers?

I don't use one, but interestingly, every IDE (or other professional mega-app such as Blender) is essentially its own tiling WM.

So quite clearly they have won as an UI concept for people who want to get things done.

Clearly, it only works in-game because SCUMM, the mysterious ingredient, is installed alongside the game. :-)

I agree, but I would say what the parent is saying is more akin to Say's law: https://en.wikipedia.org/wiki/Supply_creates_its_own_demand

I realized I answered the question (if landlords/investors restrict housing supply) quite indirectly, while there is a more direct answer.

I recommend Keen/Standish paper on the theory of the firm: https://www.paecon.net/PAEReview/issue53/KeenStandish53.pdf

They show that profit-maximizing agents communicating via price-setting only will happily restrict output in order to reach oligopoly prices.

They get power out of it (restricting the supply of capital).

In neoclassical economics, savings never pay off compared to investment. But in the real world, savings have important advantages:

1. They help you sustain longer in the case of strike (be it labor strike or investment strike).

2. They allow you to react to the market (for example, buying a promising startup winner after a competition consolidation) instead of being a first mover.

3. They allow you to price dump rapidly if a competitor threatens oligopoly pricing (usually the status quo), to drive them out of business.

That's why savings give you an actual power, which increases the richer you are.

Also, in my worldview, savings are liquid/reversible investments, while real capital investments are iliquid/irreversible - if you decide to build a factory you're commiting to an irreversible decision, if you buy an index fund, the decision is reversible, so it's basically savings. Making as few irreversible decisions as you can gives you an edge compared to others.

Someone mentioned a similar thing elsewhere in the thread, that by communicating those extra 700 bits, the sender also implicitly vouches for them.

> If you have 1000 bits of semantic information you want to transfer, you can't give 300 bits of semantic information to an LLM and have it fill in the remaining 700, because it doesn't know what those 700 bits are.

LLMs do inference or computation among other things, so the remaining 700 bits can be something like that. The hidden implication in your claim is that computation adds no information content, which leads to an interesting philosophical discussion.

So for example, if I ask an LLM to give a proof or derive a new theorem from a set of axioms, according to your assumption, if it answers correctly, then I haven't learned anything new.

I am not really sure how to resolve this paradox in information theory.

I am also not sure if the observation is true. People mentioned cats as a counterexample.

I think there are other species that could be considered more capable than humans, such as E. Coli, octopuses or ants.

And it's not even clear whether the AI will have its own individuality. It might become an extension of human brains, in the same way neocortex is an extension of amygdala. In that case the statement of who has control might become meaningless.

Liberalism has both economic (free market) roots and political roots. The first "leftists" were the French revolutionaries and they wanted (political) freedom as well. The reason liberalism is in the "center" is because both left and right tried to appropriate it. (Although I think liberalism, in the sense of individual freedom, is a distinct value from other values such as conservative/authoritarian or socialist/communal.)

> where companies provide the user/customer with an interface to an AI that can do things for the user

I'm afraid it is the future. The companies will protect all documentation and IP by putting it behind AI agents, and will monitor (with another AIs) how is it being used.

It's gonna be a dark era for any knowledge in public domain.

I am from EU, leftist, socialist and liberal (the left parts), and I can assure you, (a) most leftists (90%) are as liberal and antiauthoritarian as it gets, and (b) we are as powerless to change these things as you are.

Possibly, if you choose to believe me, things can change, but it's on you.

You have a point; I am looking at it from quite functional programming perspective, because that's how type systems are typically understood. So from that perspective, interior mutability is a form of rebinding.

When you say "we can choose mutability as a part of a type", the question is, what kind of errors are we trying to prevent? What is the semantics we want to give? From that it should be obvious whether it can be subtype or not.

Fair enough. Although I don't fully subscribe to the dichotomy of compile vs run time, we can say that.

I feel like the explanation is overcomplicated. Types are properties of values, not variables. Mutability is a property of variable, not of a value.

So it's kind of a categorical error. (I want to joke here that all categorical errors are just type errors in category theory.) When we speak of "type of a variable", we mean this variable can only be assigned (bound to) values of certain type. This has nothing to do with whether it can be reassigned (i.e. mutability).

So you don't even need the notion of subtyping to explain this.

Also, one could probably define variable as a monad over its type.

I was a PhD student for a while, but I always enjoyed "refactoring" proofs, more than coming up with new ones. Making them simpler, shorter, clearer. Unfortunately, it's not much rewarded.

Today, the difficult shit is how to get the resources from the people who use them to turn difficult shit into an easy shit. Basically, a war. I am not sure I want people to move on to that.

I agree with the 2nd sentence onwards, and I think I expressed it in the other comments I made here. I am not really sure what was your point about "execution", though. Humans might have inner interpreter loops as well.

I wish Terry Tao would prepend the guest names on his blogposts, this is not the first time it's confusing.

I disagree we understand LLMs, your view is quite reductionist. It's like saying we understand human brain because we understand physics and evolution, or that we understand some program because it's just a binary code in a known instruction set.

I think Dennett's theory of intentionality (see https://en.wikipedia.org/wiki/Intentional_stance) applies here. We do understand LLMs from physical stance (ML algorithm and inference), but we don't fully understand them from design stance (it's internal workings have been evolved so it's hard to tell the functional units) and from the intentional stance they are a complete mystery.

And I talk about obstacles to this understanding elsewhere in this thread.

Not really sure if it's sarcasm, but let me make a side remark.

It's really stunning how much more effective the "Standard ML" notation (embraced by Haskell, Lean etc.) is compared to writing proofs in classical logic.

This "UX problem" is, I think, the reason why is mathematical community embracing automated provers maybe 50 years later than they could have. Automated people wanted the better language, but the mathematicians largely resisted.

So seeing this, it would be preposterous for me to think that any language, natural or not, has the last say in this. We're gonna be stuck with learning new languages and formalisms for a long time.

I disagree, to keep it short, what you're describing is not understanding, it's superstition. And I think it's a wrong direction of engineering, relying on some sort of irreproducible expert intuition, one that has been successfully replaced by enlightenment and scientific method.

There are 3 major obstacles in understanding LLMs:

1. They use inscrutable internal language of embeddings

2. They communicate in natural language which is itself ambiguous

3. The weights and training inputs are being hidden as a "trade secret"

"with the added advantage of having been trained on a HUGE number of codebases"

This doesn't really mean much unless we understand what is the quality and relevance of these sources for the problem at hand. Without this understanding it's just a superstition.

I agree LLMs are useful tools, but I am dismayed by a lot of cargo-culting around them, which happens because we don't understand them. I think we will have much better tools when we understand what is the expectation and what is the algorithm they run.

Somebody else said that the magician analogy was poor. I like magic tricks, but it took many years of cultural change (influenced by people like Houdini, Randi, Penn & Teller) to stop illusionists (and mentalists) make claims they have supernatural abilities, or people believing it on their own (a magician pretending to be able to catch a bullet was shot by an audience member who didn't understand the distinction).

It is detrimental, I think, to treat LLMs as if they have magical abilities ("superintelligence") rather than understanding they just run some clever algorithm. The fear for (programming) jobs comes from that framing; nobody fears of their job because of compilers, since compilers are understood.

(And it actually runs against kind of "socialist" framing of the problem, which I agree with, that is why should people be worried about the jobs in the first place, when society is getting richer as a result of better tools?)

"You could say the same thing about human programmers, but I've never heard anyone say they think that programmers "execute" Jira tickets."

Yes I could. We have "executives", for starters. And first "computers" were actual humans.

"That was eons ago."

Yes, technically I should call them LRMs (large reasoning models) not LLMs. But that doesn't seem relevant here, to my point they encode some logic (which we want to be close to classical logic, i.e. behavior of words like "true", "and", "not" and so on matches).

I would agree with EDW, and I have argued here in a similar way.

I am not against use of NL in negotiation or poetry. If you find ambiguity useful there, be my guest. But engineering specifications, mathematics, as well as other sciences or even philosophy would IMHO benefit from more rigor.

I also strongly disagree with the notion that logical or programming languages cannot express ambiguity. (It actually took me many years to understand.) I used to think you need something like fuzzy logic or probability, but that's unsatisfactory in some ways. Eventually, I settled for a really simple understanding of the problem.

Take lambda calculus for instance. I define the term to be ambiguous iff it has a normal form. So it is ambiguous if it expects additional argument, which resolves (part of or all) the ambiguity. Terms with no normal form are completely unambiguous, their "output" is completely given.

In classical logic, this corresponds to formulas that are conditioned on additional assumption. Again, the extra assumption can resolve the ambiguity.

So it is kind of my conviction (although we could show that by translating an LLM as a program into LC) that all the words in natural language can be formalized as sufficiently complicated lambda terms, that all have normal forms and react to each other in a way that resolves some ambiguity without ever resolving all of it.

Well.. I think this is a big open problem in philosophy.

On one hand, you have things like Lean (calculus of inductive constructions), these are relatively simple formal logics (just in more practical notation) that let you define any conceivable type, which is akin to specification.

On the other hand, there is a rich set of modal and fuzzy logics that can help with aspects of reasoning in natural language. I think these can be defined in the former, but nobody has really made a good agreement as to how.

So the main difficulty is for any such language to gain traction, people who speak it.

Instead, we trained LLMs and they came up with something (evolved to reason). I think the future philosophical research will need to answer what exactly do LLMs bring to the table in terms of formalization of natural language.