This month saw the release of the long-awaited version 1.0 of Julia, the self-described “language for greedy programmers.” Why greedy? As cited from the language’s 2012 debut, the goals the Julia team set for themselves were lofty, to say the least. They are worth repeating here:
“We want a language that’s open source, with a liberal license. We want the speed of C with the dynamism of Ruby. We want a language that’s homoiconic, with true macros like Lisp, but with obvious, familiar mathematical notation like Matlab. We want something as usable for general programming as Python, as easy for statistics as R, as natural for string processing as Perl, as powerful for linear algebra as Matlab, as good at gluing programs together as the shell. Something that is dirt simple to learn, yet keeps the most serious hackers happy. We want it interactive and we want it compiled.”
As you can see from that initial wish list, one basic idea behind Julia was that they no longer wanted to compromise performance for ease-of-use. So, the question now is — did they succeed? Or, as an article in Quartz asks, should data scientists using R and Python switch over to Julia?
Of course, keeping in mind Betteridge’s law of headlines and the general rule of thumb when it comes to adopting new technologies, the answer is likely some combination of “obviously not” and “maybe for some things but not for others.” While Quartz points out that Julia is faster than Python and R, it also notes that “if processing speed isn’t important to you, Julia is probably inferior to whatever product you are using — at least for now.” They also mention the simple fact that, as a yet-to-be fully developed technology, “Julia is behind Python and R in terms of tools for debugging and identifying performance issues.”
At the same time, it certainly looks like Julia is turning some heads, with more than two million downloads, customers like the New York Federal Reserve, and an apparently surging popularity in China. If you find yourself considering leaving behind Python and R for the new girl on the block, here’s another article that gives a point-by-point comparison between the languages, definitely siding with Julia.
Really, though, is there ever a simple answer to a question like this? Choosing a language is always some blend of project requirements, language performance and features, and personal preference. Surely, we’ll watch Julia rise through the ranks as time goes on. Whether or not it replaces steadfast and stalwart languages like Python and R, well, that remains to be seen.
This Week in Programming
- Twitter Is #SorryNotSorry for #BreakingMyTwitter: ProgrammableWeb writes this week that Twitter explains #BreakingMyTwitter, but I would venture that my heading would be more accurate. Citing an internal email and public post from Twitter’s Rob Johnson, they write that since “the developers using [the User Streams and Site Streams APIs] were among the most prominent members of the company’s ecosystem, it would appear that Twitter was intent on breaking up with them, backlash be damned.” The article ends by asking if developers will “continue trying to create meaningful apps using Twitter’s APIs” or if “Twitter’s developer ecosystem [is] dying a slow, intentional death,” and I find myself wondering just how many chances the company could possibly have. I mean, it’s not like I was writing about this same exact situation years ago or anything like that…
- The Modules Cometh in Go 1.11: Perhaps you remember the hubbub around the introduction of the new vgo package versioning that was first announced back in February and formally accepted back in May? Well, with the release of Go 1.11, modules will get experimental support. So, it looks like it’s time for the rubber to meet the road and software developer Roberto Selbach offers a step-by-step introduction to go modules, leaving the internal debate in the past and focusing instead on how semantic versioning is going to work in Go moving forward. The post looks like a must-read for anyone committed to continuing on with Go.
This is the third major rant or rebuttal to Go modules I’ve seen in the past two weeks. The only constant seems to be that Russ Cox doesn’t listen to anyone that doesn’t absolutely fall in line with his opinion. #golang https://t.co/sq9NM51njW
— Dahs81 (@Dahs81) August 18, 2018
- Fascinating, Historical Programming Tidbits: And to wrap this week up, we have a couple of articles that explore some of the fascinating history in the world of programming. First up, from our own pages, David Cassel takes a look at Vim, a text editor for the ages, exploring the slow migration from one extremely short-named editor to the next, until Vim was born — a name that increased the name length over previous editors by 50 percent. It’s a great read that explains Vim’s various quirks as part of a program “written for a world that doesn’t exist anymore.” Next, going further back in time another 150 years or so, the TwoBitHistory blog asks what did Ada Lovelace’s program actually do? The post takes the reader through the progression of mathematical thought leading up to Lovelace’s program and even goes so far as to translate it into C.
— USC Learning (@usclearning) August 24, 2018
Feature image via Pixabay.