Is Julia the Next Big Programming Language? MIT Thinks So, as Version 1.0 Lands (techrepublic.com)

Julia, the MIT-created programming language for developers "who want it all", hit its milestone 1.0 release this month -- with MIT highlighting its rapid adoption in the six short years since its launch. From a report: Released in 2012, Julia is designed to combine the speed of C with the usability of Python, the dynamism of Ruby, the mathematical prowess of MatLab, and the statistical chops of R. "The release of Julia 1.0 signals that Julia is now ready to change the technical world by combining the high-level productivity and ease of use of Python and R with the lightning-fast speed of C++," says MIT professor Alan Edelman. The breadth of Julia's capabilities and ability to spread workloads across hundreds of thousands of processing cores have led to its use for everything from machine learning to large-scale supercomputer simulation. MIT says Julia is the only high-level dynamic programming language in the "petaflop club," having been used to simulate 188 million stars, galaxies, and other astronomical objects on Cori, the world's 10th-most powerful supercomputer. The simulation ran in just 14.6 minutes, using 650,000 Intel Knights Landing Xeon Phi cores to handle 1.5 petaflops (quadrillion floating-point operations per second).

Comments

Translation

[TimMD909]

Is Becky's baby the cutest baby in the entire world? Becky thinks so, as Birthday 1.0 arrives.

Obligatory Betteridge's Law Post.

[king neckbeard]

Obligatory Betteridge's Law Post.

Re:Obligatory Betteridge's Law Post.

[ilsaloving]

To save people effort googling:

https://en.wikipedia.org/wiki/...

Re:Obligatory Betteridge's Law Post.

[TranquilVoid]

To save people the effort of opening a new tab;

Betteridge's law of headlines is an adage that states: "Any headline that ends in a question mark can be answered by the word no."

Let's make something to meet everyone's use cases!

[kalpol]

https://xkcd.com/927/

Great..

[Anonymous Coward]

Great... Just what we need... another language.. oh wait, that will need a new package manager.. and new frameworks.. and..
screw it I'll just stick to C++.

Re:Great..

[jellomizer]

Having languages to choose from is a good thing. Saying Julia is the perfect language may be pushing it, because it may be the perfect Language for MIT, and research and education. It may not be a good language for businesses who may want more CRUD applications, and/or Heavy Database work and reporting.
Julia seems to trying to compramise on the fight within MIT whose better. C++,Python, R and Ruby (Currently the most popular languages Outside of Java* ). They basicly took the key strengths of the different languages and combined it into one. However... Python, R and Ruby while slower then C++ are interpreded lanaguges which has its own benefit, of working better across platforms, and not needing to recompile code, and having your source magically go away from you, with the executable running for years afraid to upgrade.
 

Take A Look At Crystal

[Bruce Perens]

There is always going to be argument about which language is the best, which Linux distribution, which web framework, and systemd.

I have been using Crystal and the Lucky Web Framework for a large project, and it's been great. Crystal's handling of types, and the fact that you get all of the error-killing power of tight typing while you often don't have to specify the types at all because they are inferred, has make my code cleaner and easier to write, with fewer bugs and less need for testing. You write it like an interpreted language (it follows Ruby syntax, but treats typing and metaprogramming differently) and it has compiled speed (uses LLVM).

Re:Take A Look At Crystal

[Desler]

it follows Ruby syntax

That's supposed to be a selling point?

Re: Take A Look At Crystal

[Bruce Perens]

Would you rather that white space had syntactic significance? I only know two programs where that's the case: make, and python. And even the author of make was clear that was a mistake. Guido is a nice guy, but he really blew that one.

Re:Take A Look At Crystal

[farble1670]

I have been using Crystal [crystal-lang.org] and the Lucky Web Framework [luckyframework.org] for a large project, and it's been great. Crystal's handling of types, and the fact that you get all of the error-killing power of tight typing while you often don't have to specify the types at all because they are inferred, has make my code cleaner and easier to write, with fewer bugs and less need for testing. You write it like an interpreted language (it follows Ruby syntax, but treats typing and metaprogramming differently) and it has compiled speed (uses LLVM).

