Is there an equivalent modelling approach for earthquake prediction? A data repository for it widely shared on the same line as the top comment would work
This is exactly my thought, check the video I posted on twitter @serialdev , I was thinking of the usual loop unrolling , caching , vectorize , if with a managed Lang compile, check intrinsics and then even explore SIMD. I'm honestly impressed by ChatGPT
I see the appeal. But I gotta say to constraint yourself to only California or Rotterdam is kind of missing that hacker vibe that cares about results and content. Not just hype.
Specifically when learning and applying compiler development, advancing to more complex use-cases (code optimization, parallel compilation), programming language theory etc? Do you still use BNF Grammars with Parser Generators, or do you use Parsing combinators? Are you using a specified IR like LLVM's or if not why is that your choice? How do you deal with targetting multiple Architectures?
One difference is flow control. When you call a function, all the arguments are evaluated before being passed into the function. If you want to delay evaluation, you have to wrap the argument values in a function. When you call a macro, the text forms get passed with no evaluation.
Say Clojure forgot to ship with the boolean "or". "or" should evaluate its arguments one at a time (to allow for short circuiting) and return the first non-false value. You could do this with functions, but you have the source-level overhead of manually wrapping everything, and performance overhead of defining and passing an anonymous function for each argument. With a macro, at compile time you just translate the "or" macro into a simpler form that uses "if". This is how Clojure actually implements "or":
(defmacro or
"Evaluates exprs one at a time, from left to right. If a form
returns a logical true value, or returns that value and doesn't
evaluate any of the other expressions, otherwise it returns the
value of the last expression. (or) returns nil."
{:added "1.0"}
([] nil)
([x] x)
([x & next]
`(let [or# ~x]
(if or# or# (or ~@next)))))
