
Julia v1.2 - ziotom78
https://discourse.julialang.org/t/julia-v1-2-0-has-been-released/27742
======
taliesinb
Bit late to the party here, but here's a thing that's been bugging me: as a
veteran of many deep learning frameworks, I’m 100% convinced of many of the
arguments put forward in "Tensors Considered Harmful" [1].

Basically, I can summarise the argument as: for complex, real-world projects
involving multidimensional arrays, having to remember which dimension means
which thing, and track these through various tensor transformations, is the
21st century equivalent of how prior to high level programming languages we
had to manually track which registers we we were using to store what
quantities, and how this changed in different parts of a program.

It was the real dark ages of programming, and we’re in that same place with a
lot of complex deep learning models now.

So my question is: has this been discussed at all in the Julia community? Is
this on anyones radar? Since one of the core competencies of Julia is array
processing and elegant metaprogramming, I would hope that it can gracefully
absorb the idea of named array axes in a way that feels natural and complete,
and could start showing up in ML frameworks like Zygote and Flux down the
line...

[1]
[http://nlp.seas.harvard.edu/NamedTensor](http://nlp.seas.harvard.edu/NamedTensor)

~~~
mcabbott
There are a bunch of packages exploring ideas around labelled dimensions,
although we are still far from the vision of caring as little as we do about
registers:

* [https://github.com/JuliaArrays/AxisArrays.jl](https://github.com/JuliaArrays/AxisArrays.jl) * [https://github.com/davidavdav/NamedArrays.jl](https://github.com/davidavdav/NamedArrays.jl) * [https://github.com/invenia/NamedDims.jl](https://github.com/invenia/NamedDims.jl) * [https://github.com/rafaqz/DimensionalData.jl](https://github.com/rafaqz/DimensionalData.jl) * [https://github.com/ITensor/ITensors.jl](https://github.com/ITensor/ITensors.jl)

While these don't pass dimension labels along in the type, there are also a
number of Einsum-like packages which should work on any storage order, and
could be taught to interface with such types:

* [https://github.com/Jutho/TensorOperations.jl](https://github.com/Jutho/TensorOperations.jl) * [https://github.com/under-Peter/OMEinsum.jl](https://github.com/under-Peter/OMEinsum.jl) * [https://github.com/mcabbott/TensorCast.jl](https://github.com/mcabbott/TensorCast.jl)

------
eigenspace
This release got delayed a bit but I think it was for great reasons and really
showcases the straights of the Julia community and core developer team.

My understanding (please correct my if I’m wrong somewhere) is that in Julia,
for releases which are supposed to be non-breaking such as 1.2, the Julia devs
run the test suites of every registered Julia package on stables versions and
then on their release candidate and then go through any regressions and
identifies any unforeseen breakages that occurred and then either fix them in
the Julia release candidate or if the package relies on an internal
implementation detail which is not guaranteed to be stable, they will often
try to help the package owners fix the regression. That’s seriously impressive
and while I’m sure it happens in other languages, I hadn’t heard of a
programme like that and thought it was worth mentioning here as the happy
reason why this release was delayed.

~~~
fluffything
This process is common for modern languages with modern tooling and that's a
good thing.

The Rust project has a tool called `crater` that can build all crates in
crates.io and run their tests, a process that takes a couple of days. It also
has a github bot that allows running crater on PRs on demand.

This is super super useful and something that all programming languages should
have. It allows you to:

* make sure that a new Rust release doesn't break code that compiled with old releases.

* assess the impact of a PR implementing a breaking change (e.g. due to a bug fix)

* obtain quantitative data about language usage for language evolution.

This last point is probably the most impactful. When I was working on C++, a
question like "How much people are doing X?" would often come up.

What did we do? Stakeholders in C++ meetings would travel back home, grep
their codebases for the X pattern, and report back 6 months later. And that's
it. That's all evidence we were hoping to get. And this was often super biased
due to different coding guidelines and styles in the different companies.

In Rust, you open a PR that makes doing X trigger a compilation error,
schedule a crater run, and get a list of all places in all crates in crates.io
where the error is triggered. This gives you quantitative information about
how often is X done in the wild, and you can then go and analyze the code
doing X and obtain even more information.

It's hard to convey how important this is. You'll never have to read
discussions about "I've never seen X in the wild" vs "I see X in the wild all
the time". Those discussions make no sense when you have a tool that can
actually tell you the answer. Every programming language being evolved today
should have something like this.

~~~
tsbinz
Don't you run into sampling bias this way since not everything is published on
crates.io? (I'm not saying that having that tool is a bad thing, just saying
that maybe that tool doesn't give you the actual answer ...)

~~~
dtech
There's no better data set, and it's not a big assumption to assume closed
source/unpublished code has roughly the same usage patterns.

------
dragonsh
Good work and keep it up.

A nice language for scientific computing after Fortran (some might hate it,
but I liked it during my CS studies).

I hope Julia succeeds like Python. I have been using Python for quite a while
for scientific computing, machine learning and as general purpose language for
web services development. I wanted to use Julia for some machine learning
problem for predicting prices (time series forecasts), but familiarity and
tool support of Python always kept me back and with Facebook's Prophet
(fbprophet) library I could do it easily.

I will definitely give Julia a try in coming months. I like this competition
and innovation in scientific computing.

~~~
vanderZwan
> _some might hate it, but I liked it during my CS studies_

Isn't a lot of the frustration regarding Fortran aimed towards libraries
written by PhDs who don't know a thing about writing maintainable code
(because that's not their specialty - not their fault really) and on top of
that are so intelligent and specialized in their own field that you end up
with even more impenetrable code, while also being dependent on said library
because nobody else understands the problem domain in question to the same
degree as those PhDs did (emphasis _did_ , to make things worse[0]) when they
wrote the library?

That sounds like a frustration layer cake to me, but it's not exactly the
language's fault.

[0] [https://medium.com/@fjmubeen/ai-no-longer-understand-my-
phd-...](https://medium.com/@fjmubeen/ai-no-longer-understand-my-phd-
dissertation-and-what-this-means-for-mathematics-education-1d40708f61c)

~~~
C1sc0cat
I recall at my first job improving a PHD candidates Fortran code that ran
experiments on our various mixing rigs.

His initial code's interface was "?" and you entered integer numbers to
execute various functions, and there where multiple levels here so you had to
memorise the numbers and where you where in the program :-)

I added prompts (with Mixed case Hollerith statements) that showed the options
at each level and what they did.

This was to reduce the risk of a botched run which when we scaled up to 1:1 in
an 8-1 m dia tank could cost £20k - the cost of a small flat at the time

------
cbkeller
Release notes:
[https://github.com/JuliaLang/julia/blob/v1.2.0/NEWS.md](https://github.com/JuliaLang/julia/blob/v1.2.0/NEWS.md)

------
truth_seeker
Julia has very well thought syntax and runtime

I hope to see it succeed in the server-side web development area

~~~
FranzFerdiNaN
There is [https://genieframework.com/](https://genieframework.com/) for a
fullstack framework.

~~~
truth_seeker
Awesome, thanks.

------
tixocloud
Does anyone know where Julia has been deployed for production use cases at
companies? Understand it’s quite an undertaking but seems like the fast
computations might make it seem worthwhile in certain industries?

~~~
mruts
Julia isn't really well suited for production environments. And by that, I
mean on some server or something. In finance it's gaining marketshare as an
exploratory analysis tool for traders and quants though. The code is typically
productionized in C++ or whatever in the same way Python or Matlab code is.

~~~
dtech
Is this a common thing? I'd argue it's an anti-pattern, similar to how we
prefer devops over splitting purely development and purely operations
nowadays.

At least the times I've seen it the first authors proclamed it as done and
"just need to port it for production" only to find out pesky things like
massive amounts of bugs (no testing in the originals) or unusable performance
problems (turns out what you can do on a 64-core cluster overnight is not
suitable for doing realtime)

~~~
setr
Whats the alternative? Write it with prod in mind, when you don’t know if the
idea is actually viable, and end up erasing a lot more time/code if it fails?

The idea for exploratory programs is just to see if the core idea is actually
viable in the first place, before spending time on things like making it
robust/fast.

Ofc, if you could make it robust/fast for free/cheap, then it makes sense to
call it an anti-pattern — you made it fragile for no good reason — but I’m not
clear on how to obtain robustness/speed without quite a bit of work

~~~
dtech
My preferable alternative would not be to use a totally different toolchain
for prototyping and production, and making the people responsible for the
prototype also responsible for bringing it to production.

I've heard all kinds of arguments against it, but they mostly boil down to
"data scientists/analysts/whatever" can't be arsed to bring it to production
(or "do not have the right skill set") and vice-versa for software developers.

I've seen much more success with a developer and less-technical person working
closely in a team and bringing a project from prototype to production
together.

~~~
mruts
A lot of the time, you’d just be wasting the developers time. In finance the
research quants are going to have to test and explore dozens of ideas before
even one is suitable enough to actually deploy in production. It doesn’t make
sense for the quant and developer to work closely together in C++ or whatever
when there’s a high likelihood that the trading idea doesn’t work in the first
place.

Also, the quant often isn’t good enough at computer science to actually
develop a production system himself. And even if he was good enough, it isn’t
his comparative advantage so he probably should be focusing on research.

------
QuadmasterXLII
I’ve recently switched to Julia for all my side projects and I’m loving it so
far! For me the killer feature is the seamless GPUs integration

~~~
RivieraKid
What do you mean by seamless GPU integration, is it some specific package?

------
mayankkaizen
I have heard a lot of nice things about Julia and I've decided to learn it.

Can someone point me to excellent resources/tutorials for learning Julia?

I mean I can search Internet but I am not sure I'll stumble upon really good
tutorials (I don't want to go through Medium or TutorialsPoint kind of
tutorials).

Any help?

~~~
ihnorton
The best place to start is this list of resources:
[https://julialang.org/learning/](https://julialang.org/learning/)

Excluding the university course listings, I think most of the resources there
should be up-to-date (post Julia 1.0).

Once you have a basic feel for the language, the forum
(discourse.julialang.org) and Slack are both very welcoming.

~~~
mayankkaizen
Thanks a lot!

------
mirekrusin
Honest question - why did authors feel like creating new langauge instead of
contributing/expanding something that exists, ie. Crystal seems to be
extremely close to what Julia offers, or am I wrong? Are there any fundamental
decisions that put Julia above Crystal?

~~~
jabl
Ignoring the Crystal issue that others already answered, why didn't Julia
developers instead create a kick-ass JIT for Python or R?

And the answer to that is that the semantics of the language were designed
from the start for efficient JIT'ing. Thanks to the language design, Julia can
get close to C performance with a comparatively simple JIT approach (resolve
types, compile a function statically with LLVM just like C, then use multiple
dispatch to select the right function at runtime (simplified, yes, but roughly
like this)). Compare this with all the tracing JIT heroics that Javascript
implementations or PyPy pull, while still getting performance far from what
Julia achieves.

~~~
ddragon
Actually, it will choose the right function to dispatch at compile time. In
fact if it will in certain occasions even erase all function call and replace
with the final output and even remove unaccessible branches from the generated
code.

