[unknownsavage]

The lisp quickstart is indeed one of the key advantages of lsip:

    $ time sbcl --script hello.lisp 
    Hello World!

    real	0m0.026s
    user	0m0.009s
    sys	0m0.013s

Compared with languages with a much bigger starting curve:

    $ time node hello.js 
    Hello World!
  
    real	0m0.113s
    user	0m0.052s
    sys	0m0.022s

[pjmlp]

And you can AOT compile your Lisp code to pure native code, try that with JavaScript.

[TeMPOraL]

Maybe a stupid question, but is AOT a new name for what just few years ago we used to call "normal" compilation?

[nickpsecurity]

No, lol, it's exactly normal compilation. It's a buzzword that differentiates languages without normal compilation (esp using VM's or interpreters) from special implementations of them that do support that. The latter have "AOT" compilation. Wikipedia states the difference is AOT compiles the bytecode of an existing VM. It's still just a compiler, though, given the end result is mostly the same.

[lacampbell]

Yeap. It's quite a common linguistic phenomenan, when a term like JIT stops being a fringe thing and enters mainstream discourse among an audience, what used to just be "normal" now gets a name.

"Imperative programming" might be another one. IRL, think about how "cisgender" has entered into mainstream vocabulary in the past few years, or "heterosexual" many years before that.

[jeff_petersen]

I suppose the contrast is with JIT compilation, which has a lot of mindshare now so it's valuable to make the distinction

[pjmlp]

Yes, because nowadays VM with dynamic compilation are a thing on mainstream computing, which used to be only available on mainframes or specialized hardware systems like those developed at Xerox PARC, DEC and ETHZ.

So ahead-of-time compilation, as linguistic term and CS literature, was born as a way to differentiate from dynamic compilation.

[eatonphil]

Maybe the point is that Javascript is JIT compiled?

[mbrock]

Not just AOT; you can also easily compile new functions at runtime, and then even serialize the entire program's state, including JIT-compiled functions, into a new compiled image that starts instantly.