rfgplk

> Most of them are slop and it’s hard to find something valuable.

Most of them aren't slop. They're actually quite useful, but I guess the anti-AI cult wants to silence all AI-aided projects in an attempt to point out how "there's no new software being written by AI".

Just quiz any of these AI detractors on pure asm + CPU implementation details. Oh what's this? You're writing this in Rust? Can you please tell me how the compiler optimizes this code and what assembly will it produce. Oh what's that, you can't do it? Well, it's obviously because you're not a true engineer™ and you're relying on the slop your compiler gives you.

Keep going, and I hope more people start rolling their own languages.

If anyone is interested, I'm fairly close to finalizing Slang and I'm considering open-sourcing it in the near future. What originally started as a simple register based lang for an embeddable VM turned into an insanely expressive meta?programming language. Full system Fω, expansive whole program reflection (you can reflect on absolutely anything), string memory & logic safety..

You can do stuff like this:

   (fn answer () -> i64 0)
   (defpass build-answer
     (phase source)
     (transform (lambda (f)
       (fn-with f 'body '(let ((a (arr (42)))) (at a 0)))))
     (safety (lambda (goal) (syntax (refl)))))
   (run-pass build-answer answer)
   (fnmut answer
     (transform (lambda (f)
       (if (memory-safe? (check-memory (current-program)))
         f (syntax-error 'unproved-memory)))))
   (defpass inspect-ssa
     (phase ssa)
     (transform (lambda (f)
       (if (memory-safe? (check-memory (ssa-current-program)))
         f (syntax-error 'unproved-ssa-memory))))
     (proof (lambda (goal) (syntax (refl)))))
   (run-pass inspect-ssa answer)
   (answer)

or this:

   (fn next ((i i64)) -> i64 (+ i 1))
   (fncontract next
     (ensures result (successor (Eq i64 result (+ (old i) 1)) auto)))
   (fn read-second ((i i64)) -> i64
     (let ((a (arr (0 42)))) (at a i)))
   (fncontract read-second (requires (one (Eq i64 i 1))))
   (let ((i (next 0)))
     (with-proof ((one (Eq i64 i 1) (result-proof i successor)))
       (print (read-second i))))

it also supports full inline asm or llvm ir:

   (var answer 0)
   (asm (input rdi 20)
        (input rsi 22)
        (output rax answer)
        (mov rdi rax)
        (add rsi rax))
   (print answer)

   (macroop \ (a) (asm (mov a rax)))
   (\ 42)

   (print (llvm add 20 22))
   (print (->i64 (llvm fused-multiply-add (f64) 6.0 7.0 0.0)))
   (llvm fn sum32 ((x i32) (y i32)) -> i32
     (block entry
       (value answer (llvm add x y (declare (flags nsw))))
       (llvm return answer)))
   (print (->i64 (sum32 (the i32 20) (the i32 22))))

Even though you can write this by hand, the core idea is to get a very dense and terse language that LLMs can emit while guaranteeing safety and performance.

For custom server implementations, agreed. But the web still depends on HTTP and we sadly need the major infra providers to agree on a new standard otherwise HTTP isn't going anywhere

Most header parsing bugs that affect HTTP1.1 can also affect 2+3. Not in the same style but there are quite a few overlapping ones.

Or you can roll your own and not rely on the literal disaster that Google developed. Brotli is trivial to implement.

Agreed. The issue with all these archaic standards is that they were rolled decades ago back when certain practices were either outright not being employed OR that hardware wasn't fast enough. Ironically, HTTP itself is a literal nightmare to parse (performance wise) on top of having like... ten? distinct vulnerability classes. The world desperately needs new standards.

As I've mentioned numerous times at this point, relying on third party code is a massive liability (supply chain attacks/sloppy code). My hand rolled brotli implementation is not only faster than libbrotli but also immune to this vulnerability (yes, I checked). Roll your own code people.

I'd advise you to keep going. Over the past few months I've iterated through a few different kernel designs, just trying out certain architectures and seeing what works, or, what would work better than the POSIX de facto standard modern OSs use. I can genuinely see a future where running your own OS becomes the norm and not an esoteric project.

The quality of technical discussions here has clearly nosedived over the past few years. This release basically confirms it.

?

Inference is super easy, you already have a myriad libraries that accomplish this. In fact if you read the source, this is release is mostly a wrapper around those same libs.

Claude didn't make this, the author did.

They haven't degraded, their service is being hit by an enormous amount of traffic. PRs/commits are what? Doubling every quarter?

Opus/Fable/Astra/Sol are outright better than Linus.

Which is spikier qktqb or rrqtyun? For me personally, rrqtyun is spikier although certain models seem to disagree. GPT (Astra) believes qktqb is spikier.

This one is also a curiosity

> isn't klop right at the edge between spiky and round

> Yes. “Klop” is borderline, but leans slightly spiky.

I don't even use an editor anymore. Just sed the source files directly via my agent.

Here we're seeing what skill in using LLMs looks like.

Controversial opinion, but new programming languages are desperately needed, _especially_ in the age of LLMs. Simply put, not all languages provide equal expressiveness, even if they're all Turing complete.

> A PhD is not the same thing as professional experience.

You're correct, academic experience and credentials should be worth _more_.

Every single job requires many YoE at this point. Every. Single. One. And the worst part is that they really mean "years of employment" and not experience. Pursuing a PhD full time effectively _is_ employment, yet most companies and HR departments don't see it this way. Likewise for independent research, open source work, self-employment etc. My guess is he has dedicated his life to his PhD studies, meaning he has little "ReAl ExPerIeNcE" so no one wants to hire him because... reasons? Who knows, hiring is broken.

Yep. If you think your job involves "writing code" as the core part of your responsibilities, write yourself off immediately. That career is dead and dusted. Sadly most companies still haven't realized this, given how few Architect openings exist (and those that do, most are asking for 20+ years of exp lol)

Not quite. My C++ Linux rewrite is already production ready, meaning in theory I no longer need to rely on the Linux kernel devs. This will, in a matter of months I presume, become the norm.

Linus himself is actually comically incompetent. He only became famous after the Linux kernel took off... decades ago? Since Git, he has made ZERO code contributions whatsoever (not even to the Linux kernel). He doesn't even review code and has his team of capos do it for him. All in all he's no different than the CEO of some tech company, his thoughts on LLMs are no longer relevant (for more lack of credibility, see his stance on Rust, C++, Go)

> pushes back on much of this

He's "pushing back on this" because he's being obsoleted in real time.

No, this implementation is just horribly optimized (as usual). Just glancing at the source you could do easy 100x performance improvements with simple fixes.

ie no SIMD/SWAR anywhere; simulating things that literally don't need to be simulated; CPUs are emulated via monstrous instruction flooding cascades with ZERO reordering/speculative execution optimizations (this only improves performance, the underlying emulated program literally can't tell the difference, and with most emulators you'd get a FREE 5-20x improvement); cache trashing everywhere; zero multithreading (as far as I could tell, couldn't bother checking in detail)

I've spoken to a guy on reddit whos working on an AI written The Winds of Winter/Dream of Spring. He's shown me a few chapters and it genuinely feels like GRRM wrote it.

Considering forking it (and rewriting to C++)

Yea, these are generally the acc numbers I've been waiting for. The only thing they need to do now is port this tech over to less expensive models (<$150k). The acceleration of most modern cars is an absolute joke, even when taking into account sports cars.

Also keep in mind that even _this_ acceleration is... decent at best, for a car. I've made numerous hexrotors that can hit ~300kmh (~186mpg) in 500-1000ms.

Taking off they make cars look like an absolute joke. Disappears in front of you.

Love it.

They can't prevent people from making their own in-house clones. They can take down Artcraft/whatever OSS repo but it's meaningless. I have my own C++ Photoshop/Office clones that I've been using for a few months now. Full replacement for anything Microsoft/Adobe has put out. How are they going to prevent me from using my own code? Or how will they prevent anyone else from just vibing up another Artcraft replacement (in case it gets taken down)?