I'm sure your employer (or contractor) is ecstatic about the fact that they'll have to pay 3x the going rate to find devs that can work on the project you've built. Well actually that's not true. They'll have to pay someone to completely re-write the project when they can't find anyone to work on it and / or the niche framework you've picked is no longer supported / evolved.

Maybe it was a pet project though.

Re: Take A Look At Crystal

[farble1670]

Your viewing this from the perspective of the sort of programmer who is hired like an interchangeable cog.

If you are telling me that you develop in a way that isn't easily picked up by another engineer, I don't think you are the master you think.

Software engineering is... engineering. That means it's well documented, easily understood standard practices. Part of that is choosing a language, toolchain, and development environment that is stable and well understood.

They are probably more concerned with time-to-market than anything else.

Probably? So you explained it to them right? They probably don't understand the implications of your choices.

Re: Take A Look At Crystal

[jd]

Occam is also whitespace sensitive, as part of the logic for determining design bugs. I don't mind it, although it's not everyone's preference. Occam is one of the few languages in which programs are provable, so I'm careful about arguing about design defects.

No.

[xtal]

C is lightning fast and is the tool for when you know what you're doing.

Python is .. for everything else.

Everything else just turns into a clusterfuck over time. C and Python have somehow avoided turning into clusterfucks by being simple, while building an unstoppable freight train of reference work.

Julia solves lots of problems in a specialized domain, but most programming is laughably mundane.

Re:No.

[Anonymous Coward]

Python is a clusterfuck. Not enough people recognize it in time.

Re:No.

[fahrbot-bot]

C is lightning fast and is the tool for when you know what you're doing.

Python is .. for everything else.

So Python when (a) you don't need fast and (b) you don't know what you're doing. :-)

[ And when you don't want C, but want fast and you know what you're doing, use Perl. ]

Re:No.

[serviscope_minor]

C is lightning fast and is the tool for when you know what you're doing.

C is a lightning fast tool for people who are obsessed with micromanaging things which can be easily automated. If yu want lightning fast performance (often faster) but don't really want to do things by hand that a computer can be easily taught how to do then there's C++.

Everything else just turns into a clusterfuck over time. C and Python have somehow avoided turning into clusterfucks by being simple

C moves the complexity of the language into every single project that uses it. So the language per-se might not be a cluster fuck, but it is the epicentre of a custerfuck of biblical proportions.

Re:No.

[fortytwoQAM]

TL; DR: There are a lot of great and nuanced features of Julia, but if you're writing off Julia without understanding the potential power of "multiple dispatch", I'd really encourage you to read up on multiple dispatch and its benefits. Also, if your programming is "laughably mundane", watch out that a machine or machine-learned model doesn't take your job. I'm surprised this got upvoted to a 5. One of the aims of Julia is to 'solve' or 'avoid' the "two-language problem". Interestingly, you just embraced the two-language problem. You can call and use C-code from Python, but that's not necessarily simple. At that point, anything that is "fast" from a computational standpoint now needs someone who's expert at both languages to provide functionality. Most Julia packages provide "fast" code, while allowing any Julia user to help and fix things by learning Julia - i.e. the "one-language satisfaction" ? Julia code is generally "fast" while being very "expressive" - i.e. an aim at trying to avoid the 2-language problem. Crystal looks very interesting and is an "LLVM-language" like Rust and Julia, but I don't see any mention of "N-Dimensional Arrays". To quote another poster, "dealing with ND Arrays with for loops is like pulling teeth". Python has NumPy, but all the good syntax was taken by the time NumPy came along (mid-2000s), so the ND Array syntax can be quite cumbersome with Python, as much as I like the NumPy/SciPy stack. I've been working almost exclusively with Julia over the past 3 months. I'm parsing large-ish (~1GB) binary files generated by arduino boards and a lot of signal analysis work. I'm absolutely loving it, but Julia has been on my radar for a few years now. A few years ago I did a bunch of the Euler challenges with Julia while trying to write as little code as possible and that was a fun exercise to see how powerful some of the syntax is.

