Probably worth noting that the GitHub issue in question relates to work being done on Julia 0.5, a future release that is not yet ready to ship and won't ship for several months.<p>Within a few weeks, Julia 0.4 will be shipping, which is not focused on changes to arrays.
The "arraypocalypse" name is somewhat tongue in cheek, referring to the fact that this change will include some breaking changes. To provide some very brief motivation for the two most significant changes that are planned:<p>1. Array slices will create views rather than copies. This is just a matter of performance – although possible, it is currently way too annoying to write copy-free array code. This change will make it the default.<p>2. Slicing will behave more like APL: the rank of a slice of an array will be the sum of the ranks of the slices. This is a regular and powerful scheme, but sometimes at odds with how slicing works in Matlab.<p>These changes will make the language easier to write high-performance, general code, while, with some care not making linear algebra harder.
Could someone maybe tl;dr what is going on here?<p>I've tried out Julia a few years back, but didn't find it ready for serious use (yet). Am I right to assume that this means the language is still in serious flux?
I love Julia for its expressiveness but I am somewhat confused about its dynamic typing and its powerful type system. Are we to write mostly Python-like function and rely on multiple dispatch and JIT code generation for speed? Duck typing is one reason I stopped using Python for technical computing. I tried Julia out a few months ago and found that type inference has some holes that make type annotation brittle for function parameters. I finally gave up when I found out functions have no return type in Julia.<p>Hopefully Julia can work out all the language features and mature into a good technical language. It would also help if there is a guide about the canonical programming style. I prefer static typing but thought using type annotation I could come close to static typing while still retain the freedom of quick-and-dirty code. I believe for the current Julia I was wrong.
Is there any progress when it comes to the slow package loading times of Julia? That made it quite unusable as a data exploration language when I last tried it about 1 year ago, but perhaps there was progress in that regard.
I'll be glad once this is all implemented. I recently rewrote most of my functions that took abstract vectors and matrices to instead take concrete arrays along with a few index parameters. I did this because I realized SubArrays were making huge memory allocations inside the tightest parts of my loops for some unknown reason. Since I didn't want to spend days debugging that weirdness, I just took the simpler (but cruder) option of passing in the "kitchen sink" to each function.