ninjaaron

The original Rust compiler was written in OCaml, and OCaml was one of the chief design inspirations for the language. The similarities between Rust and ML-like languages is no coincidence.

> To me, the second is both more charitable, and more in line with what I think Rob Pike's background and experience would have exposed him to.

More charitable to Rob Pike, rather than to the person you're in the the middle of a conversation with.

Anyway "appeal to authority" is not an argument, it's a religion. Our lord and savior, Rob, knows so much that his design decisions are beyond question.

There are some animals that don't do anything like a human definition of sleep. Some sharks, for example, who have to keep moving all the time.

Probably any computer-based metaphor we come up with for sleep is going to be crap because brains are not similar to computers, and it is unclear how they work. We don't even know exactly why sleep is necessary.

In a purely functional language, functions apply inputs to a single expression to produce an output (though there is usually a way to add some declarations inside the function to keep the expression from getting to hairy). Side effects are possible, but they are wrapped up as values that still have to be passed around as functions and possible errors must be handled.

"Purely functional" means that pure functions are not only possible, but that they are the only kinds of functions in the language.

While it might be theoretically possible to write purely functional code in Go, it doesn't have mechanisms for treating side effects as values, and the heavy reliance on arrays and channels and things would make it unnatural. Pure functions don't contain loops because a loop is only used to generate side effects. That would be hard in Go, but it's pleasant in languages that support pure FP.

If this explanation sounds weird, learn some Haskell to get an idea of what pure FP is like. It's fun stuff.

You have not because you ask not.

https://xon.sh/

Why is web assembly a desirable target? Wouldn't it make more sense to use LLVM IR or something that can go down to native? It don't get why, if you're compiling down to such a low level anyway, you'd want to target a bulkier runtime like wasm.

I also don't really understand why you'd want more than one language in the shell, but I guess if you wa

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.)

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.