It has something like defmacro, from my understanding.

You're entirely correct; I'm blind. That makes sense.

Didn't Verhoeven famously not read the book? Hard to call it "satire" then, "straw man" might be more accurate.

Perhaps less famously, Edward Neumeier wrote his screenplay.

I hadn't heard that before but I agree with you, it doesn't qualify as satire if he didn't even bother to consume the source material. At least not in the literary sense.

On the other hand, you have games like Borderlands that force you to finish the game once (or even twice) to unlock an "acceptable" level of difficulty (via lazy bullet sponge metamorphosis).

Same with Bioshock Infinite that needed a hack to unlock "1999 mode" or Bloodstained its harder difficulty (still easy, though).

Balance and fair difficulty really are some of the hardest and most important things to get right in video games.

It's well deserved. The bell curve isnt a good work of science.

Thing is that experiencde programmers must start at "junior" like any other...

You’re not wrong, but there’s a glut of junior developer talent at the moment that there’s no shortage of folks to take on those most senior roles. This this is a “tomorrow” problem that (for better or worse) will get ignored for now

I suppose the question is whether the only way to educate good programmers is for them to spend time as a (possibly net-negative) apprentice in an enterprise job. Perhaps under the watchful and patient gaze of future AIs, they're able to blossom earlier, perfect their skills on open source, and enter into the workforce ready not to cause chaos. Personally I'd love the alternative version of the future where LLMs do all the bullshit (meetings, alignment, planning) and then seniors feel far less stress and pressure and rejoice in being able to spend time raising up their fellow humans.

Not sure either outcome is likely though.

No, macros run at compile time (cf https://www.lispworks.com/documentation/HyperSpec/Body/03_bb...), you may be confusing macros and reader macros.

Fair that I was definitely mixing them in my thinking. My general point was supposed to be simply that "compile time" is probably not what people are thinking of when coming from other languages. I was clearly a bit too eager to try and say that, though. :(

People having lived through one or more eternal Septembers are the reason you don't hear about them much. And also because there are few such places that haven't succumbed to the mainstream politics mind virus.

Don't want to sound too snarky, but aren't you just saying that good denoisers must be temporal in addition to spatial? Something like an improved V-BM3D (cf https://arxiv.org/abs/2001.01802) and even traditional V-BM3D works fine even on non-Gaussian noise.

Together with external noise generation (something like https://old.reddit.com/r/AV1/comments/r86nsb/custom_photonno...) that'd support external denoising (pass the reference and denoised video to get the grain spec), the whole FGS thing would be much more interesting.

>God, Lisp...the core language isn't exactly that interesting in this day-and-age. Dynamic typing, garbage collection, anonymous functions, this has been the bread-and-butter of Python, JS, Ruby, etc.

CL still got symbols, the reader (and its macros), gradual typing and user available runtime compilation (compile and compile-file).

I find the core language itself near perfect (mostly the historic stuff like threads/atomics/unicode missing, the whole divide between normal CL and CLOS and lack of recursive and parametric typing") but the standard library quite baroque and lacking; still infinitely more serviceable than C's, though.

(to be clear those historic stuff are present in today's implementations)

JS Symbols are like CL gensym and CL symbols (interned strings) don't exist in JS.

Normal TS doesn't expose normal macros or reader macros to the user.

JS runtimes don't have the image introspection ability of CL.

TS types are removed before the JIT and don't actually impact performance (not to mention they encourage polymorphism which is actively BAD for JS performance). CL type hints are use by the compiler to actually speed up the output code (quite dramatically I'd add).

Really? You can `(compile nil my-lambda)` without having to write a JIT yourself?

I meant reader macros, by the way: can it do that?

  ; A comment
  (set-macro-character #\% (get-macro-character #\;))
  % Also a comment

Sure.

    new Function(“…”)

There’s no guarantee that it will be JITed, but then the CL standard is also pretty loose about the semantics of ‘compile’.

I must admit, I don't know what this is doing, and why.

The semi-colon symbol is the single-line comment symbol in Lisp, but the percent symbol means nothing special in Lisp.

SET-MACRO-CHARACTER is used to modify what happens when certain characters are found while reading code. In this case, SET-MACRO-CHARACTER is being used to instruct Lisp to start treating % as if it were a semi-colon (i.e. the third line is a comment), thus extending the syntax of Lisp on-the-fly.

The (GET-MACRO-CHARACTER #\;) portion could have been any code at all; GP could have defined % to do anything, such as "treat the remainder of this line as if it were a line of Python code", using calls to a Python implementation, such as cl-python [0].

[0] = <https://github.com/metawilm/cl-python>

who is using macros in ts ?

The quite cool journey of a hacker trying to find his favourite SSG itch scratching position.

What inspired me to post it is that I cobbled a fun HTML preprocessor using cpp to someone today: https://git.sr.ht/~q3cpma/html-cpp (I use a Common Lisp contraption for myself).