To quote Julia (Child)...

[The Original CDR]

Quote: "These damn things are as hot as a stiff cock!"

Full unicode variable names are a mistake

[presidenteloco]

I can see perhaps adding some greek symbols to ascii for variable names, function names, but allowing full unicode is a disaster of a design decision since it permits all kinds of deliberately obscured code.

Languages need to be about well-chosen constraints to guide creativity, not about absolute freedom. Libertarian languages are a bad idea, since code is maintained and extended collectively.

Unicode for string data, yes, of course. But entity names in the language, no, no, no.

Re:Full unicode variable names are a mistake

[serviscope_minor]

I can see perhaps adding some greek symbols to ascii for variable names, function names, but allowing full unicode is a disaster of a design decision since it permits all kinds of deliberately obscured code.

do they allow full unicode. C++ allows unicode[*], but it specifies which character ranges within unicode can form part of an identifier. So you can have a poop emoji as an identifier, but not a thin space.

[*] which is to say it doesn't and does sort of, in the most C++ish way possible. C++ is defined in terms of a character set and it specifies which ranges in that character set. the character set is not specified, but the ranges look suspiciously identical to unicode ranges. How the compiler goes from the source encoding to the language encoding is implemention defined (outside of plain ascii, and \uXXXXXXXX to get higher range characters). So clang supports poop emoji as an identifier which is conforming and GCC doesn't which is conforming too.

Re:Julia?

[fibonacci8]

I z^2+c what you did there.

A good Matlab replacement, not the next big thing.

[jma05]

If MIT had been having its way, we'd all be using Scheme.

Julia is a better Octave (open source Matlab replacement) - good for computer scientists, but software engineers will not be interested. Question is, will the scientific community create enough definitive libraries to provide alternatives for Matlab toolboxes. Not enough seem to have attended the Octave party.

Also, computer scientists don't define popular adoption of programming languages. Else, we'd be using Haskell/Scheme by now.

Okay. Let's do this ...

[fahrbot-bot]

... for developers "who want it all" ...

I want: local/global "goto" operations; unchecked pointers and arrays; brace *and* white-space (for you Python freaks) block delineation; weird operators like "+-+", "=!=", "-+/*" and "..."; support for casting on the *left* side of the assignment (ya, I did that on 4.3 BSD w/K&R C); random requirements for some variable to be in UPPER case and/or start with specific letters (for you FORTRAN fans) ...

Feel free to add to this; I'll be back after I get a fourth cup of coffee.

Re:Okay. Let's do this ...

[Kjella]

Well "..." is the spread operator in Javascript, here's =!=, it seems plausible that "+-+" might be interpreted as x+(-(+y)) which collapses to "x-y". Not sure about -+/* but Ruby should get a honorable mention for %/%. The most annoying thing about operators though is not each one, it's the precedence rules. For example in SQL "WHERE a OR b AND c = 1" when you mean "WHERE (a OR b) AND c = 1. I really, really wish some smart language would say "fuck that, we're not making obscure rules nobody remembers/notices are invoked" and just throws a syntax error, here's ambiguity so resolve it explicitly with parentheses. That would be the sane solution for all future maintenance. Also I'd like to ban the singular "=" operator, use "==" for comparison and ":=" for assignment, you can keep the mixed ones like "+=".

Four cups of coffee

[maroberts]

..are you having a day off?

MatLab eh..

[volodymyrbiryuk]

the mathematical prowess of MatLab

Like arrays starting at index 1?

Re:Why?

[jma05]

It is the only array programming language with a decent JIT.
It is a high-level array programming language like Matlab/Octave/R, while executing at about the speed of a native language like Fortran.
If you prototype a lot of linear algebra functions in an interactive environment, this is the language for you. The thunder is somewhat stolen by newer tools like tensorflow, which give you GPU performance, while still providing a high-level language (Python).
Still, Julia has meta-programming features. So it can deliver compact, high-performance mathematical code.

Language should guide you to good practices

[presidenteloco]

and try to limit the egregiousness of bad code.

