6 ms·

Julia v1.2

155 points by ziotom78 7y ago

cbkeller 7y ago
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 7y ago
Julia has very well thought syntax and runtime I hope to see it succeed in the server-side web development area
- quixoticelixer- 7y ago
  That would be nice but it's probably unlikely
- FranzFerdiNaN 7y ago
  There is https://genieframework.com/ https://genieframework.com/ for a fullstack framework.
  - truth_seeker 7y ago
    Awesome, thanks.
- oblio 7y ago
  I'd actually want it to get more traction on the DevOps side. The language seems really nice to use, they just need to make it super easy to deploy (think static compilation). Basically it could take over the niche were Go is right now.
  - cbkeller 7y ago
    I think this [1] is the latest on static compilation -- they're working on it [1] https://github.com/JuliaLang/PackageCompiler.jl https://github.com/JuliaLang/PackageCompiler.jl
- C1sc0cat 7y ago
  That's not what Julia's use case is
- locoman88 7y ago
  "Julia has very well thought syntax..." This holds only of you think MatLab has a very well thought syntax
dragonsh 7y ago
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 7y ago
  > 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-dissertation-and-what-this-means-for-mathematics-education-1d40708f61c https://medium.com/@fjmubeen/ai-no-longer-understand-my-phd-...
  - C1sc0cat 7y ago
    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
- 7y ago
eigenspace 7y ago
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 7y ago
  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.
tixocloud 7y ago
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 7y ago
  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.
  - C1sc0cat 7y ago
    Why is it not suitable for production environments, its a compiled language?
    - 1e-9 7y ago
      It depends on the application. Sometimes you need the finer level of control over resources provided by a statically-complied language like C++. An example would be latency-sensitive applications that cannot tolerate the unpredictable delays inherent in garbage collection and just-in-time compilation. Other issues might include current availability or stability of the packages.
      - mumblemumble 7y ago
        By this logic, Java would be unsuitable for production, too. I think perhaps you're conflating "production" and "real-time". Personally, what I'm really looking for when I ask if something is ready for production is, first and foremost, is it buggy? Second, has it stabilized, or are breaking changes still common? Third, is package/dependency management something that ops can work with without too much hassle, preferably without just relying on Docker to keep it manageable like a parent closing the door to their teenager's pigsty of a room. Also, you don't have to be faster than the bear. Julia's chief competitor, Python, is often used in production even though it fails the 3rd test and only semi-succeeds at the first.
mirekrusin 7y ago
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?
- ChrisRackauckas 7y ago
  Julia came before Crystal? https://github.com/JuliaLang/julia/graphs/contributors https://github.com/JuliaLang/julia/graphs/contributors https://github.com/crystal-lang/crystal/graphs/contributors https://github.com/crystal-lang/crystal/graphs/contributors Also, there's a lot of stuff that Julia has which Crystal doesn't (and vice versa since they focus on very different domains)
- cbkeller 7y ago
  Going off of wikipedia, it looks like Julia started in 2012, two years before Crystal.
- tokai 7y ago
  Crystal and Julia is not alike at all? Crystal is a static compiled OOP language. Julia is dynamic with multiple dispatch, and is not OOP. The crystal guys should have but their effort into nim or something like it imo
  - pjmlp 7y ago
    Multiple dispatch is definitely OOP. https://en.wikipedia.org/wiki/The_Art_of_the_Metaobject_Protocol https://en.wikipedia.org/wiki/The_Art_of_the_Metaobject_Prot... https://en.wikipedia.org/wiki/Dylan_(programming_language) https://en.wikipedia.org/wiki/Dylan_(programming_language)
- jhbadger 7y ago
  I'm not really seeing any similarities other than both languages having type inference (which is a pretty standard feature of newer languages and as mentioned, Julia was earlier). Julia is competing with Matlab/R/Numpy. That's not what Crystal is targeting at all. I suppose you could imagine that libraries could be written for Crystal, but except for Python's Numpy, these tend not to go anywhere in practice (Ruby itself has the now mostly dead Sciruby for example).
taliesinb 7y ago
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
- ddragon 7y ago
  There are some packages: https://github.com/davidavdav/NamedArrays.jl https://github.com/davidavdav/NamedArrays.jl In Julia, as long as any custom type implements the base methods (through overloading) it will work with anything and with no performance cost (since most base Julia types are written in Julia anyway), including every ML library. For example unitful that keeps track of the physical dimensions that perfectly integrate with the differentialequations library: http://tutorials.juliadiffeq.org/html/type_handling/03-unitful.html http://tutorials.juliadiffeq.org/html/type_handling/03-unitf...
- mcabbott 7y ago
  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
QuadmasterXLII 7y ago
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 7y ago
  What do you mean by seamless GPU integration, is it some specific package?
mayankkaizen 7y ago
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 7y ago
  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 7y ago
    Thanks a lot!
- cubedrone 7y ago
  I have just finished Think Julia, which was a pretty good introduction and is available for free online: https://benlauwens.github.io/ThinkJulia.jl/latest/book.html https://benlauwens.github.io/ThinkJulia.jl/latest/book.html Its a little slow for seasoned programmers, but it has a lot of exercises and the idiomatic julia parts tend to stick out more with the simple 2 line snippets.

