Ashymad

Isn't the --include option basically that?

Yeah i meant the 2 causes that are lost. The other 2 are still in use

He wasn't saying that the engineers believe that in ontological sense. Rather he was presenting the difference in how we usually think about complex systems (i.e. the thermostat "wants" to keep a stable temperature). We abstract away the materialism we believe in because it's not practical and in a way we come back to the causes that aristotle wrote about, just metodologically not ontologically.

With vibe coding, one could even say that you can believe in the computer's intent to write the code and the code working through that intent. You might not even know how the code looks after all.

Your comment came at a right moment, right after my lecture in ontology yesterday where the proffesor presented the inverted casuality of a controller feedback loop as an example of a 2 types of causes described by aristotle that are lost in modern materialistic thinking, the formal cause and the final cause.

Great examples with the tea and the opamp for how a final cause be in the "future" of the effect, I'll remember them for the exam :)

Honestly I am not surprised. I imagine he wrote it quickly as this fun quirky look at the universe but then it got extremely popular, kurzgesatz video released and all. A lot of people based their personal beliefs off of the story.

Imagine you write a small story for fun but then it becomes nearly a religion. It must be a little frustrating for Andy.

But rust absolutely does not have any C/C++ compatibilty besides arguably very good FFI. And that's where zig shines. They have a c/c++ compiler built into the zig compiler via zig cc, that's even easier to use than clang or GCC due to having the benefits of a buildscript and baked in libcs for different architectures, making crosscompilation a breeze.

In zig you _can_ actually start with a c codebase and rewrite it file by file in zig and you _can_ include c headers in your zig files verbatim. Both of these are not possible in rust.

This milestone is only gonna remove the c++ (and objective c/c++) compiler for now from zig cc. So while you could argue this will ostracize people rewriting their c++ codebases in zig, I don't imagine there's actually many people like that. EDIT: I just looked at the discussion and there's actually a lot of people that use the c++ capapbilities.

I've tried glider for some time but it had a very unpleasant tendency to freeze my phone completely. I've since switched to Hacki which is really responsive and has similar swipe controls.

You got me. I was too lazy to implement the return stack. But it should be fully possible. The hardest part was not implementing things in the trait system, but parsing any non-trivial syntax using the clunky macro_rules!. For this reason if/else/then are not a special syntax but words that block and unblock subsequent word execution.

Indeed, could possibly be sped up by using typenum[1] instead of trait-eval, as it is not Peano axioms based.

[1] https://docs.rs/typenum/

The trait system and macros run at compile time and sadly there is no way to interact with the Rust compiler. However the macro is fully incremental (creating new words too). Which means in theory if it were possible to ask for input and pass it to the macro it would behave more like a VM:

  // create a word
  forth!(: inc 1 + ;);
  // ask user for $input
  type Stack = forth!($input inc return);
  // if you keep the stack around it can be used again
  forth!({ Stack } inc .);
  // should print $input + 2

Beautiful. With such advances on the frontier of Trait exploitation, soon most of the Rust language will become obsolete and everything will be evaluated on compile-time! It is the ultimate optimization. Just embed the most expected output values in the binary and run time calculation becomes redundant.

Yeah, but rather than "resistance from BSD community" I would call it "Pale Moon developers being huge d* * *s" https://github.com/jasperla/openbsd-wip/issues/86