One example. Languages should probably enforce the presence of a method header comment.
If you still choose to make it a useless comment, you're just advertising your complete misfit / incompetent status.

Language made it easier to do the right thing and harder to do a bad practice.

Same goes for meaningful indenting enforcement. It's a good thing, because it doesn't hurt, and encourages comprehensible code.

The freedom you NEED as a programmer is freedom to
- organize the order of your ifs, loops, and subroutine calls,
- choose names, although that should be limited to a limited character set and probably enforced case and/or underscore conventions.
- create arbitrary hierarchical data structures.

You actually NEED no other freedoms than that.
And the fewer extra freedoms you get, the less you will completely screw up the experience of others trying to read and understand your code.

R.I.P. Python

[Anonymous Coward]

Python 2.x to 3.x incompatibility is a total clusterfuck, and it's why I left the language.

At this point I only trust people if can define their language up front in a way that can be safely extended and hopefully standardized. I'm not going to muck with Python again only to have it break in some version 4 or version 5. (Yes, I still have code in production with K&R prototypes even though ANSI C has been around for nearly 30 years.)

Languages that offer useful pure functional programming are the future when it comes to massively parallel projects. The next big thing is going to be related to ML, Haskell, or OCaml. But it's a damn shame my old C skills make me no good at these languages.

So I'll probably have to retire once a proper programming language comes around. Lucky for me nobody seems to be doing a very good job at making me obsolete!

Cat

[DrYak]

...but why {...} ?!? {...} the syntax looks like the bastard child of Fortran and Perl

Because since Python started overtaking Perl, my cats are sad because they can't write fully compliant programs just by random walking across the keyboard anymore.

I would like

[tgibson]

the readability of Perl with the brevity of COBOL.

HR Posting

[sycodon]

Technologically aggressive company in the expanding AI and Scientific arena is looking for experts in Julia.

Must have at least 5 years hands on experience building applications with Julia in multi-core, machine learning applications and simulations.

Julia is Hot

[BrendaEM]

Nearly seamless multitasking over an entire network.

Re:The "dynamism" of Ruby?

[jma05]

Once you get over your newbie tunnel vision with the block syntax, you will find that Julia is a compact (despite the ends), powerful, high-performance, array language with meta-programing features.

No, it is not an academic language like say, Haskell. It is a practical programming language for research into math-heavy algorithms - Artificial Intelligence, Signal Processing, Image Processing etc.

No, it is not a general purpose language for day-to-day scripting or web/business programs. It is not, as you put it, for "bootcamp coders".

"want it all" refers to the historically diametric needs of computer scientists. They need a high-level, expressive, vectorized language like Matlab to prototype and interactively explore data... and a high performance language like Fortran or C++ to implement that algorithm after, on the fastest supercomputers. This gives them both in one tool.

It sounds like your never wrote any significant matrix/math code in your life. Writing any complex matrix code with just loops is like having one's teeth pulled, compared to how it is done in an array language like Julia. The block syntax is the least of one's worries when dealing with high-dimensional data.

1-based arrays

[dbrueck]

I read through the docs and was really liking what I was seeing... right up until the part that it says arrays are 1-based. Ah well, nevermind then.

Re:Convolution Evolution

[nmb3000]

Just try to do reflection on nullable C# types, for example. It's a WTF moment. When you investigate why it's that way, you learn that nullable types are an ugly hack on top of the existing dynamic type sub-engine.

In what way? Aside from some magic around implicit type conversion, Nullable types were added to the language through the Nullable<T> generic struct and some new language syntax to support the int? syntactic sugar (instead of Nullable<int>). Detecting and reflecting on a nullable type is just a matter of using Nullable.GetUnderlyingType(Type), or if you want to do it the long way you can always use the IsGenericType, IsValueType, GetGenericTypeDefinition(), and GenericTypeArguments on the Type of the thing you're looking at.

There's nothing dynamic about nullable types in C#.

Re: Human Resources

[jd]

Address: 147 Rassilon Way, Gallifrey.

Years of experience with Julia: 729