s-macke

The answer is yes according to code and documentation [0]:

> The stream multiplexing capabilities of QUIC allow reducing the head-of-line blocking that SSHv2 encounters when multiplexing several SSH channels over the same TCP connection

....

> Each channel runs over a bidirectional HTTP/3 stream and is attached to a single remote terminal session

[0] https://www.ietf.org/archive/id/draft-michel-remote-terminal...

It is not faster in this sense. However, an SSH connection can have multiple substreams, especially for port forwarding. Over a single classical connection, this can lead to head-of-line blocking, where an issue in one stream slows everything down. QUIC/HTTP3 protocol can solve this.

Author here. The discussion about this wording is actually the opening section of the article.

> Unfortunately, the term hallucination quickly stuck to this phenomenon — before any psychologist could object.

Like they learn facts by heart, they learn what they can’t by heart as well.

Ask them to solve one of the Millennium Prize Problems. They’ll say they can’t do it, but that 'No' is just memorized. There’s nothing behind it.

Author here. You’ve just summarized the main part of the article. To keep things simple, the focus is on pure facts. But yes, the outcome of next token prediction is much more profound than wrong facts.

The Starflight role-playing game for DOS [0] was written in its own Forth dialect. Even today, it remains one of the games with the strongest Star Trek feeling.

[0] https://en.wikipedia.org/wiki/Starflight

Yes, my comment came across a bit harsh, and it’s fine to pick up a few negative karma points. But I keep seeing Forth posts every two weeks where everyone has just built yet another interpreter.

Actually I did a few projects with Forth and I find it very cool:

[0] https://github.com/s-macke/Forthly

[1] https://github.com/s-macke/starflight-reverse

[2] https://s-macke.github.io/concepts-of-programming-languages/...

Right. And once again, you’ll also notice that no one is actually coding anything useful in Forth.

Thanks. Fixed it.

Nice to see another developer who tried to implement Forth in Go (here’s mine: [0]). It’s not easy and usually takes several iterations.

His implementation, while working for his use cases, is actually quite far from the originals. He uses separate Go structures for words, memory, for-loops, etc. Most of the default Forth implementations of words will fail, since they expect the heap and stack to behave in a certain way. Also, every major word is implemented directly in Go, with no bootstrapping.

> However, it's insufficient for the hacker level, because the host language interpreter (the one in Go) has all the control, so it's impossible to implement IF...THEN in Forth

Well, I did it with a ... heap []any ... data structure. Works well enough.

[0] https://github.com/s-macke/Forthly

Author here. Yes, it runs a modern Linux from a 1.6MB binary. I did everything possible to make it as small as I could. It even compiles into WebAssembly and runs in the browser.

Livestream yesterday

https://www.youtube.com/live/UDzGwTalVAc

LLMs can help you analyze the code, but not write it. Their ability to obfuscate is quite limited and uninspired. The last IOCCC was in 2020, so we've had plenty of time to work on it.

Most of the sites I’ve seen are indeed just demos. I especially like Compute Toys [0], a Shadertoy clone for WebGPU. [1] is probably the best place to find demos. I have a site myself in which I experiment mainly with WebGPU Compute Shaders [2].

[0] https://compute.toys/

[1] https://github.com/mikbry/awesome-webgpu

[2] https://github.com/s-macke/WebGPU-Lab

That’s a good point. For 9:05, I expect it would work just as well, since the game helps the user in many ways. The puzzles are of the type “The door is closed”, and you solve them with “open door.”

My suggestion concerns the poor performance DougHaber mentioned: if 9:05 can’t be solved, something else must be wrong with his experiments.

I’ve tried three dozen games, and it’s still hard to find ones suitable for LLM benchmarks. With non-linear complex text-adventure games, my guess is, that they get stuck in an endless loop at some point. Hence, I just test the progress in the first hundred steps.

Try the game 9:05 by Adam Cadre [0]. It's one of the easiest (and best) non-trivial text adventures. Some models are able to reach the first or even second ending.

[0] https://en.wikipedia.org/wiki/9:05

The answer to the paper's question is likely yes—especially if context is used effectively and memory and summaries are incorporated. In that case, chatbots can complete even more complex games, such as Pokémon role-playing games [0].

The challenge with benchmarking text adventures lies in their trial-and-error nature. It’s easy to get stuck for hundreds of moves on a minor detail before eventually giving up and trying a different approach.

[0] https://www.twitch.tv/gpt_plays_pokemon

This paper only scratches the surface and feels incomplete, as it references only GPT-4 and mentions appendices that are not included. The examples are two years old.

For a more in-depth analysis of chatbots playing text adventures, take a look at my project. I haven’t updated it in a while due to time constraints.

[0] https://github.com/s-macke/AdventureAI

Maybe WebVM is something you are looking for [0].

[0] https://github.com/leaningtech/webvm

Thanks. This is awesome. For the emulator I wrote my own 200 line libc implementation with a five line malloc routine [0]. Nice to see another implementation, which does a little bit more.

[0] https://github.com/s-macke/FSHistory/tree/master/src/wasm_li...

clang can compile into wasm pretty well via the

--target=wasm32

option. It creates small binaries. My 16-Bit x86 emulator with BIOS and DOS emulation is under 100kB [0].

[0] https://github.com/s-macke/FSHistory

My code uses some kind of very abstract byte code in a global

    heap  []any

structure (threaded code). "any" can be different types including Go functions. But most of them are pointers as usual in Forth.

Not sure if this counts as an implementation, but this is my Forth compiler, written in the high-level language Go [0]. This is also a challenge, as Forth usually requires machine language, call stack access, and is naturally written in assembler. Took several tries until I found working data structures.

The funniest thing is, you can easily write and invent your own control structures in Forth, as well as change the behavior existing ones such as the do/while loop.

    \ alter the behavior of do by printing the current index in each loop.
    : do immediate
        [COMPILE] do   \ first compile previous do impl.
        ' i ,          \ then print current index
        ' . ,
    ;

[0] https://github.com/s-macke/Forthly

This seems to be a formatting error. For such a huge author list, you usually write only the first name and then "et al." for "others".

There is a FAQ in the link.

This emulator does basically the same but is much more speed optimized. It uses the OpenRISC architecture and even has networking. For what do you want to use such an emulator?

[0] https://github.com/s-macke/jor1k

Yes, permanently. Sonnet 3.7 is already number one in the ranking. Grok3 has no API yet.

Simple Bench goes in this direction: https://simple-bench.com/

o3-mini was announced for today, and OpenAI typically publishes in the morning hours (PT). Many people were eagerly waiting. The publication was imminent. I kept checking both Twitter and Hacker News for updates. Just add ten more people like me and the news will become top news within a few minutes. That is legit.

> Notably, no self-reflection training data or prompt was included, suggesting that advanced System 2 reasoning can foster intrinsic self-reflection.

They suggest, that self-reflection is an emergent phenomena of reasoning. Impressive. Can't wait to see the code.