> remember we're 2 years away from self driving car since 2010

Depending on how you define that milestone, we are already there. There are multiple companies offering self-driving cars to the public in multiple cities.

I'd count that as a success.

> Depending on how you define that milestone, we are already there.

My definition is definitely not "only on straight wide and sunny Californian roads and sometimes crashing full speed into a stopped vehicle".

Remember that in 2014 Uber was talking about buying 500 000 fully autonomous teslas "by 2020", they bought 0, and they're still not anywhere close to autonomous.

The AI output was much easier to understand than your homepage.

I read your homepage for 10 seconds - I thought it was just a low resolution display.

I read the AI output - I realised there were apps and also what kind of apps were available. A completely different product.

Thanks, that's good feedback. I appreciate it.

I know the rules of chess, but my rate of attempting illegal moves is above 0%.

Especially if you’re playing blind. I’d say an error rate of less than %1 is pretty good in that case.

A human mind is not a rules model for Chess, and comparisons to a human mind are worthless. We're not asking if the LLM is human, only if it is modeling the game rules or modeling statistics

My point is this:

* If the results of the model were perfect, not a single counter-example, that would be a strong argument that the LLM has built an internal model of Othello

* If counter-examples exist, the result of the experiment is indistinguishable from a sufficiently clever statistical inference and proves nothing

So you assert that parent doesn’t have an internal model of chess?

Or that only proved expert systems built specifically to play chess have an internal model of it?

> So you assert that parent doesn’t have an internal model of chess?

I think it's an interesting question, I find it more likely we have an imperfect ability to perceive the whole chess board, whatever the hell that might mean.

In any case it's irrelevant to an LLM which has perfect information from the input set.

So perhaps we rephrase the question, I think the parent, if given a list of individual chess moves (in whatever notation pleases them), should be able to tell if a given move is valid or not for the given piece. If the parent failed to do that, I would say they do not have a valid model of chess, ya.

> If the parent failed to do that, I would say they do not have a valid model of chess

Surely even the world's foremost chess experts will occasionally make errors in such a situation, so what's the point of holding language models to an intelligence standard that even humans can't meet?

I see two ways of interpreting this: either language models do approximately learn world models, or else world models aren't necessary for human intelligence

EDIT: I see from your other posts in this thread you're probably more inclined to believe the latter statement, which wasn't obvious to me from your first post and I think that explains why there is so much contention in this thread.

Well, if the model has a 100% grasp of the rules, why call it a model?

Because it's not a physical othello board? It's just an internal model of an othello board encoded in the weights of a neural net?

Insert whatever semantics float your particular goat

I thought the whole point was about modelling rules not atoms.

I saw a cookie opt-out a couple of days ago where right was off.

That will be the point at which the current model of capitalism will fail.

I would argue that the current model of capitalism is already struggling hard, if not failing. Near-zero interest rates have ensured that the evolutionary mechanisms built into capitalism are effectively negated. Zombie companies that produce no real products or cash flow can exist in perpetuity - far from the "survival of the fittest" ethos of capitalism.

Implementing a linked list in Rust is somewhat challenging because of the safety issues that arise. Luckily you don't have to, there's one in the standard library: https://doc.rust-lang.org/std/collections/struct.LinkedList....

The equivalent of a generic memcpy is probably something like a .clone() call on a generic type that implements Clone.

> The equivalent of a generic memcpy is probably something like a .clone() call on a generic type that implements Clone.

If you type "memcpy" into the documentation search, rustdoc will point you to

* https://doc.rust-lang.org/stable/std/primitive.slice.html#me...

* https://doc.rust-lang.org/stable/std/intrinsics/fn.copy_nono... (Though it should really point to the reexport at https://doc.rust-lang.org/stable/std/ptr/fn.copy_nonoverlapp... )

The latter will also mention

* https://doc.rust-lang.org/stable/std/ptr/fn.copy.html

> Implementing a linked list in Rust is somewhat challenging because of the safety issues that arise

Implementing linked list in any language that is not memory-safe is challenging because of safety issues. Rust just points it out.

This isn't an intrusively linked list.

Probably not the Clone trait but the Copy trait.

Nice: "it’s likely that using Rust has already prevented hundreds of vulnerabilities from reaching production"

It seems unlikely that it's the double colons and the angle brackets that hold people back from migrating from C and C++ to Rust.

