One aspect of familiarity, incidentally, is being able to hire junior devs. I see that as being a problem with Go -- and, in the future, Rust -- not to mention rocket-scientist languages like Haskell, Ocaml or even Scala, or indeed C++. Go is "simple", but not really that simple, not compared to Ruby or Python. (Of course, this might not be an issue for Blow, whose company is already using C++.)
While Blow was originally talking about safety not being a paramount issue, I believe he has mentioned ownership-lifecycle management, possibly something like Rust's borrowing, as being on his mind.
- Module system
- Optionally avoiding complex build systems (rdmd or dub)
- Fast build times
- Type inference
- Nested block comments
- Owned memory (Unique, Scoped, RefCounted)
- All variables initialized by default
- Anonymous or strong enums
- Specify enum type (inferred by default)
- Order independent symbols
- Scope guard statements (more powerful in D though)
- Locally defined functions
- Built-in dynamic arrays
- Parameterized types (doesn't work in his language yet but he says it's coming)
- Compile time function evaluation (only side-effect free code though so no playable space invaders at compile time)
- Complex checks using compile time function evaluation
- Generate code at compile time and mix it into the program itself
I like where his language is headed but I'm not convinced we aren't already there. I guess I should go back and listen to his other talks to see why he's unsatisfied with Rust or D.
http://www.reddit.com/r/rust/comments/2gwi11/jonathan_blow_i...
He specifically says that Rust "cares too much about safety" and that satisfying its safety guarantees adds too much friction to development. Some of the Rust programmers in the thread acknowledge that the safety/friction trade-off for games may be different from, say, OS kernels or web browsers.
He also notes that Rust is new and still needs to prove itself, which I don't think anyone will disagree with.
That's true, but I don't think making a new language avoids that problem.
But closures have different semantics to functions, both in representation and in execution. The semantics of his language becomes even more confusing when he says that items at the top level are position independent, where as it seems that those in a function scope are, and yet they share the same syntax. There is a simple fix though. Just keep a uniform syntax for position independent items, but allow them to be declared at any scope. That is exactly what Rust does.
Personally, I'm all for having different syntax for different semantics.