So, without subagents how will the loop thing work? What about stacks? And AI factories? Wasn't the whole vibe code orchestration predicated on subagents?

You are probably not too far off. I remember once reading the distro name had something to do with food or something like that.

RL training helped reduce hallucinations. But also made them less obvious, less severe, and harder to detect. But generally speaking, if you build a long enough context window you will be able to witness several instances of hallucinations. They will just usually not be so obvious and severe as in the past.

Tim Sweeney concern are the developers, while Valve worries about the consumers. It's always been like this. You can see it down to how both their platforms have been developed over the years. If disclosure of AI usage can be used against the developer, then this does sound like an important thing for consumers who generally want to make informed purchase decisions. Tim Sweeney position is indefensible. Also, while to my knowledge the disclosure surely reads like an allergy label, "this game was developed with the help of AI", or something like that, developers are free to describe what parts of the game used it on the game description. What I would probably be critical of is if Valve implemented filtering options based on this disclosure.

I was going to ask. Then saw your reply. This is the weirdest thing.

Why are you saying Zig? Zig is fast, yes. But... - Certainly not as safe as Rust. Rust type affinity and permissions are non existing in Zig. You get some safety out of Zig, but nowhere near Rust's. And that's ok. - It does not offer as many concurrent features as Go. Nothing similar to goroutines, for instance. And most concurrency details have to be handled by the programmer. And that's ok-ish. - And it certainly isn't a simple language "like Python". What on earth made you think so. And that's fine.

Who would ever thought that 78 years later, an Israeli government would shame their people history and disgrace their nation, by turning their country into an evil bastion of propaganda, racism, destruction and death.

I can't seem to make my mind on this. The problem I have with it is when I start drawing parallels to other final products of engineering which aren't going to tell us what materials or processes were used, for instance. But on the other hand, AI use is a big deal in the context of software engineering and the user expectations to just be something we can hide from a product description.

Ok. So, instead of a log_print (b a calculate d "test" e); Which is admittedly mean of me, I could do: a log_print (b (a calculate d) "test" e); This would help some. The problems I have with it is - how unnatural it looks to me. I don't see how consistency with arithmetic operations helped us in any way. - I don't see a reduction in bloat. I suppose anyone can eventually wrap their heads around a notation (I learned RPN on my calculator once, for no reason other than I thought it was cool). But are we looking in the right place? The bloat I personally see in modern languages is associated with syntactic delimiters. Stuff like double-colons (::), equivalence (=>), arrows (->), et cetera. Many of them created not because the compiler needs them, but because there is this idea that it makes things easier to read. However I will never understand how this func(a, b, c) -> namespace::T Is any easier to read than: namespace.T func(a, b, c) (simple example here. It's almost 2am here and I don't want to think too hard)

It's log_print, not log print :)

So, I would be free to move the first argument to the right, essentially mixing prefix with infix for readability purposes?

Right. So, let result = numbers .iter() .map(|n| normalize(transform(*n))) .collect(); result = numbers iter() map (|n| *n transform normalize) collect(); If I'm getting my conversion right, the major benefit here was getting the right order of operations from the subcall: transform -> normalize. That to me is a win. But then, log_print(a, b, calculate(a, d), "test", e); Took me a while to reason through this (which in itself is already a problem, I should think): a log_print (b a calculate d "test" e); Tell me if I made a mistake and how on earth us that more readable that normal function notation. Also, how hard is it in both examples to distinguish from variables and function names?

Ok. Let's clarify, because I'm not sure what you did there. What notation are you using? And is `ns` a function call? Where are the arguments for the second example?

Well, for infix I could imagine a few scenarios. Functions with multiple arguments, argument expressions or function pointers. Function calls being used inside a larger expression. Function chaining.... I mean, as soon as you start having more complex expressions, no matter the method you choose you will reduce readability. And at that point it becomes a matter of deciding which method is more readable for the semantics of the operation (function call, function declaration, arithmetic expressions, object declaration, ...). Consistency here in my opinion would be a mistake. Because these methods don't really intersect, except in very few instances. This would leave you with a method of choice that would be consistent across the entire source file, but which readability would suffer across larger areas than the one that benefited from it.

Sneaky! 😂

But to what end? I'm not convinced unifying the syntax will bring simplicity. RPN, PN and infix notations share different advantages are disadvantages. As soon as you move away to more complex expressions, the beauty goes all away. If you make everything PN, it will be great for chaining operations, but will suck for everything else. RPN will be great if your compiler is stack-based and nothing else. Infix is great for arithmetic expressions but will suck at function calling.

Ah, damn! I was just getting ready to donate $200k to your project. Will have to go somewhere else then.

Just as Kimi announced its new open weights model. No "there's a 30% chance AI will kill mankind", no "this is too powerful to release", no "we need to regulate AI", no "people will lose their jobs". Just here's our new model and some stats for your enjoyment beating Fable. Chinese models seem to be the only adults in the room.

Much less scary to use than the shit Antropic has been saying and doing. Welcome China to the world of open AI for everyone. We the world thank you! Now slash those prices or review those plans offerings. Sheesh!