Yeah Rust's syntax was inspired to be similar to C++.

Where are the double colons and angle brackets in C?

I think the point is more that both syntaxes are verbose. No one who is used to dealing with C type signatures is going to shrink at Rust's syntax.

I was responsible for that decision, and I'm also a typographer (worked for years on vector rendering of fonts). :)

What reason were used to not use what C# has? It’s infinitely less noisy than Rust’s ::

Using a separate character for namespace resolution and field indexing allows you to have a module with the same name as a value.

Wouldn’t this be trivially solved by having namespaces follow the same PascalCase semantics as types?

I.e

use Std.String;

…. let string = String(…);

That's a different trade off. It's not a solution.

Technically, it is only 75% less noisy.

I always say that if the strongest complaint people have about your language is syntax; you've already succeeded.

You have an extra semicolon in your comment.

It's two statements, comments start with //

:o)

It's "clearly" wrapped in hidden delimiters so that the server regards it as a comment, though. (-;

Syntax is one of the most important characteristics of language.

It’s the difference that makes the difference between Rust-like and C++-like gibberish and poetry.

I do agree that Rust sometimes has a lot of visual noise.

But that use statement is not a good example of it, and if that's the biggest criticism then Rust is faring fantastically well.

Yeah I agree. Rust is a mildly ugly language, but not because of `use`! It's all the lifetime annotations, turbofish, and macros that make it ugly.

As somebody who appreciates Lisp, I feel your pain. As somebody who also appreciates Rust, I'm curious, what is your baseline?

Good design theory.

https://www.doverbooks.co.uk/point-and-line-to-plane

Consider h::i::j::k versus h.i.j.k

Two :’s is an extremely loud combination of visual elements compared to the subtle point. :: drags the eye away from the content and says “look at me oscillate”

In addition, humans group similar visual elements together so a combination of anything::doesnt::matter::what::between::clumps it is impossible to escape the common pattern and the eye jumps between the ::’s. Therefore it takes double the cognitive load to read.

What’s worse, the eye gets trapped within each :: because it’s a combination of four dots, which naturally creates an implied circular pattern which draws the viewer in further.

Compare to something like: use HashMap from std.collections

Or… more obviously the python import statements.

> look at me oscillate

I'm curious, are you dyslexic? Seeing letters move is generally something that people with dyslexia complain about.

I’m not dyslexic actually. Just thinking in terms of good user experience. A lot of the issues with C syntax is that it’s largely designed to make it easier for compiler writers.

I feel like Rust has similar pitfalls in that vein—instead of defining the user experience first, they went for a symbol that is not used elsewhere—making it easier on the engineers while satisfying the “functional requirement” of namespaces.

So—Rust will not be the language-to-end-all-languages because it is not beautiful enough. Perhaps it is almost there in functionality, but i foresee a problem with any language’s longevity unless it’s literally perfectly thought-out user experience.

I’d love to jump on the hype train with Rust but it’s not really that exciting. It doesn’t really feel all that natural. Well-thought-out user experiences should feel natural through-and-through.

> Consider h::i::j::k versus h.i.j.k

> Two :’s is an extremely loud combination of visual elements compared to the subtle point. :: drags the eye away from the content and says “look at me oscillate”

> In addition, humans group similar visual elements together so a combination of anything::doesnt::matter::what::between::clumps it is impossible to escape the common pattern and the eye jumps between the ::’s. Therefore it takes double the cognitive load to read.

It is true that the colons take up more space and your example looks good on HN.

But this problem will be immediately solved by syntax coloring. It's just never going to come up.

Syntax coloring would make it worse because coloring the :: independently of the surrounding tokens will make them stand out even more as a group.

Rust is safe but it’s at least as ugly as C++.

It depends on how the coloring is done. If the background is white, the words are black and the :: are gray, the :: won't stand out.

True, but why bother with the symbols in the first place? User experience is just as important for developers reading/writing text and languages are typically created behind closed doors with a small engineering team only.

Guido got a lot right with Python because it’s clean and easy to jump in. Minimal cognitive load. But still very powerful.

Cool, thanks! This sticks out from PL syntax criticism that goes along the lines of "not enough curly braces" etc.

Brainfuck, clearly /s

You could have 300 like FTX and have completely inadequate financial controls.

Contributed a patch to the Java String class that caches the hash code.

Much like stonehenge.