155 points by ziotom78 7y ago

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 7y ago

Julia has very well thought syntax and runtime I hope to see it succeed in the server-side web development area

quixoticelixer- 7y ago
That would be nice but it's probably unlikely
FranzFerdiNaN 7y ago
There is https://genieframework.com/ https://genieframework.com/ for a fullstack framework.
- truth_seeker 7y ago
  Awesome, thanks.
oblio 7y ago
I'd actually want it to get more traction on the DevOps side. The language seems really nice to use, they just need to make it super easy to deploy (think static compilation). Basically it could take over the niche were Go is right now.
- cbkeller 7y ago
  I think this [1] is the latest on static compilation -- they're working on it [1] https://github.com/JuliaLang/PackageCompiler.jl https://github.com/JuliaLang/PackageCompiler.jl
C1sc0cat 7y ago
That's not what Julia's use case is
locoman88 7y ago
"Julia has very well thought syntax..." This holds only of you think MatLab has a very well thought syntax

dragonsh 7y ago

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 7y ago
> 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-dissertation-and-what-this-means-for-mathematics-education-1d40708f61c https://medium.com/@fjmubeen/ai-no-longer-understand-my-phd-...
- C1sc0cat 7y ago
  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
7y ago

eigenspace 7y ago

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 7y ago
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.

tixocloud 7y ago

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 7y ago
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.
- C1sc0cat 7y ago
  Why is it not suitable for production environments, its a compiled language?
  - 1e-9 7y ago
    It depends on the application. Sometimes you need the finer level of control over resources provided by a statically-complied language like C++. An example would be latency-sensitive applications that cannot tolerate the unpredictable delays inherent in garbage collection and just-in-time compilation. Other issues might include current availability or stability of the packages.
    - mumblemumble 7y ago
      By this logic, Java would be unsuitable for production, too. I think perhaps you're conflating "production" and "real-time". Personally, what I'm really looking for when I ask if something is ready for production is, first and foremost, is it buggy? Second, has it stabilized, or are breaking changes still common? Third, is package/dependency management something that ops can work with without too much hassle, preferably without just relying on Docker to keep it manageable like a parent closing the door to their teenager's pigsty of a room. Also, you don't have to be faster than the bear. Julia's chief competitor, Python, is often used in production even though it fails the 3rd test and only semi-succeeds at the first.

mirekrusin 7y ago

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?

ChrisRackauckas 7y ago
Julia came before Crystal? https://github.com/JuliaLang/julia/graphs/contributors https://github.com/JuliaLang/julia/graphs/contributors https://github.com/crystal-lang/crystal/graphs/contributors https://github.com/crystal-lang/crystal/graphs/contributors Also, there's a lot of stuff that Julia has which Crystal doesn't (and vice versa since they focus on very different domains)
cbkeller 7y ago
Going off of wikipedia, it looks like Julia started in 2012, two years before Crystal.
tokai 7y ago
Crystal and Julia is not alike at all? Crystal is a static compiled OOP language. Julia is dynamic with multiple dispatch, and is not OOP. The crystal guys should have but their effort into nim or something like it imo
- pjmlp 7y ago
  Multiple dispatch is definitely OOP. https://en.wikipedia.org/wiki/The_Art_of_the_Metaobject_Protocol https://en.wikipedia.org/wiki/The_Art_of_the_Metaobject_Prot... https://en.wikipedia.org/wiki/Dylan_(programming_language) https://en.wikipedia.org/wiki/Dylan_(programming_language)
jhbadger 7y ago
I'm not really seeing any similarities other than both languages having type inference (which is a pretty standard feature of newer languages and as mentioned, Julia was earlier). Julia is competing with Matlab/R/Numpy. That's not what Crystal is targeting at all. I suppose you could imagine that libraries could be written for Crystal, but except for Python's Numpy, these tend not to go anywhere in practice (Ruby itself has the now mostly dead Sciruby for example).

taliesinb 7y ago

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

ddragon 7y ago
There are some packages: https://github.com/davidavdav/NamedArrays.jl https://github.com/davidavdav/NamedArrays.jl In Julia, as long as any custom type implements the base methods (through overloading) it will work with anything and with no performance cost (since most base Julia types are written in Julia anyway), including every ML library. For example unitful that keeps track of the physical dimensions that perfectly integrate with the differentialequations library: http://tutorials.juliadiffeq.org/html/type_handling/03-unitful.html http://tutorials.juliadiffeq.org/html/type_handling/03-unitf...
mcabbott 7y ago
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

QuadmasterXLII 7y ago

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 7y ago
What do you mean by seamless GPU integration, is it some specific package?

mayankkaizen 7y ago

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 7y ago
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 7y ago
  Thanks a lot!
cubedrone 7y ago
I have just finished Think Julia, which was a pretty good introduction and is available for free online: https://benlauwens.github.io/ThinkJulia.jl/latest/book.html https://benlauwens.github.io/ThinkJulia.jl/latest/book.html Its a little slow for seasoned programmers, but it has a lot of exercises and the idiomatic julia parts tend to stick out more with the simple 2 line snippets.