There are four guys credited as the creators of Julia, but the guy who sort of had the initial idea, Jeff Bezanson, is definitely a lisp enthusiast. He created his own dialect of scheme (like every lisp enthusiast), femtolisp https://github.com/JeffBezanson/femtolisp

This lisp is still used as part of the Julia parser.

Julia isn't really a lisp and it isn't trying to be, though it does have some things in common:

* AST macros

* everything is an expression and has a value

* while infix notation is supported for operators, they are just normal functions.

Still, the language is very much array-oriented and, as far as I know, there isn't even a linked list implementation in the standard library. It's a side-effect of trying to be fast. (pun strongly intended.)

For the uneducated among us who are considering learning Julia (and who have decent type system knowledge), where does Julia fall short for static type enthusiasts?

You don't have to declare types, but they are enforced when you do declare them. I'm not exactly how this is bad. Anyway, you can get into a scenario like you do with Python where type errors occur at runtime if you're not using a typed function.

I'm fine with it, as you might expect from the fact that I'm the author of the linked post.

Julia checks types dynamically. It's type system depends on the evaluation first. So any errors are catched eventually, but not on your desk.

This is only partially true. Almost all types are known at compile time because Julia was designed with static evaluation in mind. Many type errors are caught at compile time.