As mentioned, the goal is for it to be a general purpose language with a scientific focus:
Scientific language - It already has that down. It's easy to do mathematics with it, it's fast to prototype algorithms, and the code has very high performance. This is what most scientists are looking for. Generous language- ? Scripting language- Because of the foundations of Julia, it has become by default a good scripting language. It by default handles unicode well, has really good interop, can solve tedious tasks succinctly with metaprogramming and multiple dispatch, and once again is fast. There are still some major improvements here, mostly related to startup compilation time (static compilation) and reducing the bloat of the base library. These are planned to be fixed up before 1.0. Easily scalable language- Julia has features which other scripting languages don't which is useful for scaling. For example, even though it is dynamically typed, one can (and should) add type declarations to make library code basically be statically typed. In addition, the parallelism is built directly in the foundation of the language, making it easy to scale to larger systems, computers, and problems. So the goal of Julia 1.0 is to be an insanely powerful and flexible language that will be easily to prototype and deploy on large-scale problems (large-scale has always been the goal due to the focus on performance). It might be better then to try to understand what Julia is not. I would say Julia is not a language which is trying to be simple. Rather, it is a language which is trying to be syntactically simple, but at the same time very deep in its features. So while Julia's code may look simple, it's front page says things like "LLVM-based Just In Time (JIT) compiler", "Lisp-like macros", "Unicode", i.e. things that more experienced programmers would find enticing, but are certainly not phrases targeted at beginning programmers looking for a first language. In fact, if you go look at online "critiques" of Julia, most of them are about the fact that the language is so powerful yet so syntactically simple, that experienced developers can work too fast for mere mortals to comprehend (I'm not even joking, this has been mentioned a lot). This can make the language intimidating to beginners. However, I believe that this issue will be defunct when Julia becomes more integrated with undergrad education. Right now, schools are confused about trying to get people started with a scripting language (usually Python) because it's easy, but then switch to C/Java to teach about more core computational ideas. Julia has it all; you can teach it as dynamically typed, then teach what static types are via decalarations, how to do things object(/type)-oriented, do some metaprogramming/functional programming (Lazy.jl), implement data structures, do some documentation and unit testing, parallelism/MPI, teach some LLVM and how to read assembly... again, it's insane how deep you can go. I am sure the math departments will join in once they need new MATLAB licenses, and with CS/Math departments unified many science departments will follow suit (or they may even lead). Give it 10 years. On Thursday, May 26, 2016 at 4:25:49 AM UTC-7, Ford Ox wrote: > > How should be julia 1.0 seen when it is finished? > > Purpose: > Scientific language only? > Generous language? > Scripting language? > Easily scalable language? > Add yours... >
