For those unfamiliar with it:
I've watched it for a bit, and overall I'm liking it. It mixes and matches the best and worst of a number of other languages.
I'm not sure I'm wild about the lack of an implicit block opener ('begin' or '{') but the use of 'end' is good. I prefer words over symbols -- but again I'm a wirth guy. Even so the syntax feels solid as it removes a lot of 'pointless stuff' so common to the C syntax legacy that so often hobbles other languages.
The triple quoted strings that automatically 'de-indent' in the output might be nice for writing server-side HTML that's nice and formatted, but outputs with a decent amount of whitespace stripped. Switching between minified and not minified becoming as simple as switching between single and triple.
Optional typecasting is something that's only just starting to emerge into ECMAScript, that really gives you the best of both worlds. When for security and performance reasons you want strict typecasting it's available, but when the data you're working on could be any type it can do that as well. That gets a thumbs-up from me as I PREFER strict for most things, but recognize there are places it is just easier to have loose/dynamic variables.
About my only real complaint so far is that it allows for 'on the fly' variable creation and is a bit of a wonk on how scope works... but I'm a big fan of forward declaration since it tends to just reduce code errors and provide a degree of clarity. Block-level scoping is most always just a train wreck in terms of memory thrashing and code comprehension.
Performance-wise it's no slouch either, but it's implemented with LLVM so that's kind of a given.
Anyone else here given it a try and/or started learning this one yet?
I just compile Kotlin code with LLVM, gives me native-like performance too. Optional typing is just weird, prefer type inference.
Julia does look interesting though, might be a good replacement for a lot of stuff that i use Python for, especially the scientific packages.
Mark
formerly known as M
I've only watched it a little.
When I did numerical/scientific programming, I used Fortran, Matlab, R and numpy. I think Julia could be a step up over those, for different reasons. I wouldn't use it outside of numerical/scientific computing though, which is why I haven't tried it much yet.
One 'rare' feature in big languages that I found interesting was that it has multiple dispatch. Conflicts a bit with its performance goals, perhaps, but nice to explore.
(It seems 'rare' to me, I guess lisp and perl were/are pretty big but I've never tried either).