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.
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.
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.)
6 comments
[ 3.2 ms ] story [ 18.1 ms ] threadTbh, u think we kind of see a new generation here:
* Rust improved over C++ and C
* Julia improved over python
But if you take a closer look you see that neither actually approach the radical completeness of their actual competitors:
* Julia does not fully embrace its lisp heritage (I was told the developers where old lispers)
* Rust does not fully embrace Haskell's type discipline
So what do you think, is there enough room between rust and Haskell and Julia and lisp for yet another iteration?
I'm fine with it, as you might expect from the fact that I'm the author of the linked post.
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.)