23 ms·

Julia adoption keeps climbing

278 points by newswasboring 6y ago

the__alchemist 6y ago
Not until it addresses the JIT overhead.
- pjmlp 6y ago
  Yeah, because writing C and dealing with toolchain issues is so much more productive. Or keeping doing the thankless gospel to get PyPy adopted.
- deleted 6y ago
  [deleted]
- ForHackernews 6y ago
  That only matters in a scripting context where you're re-launching over and over as you make small changes. Once you have a real application that's up and running, it just runs.
  - rademacher 6y ago
    Julia has some packages to address this now. https://github.com/timholy/Revise.jl https://github.com/timholy/Revise.jl
- bsdubernerd 6y ago
  In my tests I frequently switch between cpython, pypy and julia (depending on the libraries/task I want to perform) and I haven't found the JIT overhead to be worse than pypy on average. Count me as one of the 1-based index haters, but I do love multiple dispatch and the language in general. As a language for explorative tools and analysis is on par of python (strict preference between the two according to taste). To me the biggest flaw currently is the poor "catch" syntax for exception handling. There are countless spots where exceptions are incorrectly caught at random points due to the catch-all semantics hiding/masking/breaking stuff. This is one area where I really find the syntax has been chosen poorly and it's causing real damage.
  - KenoFischer 6y ago
    Agreed on error handling actually. It doesn't quite have the feel that it should in a modern language. I think error handling and lifetimes/mutability are two of the top things we're looking at for a fundamental remodel in 2.0.
    - amkkma 6y ago
      What about traits or multiple inheritance?
      - KenoFischer 6y ago
        That's more on the "nice to have" list (at least from my perspective - others may have different opinions).
        amkkma 6y ago
        gotcha
  - physicsguy 6y ago
    Are many scientists using PyPy though? I never saw it in use in academia even though I'd tried it out personally.
    - bsdubernerd 6y ago
      I don't know. I also don't use pypy much, since python+numba is actually fast enough most of the time, and I always see pypy as a fallback to see if I can squeeze a little bit more performance before running a task.
      - goatlover 6y ago
        Does Numba offer significantly faster compile times than Julia's JIT?
superbcarrot 6y ago
Julia is a nice language, it's just tough to compete with Python. - The beginner experience in Julia is still much worse than it is in Python. Stuff that should work intuitively sometimes doesn't, and when you get a cryptic error message, it's difficult to find relevant help online. And when you do find help, some of it is out of date because the language has changed over the past few years. - You can squeeze a lot of performance out of Python and the ecosystem of libraries is hard to beat. - Julia has to be way better than Python to give people an incentive to switch. Being just marginally better in some aspects of the language isn't enough. And it's very difficult to be much better than Python especially in useability and ecosystem.
- ForHackernews 6y ago
  You can call Python directly from Julia https://github.com/JuliaPy/PyCall.jl https://github.com/JuliaPy/PyCall.jl so much of the Python library ecosystem (say, matplotlib) is available to be used in Julia programs. That helps the adoption story quite a bit. You can do the number-crunching in Julia where performance counts, and then analyse and present the results using Python.
  - superbcarrot 6y ago
    - Using Python directly is a better experience than calling Python from Julia - I've never run into unsolveable performance issues with Python So I guess I'm not in the target audience unless I just happen to be curious about a new language? That's kind of my overall point - even if Julia is a good language on its own and I work in data science, I don't have reasons to pick it over Python.
    - pjmlp 6y ago
      Except when Python fails, the option is to write C, in Julia I can carry on writing Julia.
    - galangalalgol 6y ago
      If you haven't hit a brick wall with python, it is just because you haven't run into the right problem. I was doing something that required lots of conditional operations on small matrices. The FFI into numpy's native library really bogged it down. I didn't have permission to install a compiler on that machine so I wrote it in vba in excel. It was 11x faster.
cricci16 6y ago
In my modest experience the perfect Julia slogan would be: "fast as C, easy as python, but NEVER the two together" All the sentences: "When you’re writing various algorithms, you don’t necessarily want to think about whether you’re on a GPU, or whether you’re on a distributed computer. You don’t necessarily want to think about how you’ve implemented the specific data structure. What you want to do is talk about what you want to compute." sound nice. Except in practice, unless someone else bothered doing that for you, you have to do it yourself.
- sgt101 6y ago
  Yes - if you have a real problem Julia is the way to go. If you are just banging something out to prove a point or make a delivery then Python is often much easier. Ofc this is like Excel and Notebooks - I start doing things in Excel because I can sort out an answer in like 30seconds. Doing it in a notebook requires 5 minutes, or maybe a little longer. But... see me there, a week later after the feedback and next questions from the customer... now I am in Excel hell and I wish wish wish I had started out in a Notebook.
- komuher 6y ago
  This is my favourite comment about julia for like last few years +1 on that. Ecosystem is extremly poor outside very few niches and most of the Deep Learning stuff isn't even faster than python api (+C ofc.) so swaping is just usless if u dont have time to write your own GPU kernals for every new opertaion.
  - jpsamaroo 6y ago
    At least for the GPU case, the ecosystem is slowing moving towards writing generic kernels that can be executed on both the CPU (multithreaded) and the GPU, without doing anything special in the kernel itself, via KernelAbstractions.jl. It's still got a little way to go, but already some larger codes are using it to great effect. Also, as a member of the JuliaGPU group, I know that AMD and Intel GPUs should be supported by KernelAbstractions within the next month or two, so a single generic kernel will be able to run unmodified on all major GPUs.
- 6y ago
jarenmf 6y ago
I tested my well-optimised R code and saw only 3x to 10x performance gain. That's still not substantial enough currently to migrate a whole code base, in particular given that the libraries are also still not mature enough. The research group I'm working with also have no interest in adopting anything new, In fact most of our code is still in FORTRAN so that is something I would be more interested in migrating to Julia but I don't think that is happening anytime in the next 10 years
- carlmr 6y ago
  >only 3x to 10x performance gain That sounds like a lot. I can see why maturity might be an issue, but after the word only I'd expect something like 5-10%, not integer multiples.
  - chongli 6y ago
    It does sound like a lot but it depends on the actual wall clock time. If your run time goes from 10 days down to 1 day then yes, it matters a lot. If it goes from 1s down to 0.1s it might not matter so much.
    - carlmr 6y ago
      Of course, but if you observe 3x to 10x performance gains across the board, you will have some programs that run in more than 1 second where it may be worthwhile.
- dfgdghdf 6y ago
  I would call that a huge performance gain! Perhaps Julia can be chosen for new projects; it is rarely worth rewriting old ones.
- shiftingleft 6y ago
  I guess whether it's effective to migrate a code base depends a lot on where your costs are. If you pay 500k$ for compute, it might become worthwhile to invest time into rewriting hot paths.
sgt101 6y ago
Julia is way superior if you are building programs and systems, especially if you are building for sustained use (rather than something to do a job once). Julia is less error prone, more expressive, more maintainable, more performant. But if you are creating cut and shut scripts for data science notebooks Python wins... the repl start time alone is a killer for Julia, add in the requirement to actually think about structure and the problem and it's out of my "3 -> 6hr" workflow.
- fsh 6y ago
  Julia is amazing for numerics, but the JIT is painfully slow for anything that gets looped only a few times or not at all. I don't think it is usable as a general purpose language until this gets improved somehow.
  - sgt101 6y ago
    But is that a problem apart from in scripting? If you ain't looping you ain't waiting in my experience.... Can you give an example which isn't time to plot?
    - fsh 6y ago
      I think that a slow JIT is problematic in any application except for non-interactive numerical calculations. For example in a GUI software or in a server application it would be very undesirable to have each function run a million times slower the first time it gets called.
      - sgt101 6y ago
        For GUI's I don't see this as an issue - JITs run alot faster than humans. All of Javascript is on a JIT - and thats the dominant UI for now! For servers generally you find that users are all calling the same function so it's very rare that you hit a blip - much more commonly users get performance problems from something else in the stack like the network or the client, and while Javascript is the dominant front end the dominant back end for servers is Java and that's got a JIT as well.
jpfr 6y ago
I teach a graduate course in optimization methods for machine learning and engineering [1,2]. Julia is just perfect for teaching numerical algorithms. First, it removes the typical numpy syntax boilerplate. Due to its conciseness, Julia has mostly replaced showing pseudo-code on my slides. It can be just as concise / readable; and on top the students immeditaly get the "real thing" they can plug into Jupyter notebooks for the exercises. Second, you get C-like speed. And that counts for numerical algorithms. Third, the type system and method dispatch of Julia is very powerful for scientific programming. It allows for composition of ideas in ways I couldn't imagine before seeing it in action. For example, in the optimization course, we develop a mimimalistic implementation of Automatic Differentiation on a single slide. And that can be applied to virtually all Julia functions and combined with code from preexisting Julia libraries. [1] https://www.youtube.com/playlist?list=PLdkTDauaUnQpzuOCZyUUZc0lxf4-PXNR5 https://www.youtube.com/playlist?list=PLdkTDauaUnQpzuOCZyUUZ... [2] https://drive.google.com/drive/folders/1WWVWV4vDBIOkjZc6uFY3nfXvpaOUHcfb?usp=sharing https://drive.google.com/drive/folders/1WWVWV4vDBIOkjZc6uFY3...
- awefasdfasdf 6y ago
  Small aside. Do you use the beamer package for your slides?
  - jpfr 6y ago
    Yes. Beamer LaTeX with the Metropolis theme and Fira Sans as the main font.
    - dm319 6y ago
      Those are beautiful slides.
- i_am_proteus 6y ago
  This. Julia's combination of human-readable pseudocode-like code and speed makes it perfect for these applications, and seems to be driving adoption.
sradman 6y ago
> It will be important for it to be adopted as a first-class target language by CPU/GPU vendors.” I’m not sure what the Apple M1 SoC with AMX [1] means for Julia within the Apple ecosystem. [1] https://news.ycombinator.com/item?id=25801500 https://news.ycombinator.com/item?id=25801500
- KenoFischer 6y ago
  I'm expecting somebody to add them to LLVM soon. I'd talked to folks at Apple about that some time back, but they weren't able to tell me at the time what their plans were for adding it. That said, I am fully expecting them to just add it to LLVM themselves. If not, somebody in the community will do it. Once that's done, Julia will just pick it up.
  - rovr138 6y ago
    This is interesting to hear. Thank you Keno
  - sradman 6y ago
    > add them to LLVM soon I’m not sure what “them” is. Apple has AMX, a Neural Engine, and a GPU which are abstracted through the Core ML and Accelerate libraries. AMX is not exposed as an instruction set like NEON. I guess this question applies to all of the numerical analysis tool chains: will they be able to leverage Apple silicon coprocessors/accelerators?
    - KenoFischer 6y ago
      I was talking specifically about the ARM ISA extensions. The accelerators are a different question of course. I understand the folks working on the Linux port are trying to reverse the GPU ISA. Apple could of course also just publish that, but I'd put the odds on that lower than the ISA extensions. That said, Apple has sometimes surprised me on these kinds of things.
anothernewdude 6y ago
No. It fails some very simple hurdles that are now fundamentally never going to change.
Guthur 6y ago
Ahem no. Going by Tiobe there is gulf between the top 4 languages and everything else. To put it into perspective Julia is only twice as relevant as Prolog and on par with Scratch. Of course I don't necessarily think Tiobe is a great metric for this but it was quoted in the article.
metreo 6y ago
Julia is simply a _much_ nicer to write lang than Python, it is more functional and it provides the user with far more ways to be expressive. I think the JIT warmup is less of an issue than its overall memory use but I can see that the former is more apparent to the average user sitting at their terminal. I wish we would see a larger fraction of the energy invested into propagating the 'Pythonic' approach were _properly_ redirected into improving relevant aspects of Julia.
qaq 6y ago
On what time scale? Julia is really nice lang. but it will take decades for it to put a serious dent in Python. If web side of things matures fast and someone builds a killer framework it might carve out a niche there too.
- veddox 6y ago
  It's not meant for web, it's meant for scientific computing. And it has already left a mark on that field.
  - ku-man 6y ago
    Then Julia should stop describing itself as a general-purpose programming language.
    - veddox 6y ago
      I think its website makes it pretty clear that it's mostly targeting scientists... https://julialang.org/ https://julialang.org/, https://docs.julialang.org/en/v1/ https://docs.julialang.org/en/v1/ (The first two words of the Introduction are literally "scientific computing".)
    - StefanKarpinski 6y ago
      Julia absolutely is a general purpose language and has been from the beginning. However, there are plenty of languages that are fine for building websites, whereas there are no other languages with the combination of speed and usability that Julia offers in technical computing. It's a lovely language for doing all kinds of work and I personally mostly use it for non-technical computing these days — specifically to implement package management client/server infrastructure, which is mostly web + file system wrangling.
      - veddox 6y ago
        Oh, hello, interesting to see you here :D Perhaps you ought to say that you're a co-creator of the language...
pansa2 6y ago
I don’t know whether Julia will succeed as a general-purpose language, but its design seems ideal for numeric code. In particular, multiple dispatch makes operator overloading so much nicer than Python’s fragile “dunder” methods like `__add__` and `__radd__`.
lukeitup 6y ago
Python > Julia, currently not even a contest
- rovr138 6y ago
  This depends on the task/problem/project.
kitsune_ 6y ago
It's nice imo, the precompilation step is a bit slow imho. Also not sure whether I'm a big fan of its module system.
- shmeano 6y ago
  The precomp step will speed up significantly and move to pkg install time in the upcoming 1.6 release. There's a beta out if you want to try
mkl95 6y ago
Python has a battle-tested, humongous standard library, and a rich ecosystem. It is easy to learn and it's great at gluing every day stuff. Data scientists like it, engineers like it, even the cashier at Lidl likes it. I can see how Julia may challenge Python for academic use, but challenging Python in 2021 for industrial use is no joke.
- dunefox 6y ago
  > Python has a battle-tested, humongous standard library, and a rich ecosystem Use it then: https://github.com/JuliaPy/PyCall.jl https://github.com/JuliaPy/PyCall.jl
kuter 6y ago
Julia uses modern compiler technology to achieve close to native performance. This is not just generating LLVM IR. Julia also has it's own optimization system for language specific optimizations that LLVM struggle to do (due to language specific info getting lost in conversion to LLVM IR). Google's V8 (js interpreter) also uses modern compiler tech but I think it is not as capable as LLVM optimization vise (I don't think it is designed to be). Python will either adapt or perish. Even if it is not julia it would be a another language.
- pansa2 6y ago
  V8 and the Julia compiler work in quite different ways - because they solve quite different problems. In particular, Julia’s compiler only works well on code that is "type-stable", whereas V8 has no such limitation.
  - kuter 6y ago
    I know that V8 does some interesting stuff with it's types. Julia's creators considered supporting optimization while designing the language. Whereas the first javascript engine that even generated machine code came much later it's creation. Js has weird features like being able to set a getter function to a array index. There was a memory corruption bug in V8 that the implementation of `Array.sort` would call a getter function in the array that would change the size of the array causing a memory corruption. This was used in a exploit. Creators of V8 created a domain specific language called Torque to implement the language lol.
ajankelo 6y ago
Julia is fantastic with a great community. The one issue I have though is the use of greek symbols, while great for those formally trained, may have a negative impact on wider adoption for deep learning.
- chrispeel 6y ago
  I don't think Julia requires you to Greek symbols, rather it allows them ;-)
- DNF2 6y ago
  Python also allows Greek letters. There are no Greek letters forced upon you, they aren't even used in Base, and barely if at all, in the stdlibs. It is a feature for you to use, if you want. (And they dramatically improve code readability in heavily mathematical code.)
D13Fd 6y ago
It’s extremely silly, but I don’t really like the name Julia for a programming language. It’s just a bit uncomfortable to have a programming language with a particular, kind of formal-sounding human name like Julia (or like Michael, Lauren, or Jonathan). It just feels weird to me. I know a number of people (family, friends, colleagues) named Julia. I honestly think it could have an effect on adoption. People have to say the name a lot in making a choice to adopt a language for a project. Names like C, C++, Java, Python are fairly neutral. “Julia” is just an awkward name in this context, in my opinion.
- mhd 6y ago
  What about "Ada", "Miranda" or "Haskell"? First names, too, albeit ones much less common these days. ("Linda" the language isn't even in that category, popularity-wise, although the source of the name seems to be a weirder story)
  - D13Fd 6y ago
    I had no idea that “Ada” and “Haskell” were intended to be people names. Those are not super common names. And I had totally forgotten about Miranda, which I agree has the same issue.
    - Jtsummers 6y ago
      Ada was named after Ada Lovelace, for context. And it’s definitely not a common name anymore, at least in the US. It dropped off significantly through the 20th century with a spike several years ago.
    - mhd 6y ago
      I see, that's what I thought. No problem with naming languages after people, but it's easier if it's an homage to a certain person. Common first and last names alone often point to confusing people, and there might be a certain dissonance between the mental images ("I pulled some Julias pigtails in kindergarten, now I have her name on a CV?"). The same problem would probably arise if the last names would be more common, too. "Pascal" and "Turing are probably rare enough ('though "Pascal" was a bit in fashion as a boy's name in Germany when I was young).
querez 6y ago
I'm a researcher, doing lots of numerical work both professionally and in hobby projects. While Julia has a lot of technical merits, there are just some superficial, syntax-level design decisions that strongly rub me the wrong way: 1-based indexing (makes interfacing with C code hard), explicit begin/end (verbose & ugly) and column-major indexing (personal preference). I understand that these follow in the footsteps of Fortran (and matlab), but they always feel wrong to me. I grew up on C-based languages, and these things made working with R and Lua difficult whenever I had to interface with any non-numerical code (which somehow even most of my research projects ended up needing). It's a weird hill to die on, but I personally will avoid Julia (and actively discourage students from using it, in case I need to work with their code) for as long as I can due to these design decisions.
- kescobo 6y ago
  Who am I to say what hills are worth dying on? But I don't want you to die at all - in case you're ever compelled to switch, I can't help you with end, but OffsetArrays.jl can help with your indexing woes, and I think there are packages to rotate matrices too (though not certain of that).
amelius 6y ago
My gripes, feel free to disagree: 1. Julia uses base-1 indexing. 2. Julia uses an "end" keyword everywhere, which is imho too verbose (and the corresponding "begin" is missing so it's inconsistent).
- jakobnissen 6y ago
  I would argue that if those really are your major gripes about Julia, you either have very bad priorities, or don't know enough about Julia to contribute to this conversation.
- psychometry 6y ago
  If 0-indexing hadn't been the default for so many programmers for so many years (usually because the languages being used required actually thinking about arrays in terms of memory offsets) then it would feel very odd. Humans reason about counting in terms of the natural numbers, so 1-indexing is fine. Just ask any beginner CS student what they think of 0-indexing if you doubt this.
- veddox 6y ago
  I don't like those two either, but that doesn't change the fact that the rest of the language is absolutely ideal for what I do ;-) (ecosystem modelling)
- dgb23 6y ago
  Disclaimer: Not a Julia user. 1. Base-1 indexing is more natural and less verbose. My suspicion is that base-0 indexing grew out of language implementers wanting to reduce their mental overhead rather than a first-principles approach. AKA machine code leaking out to the higher level languages. 2. You have to have some way of structuring syntax. Whether you have "end", ")" or "}". It is not inconsistent to start with something else, like a function signature with the corresponding keyword. Again Julia opts for natural readability. Both of these complaints are rather superficial anyways. Julia is a marvelous piece of tech and has an interesting story to tell about type inference, multiple dispatch, performance, data-structures, general Lisp-yness and the merits of tailoring a language for a purpose/domain (and its users) in contrast to trying to adhere to paradigms and programmer culture (cults?).
dan-robertson 6y ago
I’ve used juli a few times over the years. For some numerical things it’s nice with easy interfaces to modern algorithms. I solved a differential equation recently and it just worked. And Julia feels like a much more proper programming language than matlab. At the lower level (which I haven’t looked at in a while so may have changed) I found it a bit confusing and messy. The subtyping and method selection are tricky to get right and they are fundamental to important parts of the language like it’s numeric tower. But libraries seem to just work. Macros were horrific and the ast is inscrutable and liable to change from one version to the next. Quasiquoting was also tricky. So I wouldn’t recommend trying to do anything weird with them. But maybe they are good now. Pluto notebooks seem a great concept. I tried them recently and mostly they worked (sometimes they didn’t get dependencies right but it’s still beta). I felt like I was fighting a bit with plots.jl. I don’t know if there are things that weren’t obvious to me that I was missing or if it can just be a bit annoying. I haven’t tried gadfly but I would like to at some point. I’ve heard good things about ggplot2 which it is inspired by. I felt like documentation was a bit lacking in good straightforward tutorials and examples. As well as documentation in general. But I don’t want to put too much emphasis on that.
xvilka 6y ago
If you want to help the adoption of Julia in the bioinformatics and medical applications - feel free to support BioJulia[1][2] on their OpenCollective page[3]. During the times of pandemic projects like these are of the special importance. [1] https://biojulia.net/ https://biojulia.net/ [2] https://github.com/BioJulia/ https://github.com/BioJulia/ [3] https://opencollective.com/biojulia https://opencollective.com/biojulia
salt-licker 6y ago
Julia’s type system is not particularly user-friendly. For example, it has both a “String” and a “SubString” type which cannot always be interchanged. Their language design seem to be much more concerned with execution speed than programmer productivity — Python has the balance in the opposite direction, but they’ve been gradually improving performance for years, and this is much easier to improve after the language design is set in stone, especially as more and more people add typing info to their programs. Also, 1-indexed arrays are a major turn-off.
- stabbles 6y ago
  julia> supertype(String) == supertype(SubString) == AbstractString true If you insist just use f(s::AbstractString)
- oivey 6y ago
  I’ve generally found they can be interchanged in the way you would expect as a Python user: duck typing. I have more experience using SubArrays, but I think the underlying machinery in the language is basically the same. Adding performance after the fact is not easy. This is why most numerical Python projects depend on C extensions rather improvements to the Python runtime. Writing C extensions or jamming your algorithm into the shape of existing C accelerated APIs is often not very time efficient.
- huitzitziltzin 6y ago
  IMO, array indices are a matter of taste which inspire feelings of religious intensity. You can change it if you prefer 0 or -14 or whatever number you like. Non zero effort is required, but if you otherwise like the language it can be changed AFAIK https://docs.julialang.org/en/v1/devdocs/offset-arrays/ https://docs.julialang.org/en/v1/devdocs/offset-arrays/
Xcelerate 6y ago
I’m amazed how many people are defending Python. It’s such a kludgy language. I’m curious what the Fortran holdouts said back in the day.
- eigenspace 6y ago
  The better comparison is to Perl. Everyone used to say that there was no way Python could replace Perl because Perl had such a big ecosystem.
- pauljurczak 6y ago
  > what the Fortran holdouts said back in the day. Fortran holdouts say today that there is still no competition to Fortran for optimizing code in multiprocessing/supercomputing environment and no volunteers to rewrite tons of proven and optimized to the extreme numerical and physics code in another language. Good, old languages die hard...
tpoacher 6y ago
I don't want to disparage Julia, it's actually a very nice language, and I was very excited to learn it a couple of years ago. But, honestly, I think their adoption at this point is less "linux-like" driven and much more "apple-like". In that, the language is 'ok', but the company is going to INCREDIBLE lengths with respect to shrewd marketing and buzz-creation at this point. Which is admirable but also kinda worrying at the same time.
- eigenspace 6y ago
  Very little Julia hype comes from JuliaComputing. The buzz you see is almost all from people who switched from other languages and found that Julia was a gigantic breath of fresh air. I can say that for me, it completely changed my attitude towards programming in general. Before, programming was something I did sometimes as part of my physics research. Now, it’s also my hobby that I probably spend too much time on. It’s hard not to get a little evangelical when you go through a change like this.
- StefanKarpinski 6y ago
  This "Julia marketing conspiracy theory" that many people on HN seem to believe is so bizarre. What big tech company do you think is behind this incredible, shrewd and presumably well-funded marketing campaign? Julia is the only new major programming language of the last decade that doesn't have a major tech giant backing it. Adoption and development are pretty much entirely grass roots. If you see a lot of enthusiastic posts about Julia on HN, that's because there are a lot of actual people out there using Julia who love it and write posts about it.
  - ChrisRackauckas 6y ago
    Poor Go, Dart, Swift for Tensorflow. How is Google going to compete with Julia Computing in terms of marketing and advertising?
  - oxinabox 6y ago
    Trying to think of others. Kotlin was 2011, and is JetBrains. JetBrain's is 1500 people. So big, but not giant. Rust is 2013 Mozilla is only 750 people So perhaps Major Tech Giant is over-stating it. But definately most other things in the last decade have a major established tech firm backing it. Julia has basically nothing. Starting out as a MIT project, and then Julia Computing is a tiny startup; with like what 50 people now?
laichzeit0 6y ago
Is it correct to state that in 5 to 10 years we’ll see Julia as the default for new Data Science projects? (ML and statistical inference). I’m not a biggie on switching tool sets just because something is becoming “hot”. I like to start using something when it’s boring and battle tested, the youngsters can do the bleeding. But it seems like the likely candidate if something is going to displace the Python and R ecosystem?
- oivey 6y ago
  I’m a huge Julia proponent (and before, a huge Python proponent over Matlab), but I would be careful about claiming that Julia will be the coming standard. Python has a crazy amount inertia and excellent projects still in the pipeline. I think Julia will eventually win because writing your code in one language which isn’t C or FORTRAN is extremely productive and leads to much more composable libraries. The progress that’s been made on, for example, deep learning frameworks is impressive given the lack of massive investment from FAANG. I hope this leads to it dethroning Python, but it might not. If anything will, I think it has the best chance. I’d suggest you give it a try anyway because its really not a hard language to learn. The ecosystem itself is quite good. The fact that you can write fast code without C extensions leaves you less dependent on the ecosystem, too.
- evgen 6y ago
  > Is it correct to state that in 5 to 10 years we’ll see Julia as the default for new Data Science projects? No, it is not correct to make this claim. Nothing is going to de-throne Python in the next five years and it is EXTREMELY unlikely that anything will de-throne it in 10 years. Any language that replaces Python in these tasks will need to be significantly better, and Julia just isn't that. Incremental improvement in a few areas that reek of premature optimization is not going to be a compelling argument for the masses. The language that de-thrones Python has not been invented yet, and it will probably need some sort of hardware-coupled advance to have a chance (e.g. if the next big leap in mass-produced hardware were to drop 4K cores into a cheap SoC then a simple scripting language that handled internal data and execution concurrency might take over.) Julia is nice, but if anything you are probably going to see more migration from MATLAB and similar older dead-ends to Python over the next five years than you are to see migration from Python to Julia.
x43b 6y ago
Any recommendations on beginner (to Julia) books to get started?
- forgotpwd16 6y ago
  The manual is great https://docs.julialang.org/en/v1/manual/getting-started/ https://docs.julialang.org/en/v1/manual/getting-started/. If you want something more step-by-step with some simple exercises, check https://benlauwens.github.io/ThinkJulia.jl/latest/book.html https://benlauwens.github.io/ThinkJulia.jl/latest/book.html.
  - x43b 6y ago
    Thank you. I will look through both.
Const-me 6y ago
I wonder can I compile Julia code into a Windows DLL? For instance, with AVX2 and DirectCompute included? Currently writing C++/17 and HLSL. Would like to evaluate something higher-level. However, I think it’s unreliable in the long run to redistribute and support complicated packages like Python runtime or LLVM. Users mess with environment variables, update Windows, run antimalware, etc. Process startup time also matters, I don’t want to wait 40 seconds for the first output.
- huitzitziltzin 6y ago
  Not sure about your exact use case and this is not part of Julia which I have ever used myself but the answer might be here: https://github.com/JuliaLang/PackageCompiler.jl https://github.com/JuliaLang/PackageCompiler.jl There is a presentation from a recent JuliaCon by Kristoffer Carlson on the topic too, I believe. https://m.youtube.com/watch?v=d7avhSuK2NA https://m.youtube.com/watch?v=d7avhSuK2NA
phonebucket 6y ago
Julia offers a wonderful modular ecosystem. This is in no small part due to a clever design decision of language design of combining type genericism with multiple dispatch. For example, Turing.jl for Bayesian Inference plays well with Flux.jl for Neural Networks which plays well with DifferentialEquations.jl for ODEs. Basically, everything in pure Julia plays nicely with everything else. An example of how this useful: when neural ODES became more popular a couple of years ago, Julia users had to do almost nothing to implement them and extend them. DifferentialEquations.jl and Flux.jl already played nicely with each other, and you could just run wild. Meanwhile, in Python-land, there are devs building out ODE solvers built in Tensorflow and Pytorch, doing a load of duplicate work because the frameworks don't allow the same level of genericism. The whole ecosystem is like this. So I've decided to stay with Julia. I'm staying with Python too. It's no big deal.
- alper111 6y ago
  This seems very desirable. Though at the moment, when the self-attention got popular for the first time, it was already available in PyTorch. Python seems to have the edge just because there are lots of people using it. Maybe it is just a matter of time and users. Probably I will wait until the ecosystem gets larger, and then switch to it. (Yes, I am a lazy person to implement a transformer from scratch)
  - BadInformatics 6y ago
    If NLP primitives are all that's keeping you from testing the waters, have a look at https://github.com/chengchingwen/Transformers.jl https://github.com/chengchingwen/Transformers.jl.
laplacesdemon48 6y ago
I've been using R nonstop for pretty much 5+ years. I'm happy that there's established competition coming from Python and new competition coming from Julia. Having these languages compete over similar types of programmers pushes each one to be better, which is awesome. I'm not a die-hard R person, I'd be more than happy to switch under the right circumstances. But...I think one thing gets overlooked way too often. For "data scientists" or "statisticians" or [insert new term here], the majority our non-modeling time is spent on just plain old data wrangling. To me, R is unbeatable here. I've tried Python ~2 years ago and pre-1.0 Julia. Using tidyverse you can do pretty much anything to any dataset, often *without a monstrous amount of keystrokes*. (The pipe syntax is awesome). If you really need speed you can always switch over to data.table for uglier but faster code. I really tried but I could never replicate the "brain cycles to keystrokes" speed of R in Python/Julia. That is, being able to intuitively and quickly just convert my thoughts into readable data wrangling code. Sure the base R language is not that "fast" and Julia/Python benchmarks are way faster. But in practice this doesn't matter to me. Most of the performance sensitive packages are written in C/C++/Fortran anyway (rstan, brms, glmnet, caret). I don't care that I could write 3x faster loops. The extra 5 seconds for that one piece of code doesn't make up for the absence of a good data wrangling ecosystem. My message to the Julia team: You can get a very large portion of the R userbase to switch over if you focus on a Julia version of the tidyverse (especially dplyr). I know that DataFrames.jl exists but it just doesn't even come close. There's a difference between "you can do this in Julia too" and "here's a clean/intuitive way to do this better without extra baggage". I'm sorry if the above seems harsh. I genuinely appreciate the Julia team's efforts. I can only imagine how hard it is to create a new language. I just wanted to be honest.
- tikej 6y ago
  I also like pipe syntax and I've found there is nice support for it in Julia. There are some nice packages to improve it over base [1]. Have you checked queryverse [2]? [1] https://github.com/jkrumbiegel/Chain.jl https://github.com/jkrumbiegel/Chain.jl [2] https://www.queryverse.org https://www.queryverse.org
  - laplacesdemon48 6y ago
barfoobazy 6y ago
<clicks link to article> <clinks linked press release with the data> “Python is the 2020 Programming language of the year!” <logs off>
twobitshifter 6y ago
I have been using Julia only for a few months, but I’ve been surprised in the speed up that’s possible vs python code using pandas. Depending on the size of your datasets the JIT might slow you down a little, but the speed of Julia outweighs this. Liberally using functions really allows Julia to shine. One thing that I’ve recently seen which concerns me long term is the creation of various competing macro syntaxes for reducing the wordiness of Julia. There are many competing implementations of pipes and other syntax sugars. These macros definitely make things easier, but as you use them the code becomes more difficult for another to understand and since there is at this time, no one set of macros to use, you’ll have to know each of the competing sets to make since of examples.
- krumbie 6y ago
  I have created one of the recent competitors in this space [1], and I think it's not so bad, as long as the macros are reasonably simple to understand. If you look in the readme of my project, the four syntax examples actually look quite similar so I don't anticipate they'd cause a lot of confusion. When I got annoyed in my own work that some data wrangling syntax was repetitive I was just really glad that I could easily build my optimal solution and didn't have to just accept that there's one suboptimal (for me) way. In Python and R, if you like what they offer that's good, if not - not so good. Part of the problem comes from Julia not being geared towards DataFrames like R is, but I gladly trade a bit of convenience in one domain against a lot of expressive freedom with very clean rules that apply everywhere. For example, I think it's quite good that you can only have "weird" behavior in Julia with macros, but they give you a visual indicator with the @ that you're seeing non-standard syntax. While in R, the non-standard evaluation means that literally anything could happen to the variables you pass into any function. It makes for some convenient syntax in some cases, yes, but it's so confusing as a system for writing software! You never really know if you're looking at a variable or just a name, for example. [1] https://github.com/jkrumbiegel/Chain.jl https://github.com/jkrumbiegel/Chain.jl
dopu 6y ago
I'm a graduate student that's switched almost completely over to Julia. Prior to it I worked in both MATLAB (the IDE is so nice, and writing out matrix computations is just great) and Python (for ML). Julia is absolutely nicer to write in than either of the two. MATLAB is slow and at times feels less like a programming language and more like an incomplete and brittle interface with the JVM. Python is also slow, and it feels awkward to use given that it was not explicitly designed for scientific workflows. With Julia I get proper typing, incredible speed, easy parallelization, and a kick ass REPL. The only thing I truly miss in using Julia is the plotting capacities of MATLAB. I haven't found an environment that can match it in terms of interactivity. Give me the ability to (easily) save interactive figures for later use and Julia would be perfect.
- StefanKarpinski 6y ago
  Out of curiosity, have you tried using Plots.jl from VS Code? If so, what's missing from that experience?
  - dopu 6y ago
    I have, though I've mostly stuck with the plain PyPlot.jl package due to the familiar syntax and interactivity. Perhaps things have changed, but I just recall being frustrated at the inability to zoom in/out, and again save interactive figs. Perhaps it was just due to the particular backend I was using. I'll give the VS Code experience another try!
- superdimwit 6y ago
  I would recommend Plotly.js in VSCode for interactive plotting.
  - dopu 6y ago
    Wow, I just tried it out. This is really great. And it solves my interactive plot saving requirement. Easy as doing `Plotly.savehtml(fig, "test_fig.html")` :). Thanks!
  - skybrian 6y ago
jti107 6y ago
"I saw the 87 percent increase and think it is wonderful to see Julia growing. I think that Julia has great potential to replace C/C++/Python (and of course Fortran) in scientific and technical computing as it matures." its really all about the ecosystem, community and ease of use. python took off once people developed numpy, pandas, Anaconda, etc.
krumbie 6y ago
The comparison between different languages gets tiring when it focuses on making a black-and-white statement like "Julia is better" or "Python is better" and "x is never going to overtake y". Yes, Python has many more libraries thanks to it being much older than Julia, same for R. But at the same time, Julia can be used for impressive work that R/Python struggle with and which only seem solvable in these languages because of large investments into certain packages by big companies. So I find the fact that many hard problems can be solved very generically and performant with small libraries written in Base Julia much more interesting than countering that much larger and older Python packages with millions of developer hours poured into them are currently more feature-complete. Yes, they are, right now. Why wouldn't they be. But does what is being done in Julia with much fewer resources not point to an impressive ability of the language to facilitate such development?
- disgruntledphd2 6y ago
  While I generally agree with your argument, it's worth noting that the median Julia programmer is probably more invested in the language/ecosystem than the median R/Python programmer. Back in the mid-90's Java was the new hotness, and it probably made problems that required 100+ lines of C easier, but it's not still full of above-average programmers, as any language/ecosystem that achieves success will inevitably regress to the mean.
  - krumbie 6y ago
    That's true. I am of course biased in talking mostly to people on the Julia Slack etc. who enjoy the language a lot and do interesting things with it. That's one of the reasons, though, why I never find the "how many people are using it" argument the most convincing when talking about the merits of a language. Because most people I've seen using R, Matlab and Python, at university or work for example, used it really superficially, and therefore wouldn't have any interesting things to say about it. Neither do they add anything interesting to the respective ecosystems. I don't think it's the first interest of a new language to get this type of user, although of course in the long term you want to build tools that are easy to be picked up and used by a wide audience, and number of users is some indicator of that.
causalmodels 6y ago
Can anyone recommend some good resources to learn Julia? I am hoping there is something akin to the Rust Book [1] since watching youtube videos is too slow and the exercism option listed on the website is too cumbersome. [1] https://doc.rust-lang.org/book/ https://doc.rust-lang.org/book/
- dunefox 6y ago
  This might be helpful: https://benlauwens.github.io/ThinkJulia.jl/latest/book.html https://benlauwens.github.io/ThinkJulia.jl/latest/book.html
  - causalmodels 6y ago
    This is perfect, thank you so much! I'm a bit surprised julialang.org only links to a the oreilly store page. Seems like you would want to call attention to a resource like this.
antpls 6y ago
> "Because Julia’s compiler is different from the interpreters used for languages like Python or R, you may find that Julia’s performance is unintuitive at first. If you find that something is slow, we highly recommend reading through the Performance Tips section before trying anything else. Once you understand how Julia works, it’s easy to write code that’s nearly as fast as C." If Julia needs a "Performance Tips" section to produce fast code, I might as well use Python. The "speed" from Julia comes from LLVM, but there is nothing stopping Python to use LLVM as well where it _makes sense_ (which is the case with XLA in TensorFlow, for example). I see no plus value in learning Julia over existing tools, there is nothing revolutionary or nothing that could alleviate future risks.
snicker7 6y ago
The most important aspect of any language are the trade-offs and values held by the designers and community. Julia takes a zero-compromise oath to approachability and performance. Julia is not (yet!) a perfect language, but those values make me want to invest in the ecosystem.
septc 6y ago
I'm interested in the following example (3x speedup), and is it possible to read more details about their project? (From the hpcwire article) "During his talk, Edelman presented an example in which a group of researchers decided to scrap their legacy climate code in Fortran and write it from scratch in Julia. There was some discussion around performance tradeoffs they might encounter in the move to a high level programming language. The group was willing to accept a 3x slowdown for the flexibility of the language. Instead, said Edelman, the switch produced 3x speedup."
mapledipdonut 6y ago
I recently decided to port some of my Python analysis code over to Julia since I've been doing a lot of ODE stuff lately. Overall I'm liking it, but I've found a couple things frustrating: 1) the docs and online issues/answers are a bit of a mess, partly because many of the accepted answers are from pre-1.0 days; 2) the error messages I've found are long and not very helpful. It takes much longer to track down a bug in Julia than Python code.

278 points by newswasboring 6y ago

the__alchemist 6y ago

Not until it addresses the JIT overhead.

pjmlp 6y ago
Yeah, because writing C and dealing with toolchain issues is so much more productive. Or keeping doing the thankless gospel to get PyPy adopted.
deleted 6y ago
[deleted]
ForHackernews 6y ago
That only matters in a scripting context where you're re-launching over and over as you make small changes. Once you have a real application that's up and running, it just runs.
- rademacher 6y ago
  Julia has some packages to address this now. https://github.com/timholy/Revise.jl https://github.com/timholy/Revise.jl
bsdubernerd 6y ago
In my tests I frequently switch between cpython, pypy and julia (depending on the libraries/task I want to perform) and I haven't found the JIT overhead to be worse than pypy on average. Count me as one of the 1-based index haters, but I do love multiple dispatch and the language in general. As a language for explorative tools and analysis is on par of python (strict preference between the two according to taste). To me the biggest flaw currently is the poor "catch" syntax for exception handling. There are countless spots where exceptions are incorrectly caught at random points due to the catch-all semantics hiding/masking/breaking stuff. This is one area where I really find the syntax has been chosen poorly and it's causing real damage.
- KenoFischer 6y ago
  Agreed on error handling actually. It doesn't quite have the feel that it should in a modern language. I think error handling and lifetimes/mutability are two of the top things we're looking at for a fundamental remodel in 2.0.
  - amkkma 6y ago
    What about traits or multiple inheritance?
    - KenoFischer 6y ago
      That's more on the "nice to have" list (at least from my perspective - others may have different opinions).
      - amkkma 6y ago
        gotcha
- physicsguy 6y ago
  Are many scientists using PyPy though? I never saw it in use in academia even though I'd tried it out personally.
  - bsdubernerd 6y ago
    I don't know. I also don't use pypy much, since python+numba is actually fast enough most of the time, and I always see pypy as a fallback to see if I can squeeze a little bit more performance before running a task.
    - goatlover 6y ago
      Does Numba offer significantly faster compile times than Julia's JIT?

superbcarrot 6y ago

Julia is a nice language, it's just tough to compete with Python. - The beginner experience in Julia is still much worse than it is in Python. Stuff that should work intuitively sometimes doesn't, and when you get a cryptic error message, it's difficult to find relevant help online. And when you do find help, some of it is out of date because the language has changed over the past few years. - You can squeeze a lot of performance out of Python and the ecosystem of libraries is hard to beat. - Julia has to be way better than Python to give people an incentive to switch. Being just marginally better in some aspects of the language isn't enough. And it's very difficult to be much better than Python especially in useability and ecosystem.

ForHackernews 6y ago
You can call Python directly from Julia https://github.com/JuliaPy/PyCall.jl https://github.com/JuliaPy/PyCall.jl so much of the Python library ecosystem (say, matplotlib) is available to be used in Julia programs. That helps the adoption story quite a bit. You can do the number-crunching in Julia where performance counts, and then analyse and present the results using Python.
- superbcarrot 6y ago
  - Using Python directly is a better experience than calling Python from Julia - I've never run into unsolveable performance issues with Python So I guess I'm not in the target audience unless I just happen to be curious about a new language? That's kind of my overall point - even if Julia is a good language on its own and I work in data science, I don't have reasons to pick it over Python.
  - pjmlp 6y ago
    Except when Python fails, the option is to write C, in Julia I can carry on writing Julia.
  - galangalalgol 6y ago
    If you haven't hit a brick wall with python, it is just because you haven't run into the right problem. I was doing something that required lots of conditional operations on small matrices. The FFI into numpy's native library really bogged it down. I didn't have permission to install a compiler on that machine so I wrote it in vba in excel. It was 11x faster.

cricci16 6y ago

In my modest experience the perfect Julia slogan would be: "fast as C, easy as python, but NEVER the two together" All the sentences: "When you’re writing various algorithms, you don’t necessarily want to think about whether you’re on a GPU, or whether you’re on a distributed computer. You don’t necessarily want to think about how you’ve implemented the specific data structure. What you want to do is talk about what you want to compute." sound nice. Except in practice, unless someone else bothered doing that for you, you have to do it yourself.

sgt101 6y ago
Yes - if you have a real problem Julia is the way to go. If you are just banging something out to prove a point or make a delivery then Python is often much easier. Ofc this is like Excel and Notebooks - I start doing things in Excel because I can sort out an answer in like 30seconds. Doing it in a notebook requires 5 minutes, or maybe a little longer. But... see me there, a week later after the feedback and next questions from the customer... now I am in Excel hell and I wish wish wish I had started out in a Notebook.
komuher 6y ago
This is my favourite comment about julia for like last few years +1 on that. Ecosystem is extremly poor outside very few niches and most of the Deep Learning stuff isn't even faster than python api (+C ofc.) so swaping is just usless if u dont have time to write your own GPU kernals for every new opertaion.
- jpsamaroo 6y ago
  At least for the GPU case, the ecosystem is slowing moving towards writing generic kernels that can be executed on both the CPU (multithreaded) and the GPU, without doing anything special in the kernel itself, via KernelAbstractions.jl. It's still got a little way to go, but already some larger codes are using it to great effect. Also, as a member of the JuliaGPU group, I know that AMD and Intel GPUs should be supported by KernelAbstractions within the next month or two, so a single generic kernel will be able to run unmodified on all major GPUs.
6y ago

jarenmf 6y ago

I tested my well-optimised R code and saw only 3x to 10x performance gain. That's still not substantial enough currently to migrate a whole code base, in particular given that the libraries are also still not mature enough. The research group I'm working with also have no interest in adopting anything new, In fact most of our code is still in FORTRAN so that is something I would be more interested in migrating to Julia but I don't think that is happening anytime in the next 10 years

carlmr 6y ago
>only 3x to 10x performance gain That sounds like a lot. I can see why maturity might be an issue, but after the word only I'd expect something like 5-10%, not integer multiples.
- chongli 6y ago
  It does sound like a lot but it depends on the actual wall clock time. If your run time goes from 10 days down to 1 day then yes, it matters a lot. If it goes from 1s down to 0.1s it might not matter so much.
  - carlmr 6y ago
    Of course, but if you observe 3x to 10x performance gains across the board, you will have some programs that run in more than 1 second where it may be worthwhile.
dfgdghdf 6y ago
I would call that a huge performance gain! Perhaps Julia can be chosen for new projects; it is rarely worth rewriting old ones.
shiftingleft 6y ago
I guess whether it's effective to migrate a code base depends a lot on where your costs are. If you pay 500k$ for compute, it might become worthwhile to invest time into rewriting hot paths.

sgt101 6y ago

Julia is way superior if you are building programs and systems, especially if you are building for sustained use (rather than something to do a job once). Julia is less error prone, more expressive, more maintainable, more performant. But if you are creating cut and shut scripts for data science notebooks Python wins... the repl start time alone is a killer for Julia, add in the requirement to actually think about structure and the problem and it's out of my "3 -> 6hr" workflow.

fsh 6y ago
Julia is amazing for numerics, but the JIT is painfully slow for anything that gets looped only a few times or not at all. I don't think it is usable as a general purpose language until this gets improved somehow.
- sgt101 6y ago
  But is that a problem apart from in scripting? If you ain't looping you ain't waiting in my experience.... Can you give an example which isn't time to plot?
  - fsh 6y ago
    I think that a slow JIT is problematic in any application except for non-interactive numerical calculations. For example in a GUI software or in a server application it would be very undesirable to have each function run a million times slower the first time it gets called.
    - sgt101 6y ago
      For GUI's I don't see this as an issue - JITs run alot faster than humans. All of Javascript is on a JIT - and thats the dominant UI for now! For servers generally you find that users are all calling the same function so it's very rare that you hit a blip - much more commonly users get performance problems from something else in the stack like the network or the client, and while Javascript is the dominant front end the dominant back end for servers is Java and that's got a JIT as well.

jpfr 6y ago

I teach a graduate course in optimization methods for machine learning and engineering [1,2]. Julia is just perfect for teaching numerical algorithms. First, it removes the typical numpy syntax boilerplate. Due to its conciseness, Julia has mostly replaced showing pseudo-code on my slides. It can be just as concise / readable; and on top the students immeditaly get the "real thing" they can plug into Jupyter notebooks for the exercises. Second, you get C-like speed. And that counts for numerical algorithms. Third, the type system and method dispatch of Julia is very powerful for scientific programming. It allows for composition of ideas in ways I couldn't imagine before seeing it in action. For example, in the optimization course, we develop a mimimalistic implementation of Automatic Differentiation on a single slide. And that can be applied to virtually all Julia functions and combined with code from preexisting Julia libraries. [1] https://www.youtube.com/playlist?list=PLdkTDauaUnQpzuOCZyUUZc0lxf4-PXNR5 https://www.youtube.com/playlist?list=PLdkTDauaUnQpzuOCZyUUZ... [2] https://drive.google.com/drive/folders/1WWVWV4vDBIOkjZc6uFY3nfXvpaOUHcfb?usp=sharing https://drive.google.com/drive/folders/1WWVWV4vDBIOkjZc6uFY3...

awefasdfasdf 6y ago
Small aside. Do you use the beamer package for your slides?
- jpfr 6y ago
  Yes. Beamer LaTeX with the Metropolis theme and Fira Sans as the main font.
  - dm319 6y ago
    Those are beautiful slides.
i_am_proteus 6y ago
This. Julia's combination of human-readable pseudocode-like code and speed makes it perfect for these applications, and seems to be driving adoption.

sradman 6y ago

> It will be important for it to be adopted as a first-class target language by CPU/GPU vendors.” I’m not sure what the Apple M1 SoC with AMX [1] means for Julia within the Apple ecosystem. [1] https://news.ycombinator.com/item?id=25801500 https://news.ycombinator.com/item?id=25801500

KenoFischer 6y ago
I'm expecting somebody to add them to LLVM soon. I'd talked to folks at Apple about that some time back, but they weren't able to tell me at the time what their plans were for adding it. That said, I am fully expecting them to just add it to LLVM themselves. If not, somebody in the community will do it. Once that's done, Julia will just pick it up.
- rovr138 6y ago
  This is interesting to hear. Thank you Keno
- sradman 6y ago
  > add them to LLVM soon I’m not sure what “them” is. Apple has AMX, a Neural Engine, and a GPU which are abstracted through the Core ML and Accelerate libraries. AMX is not exposed as an instruction set like NEON. I guess this question applies to all of the numerical analysis tool chains: will they be able to leverage Apple silicon coprocessors/accelerators?
  - KenoFischer 6y ago
    I was talking specifically about the ARM ISA extensions. The accelerators are a different question of course. I understand the folks working on the Linux port are trying to reverse the GPU ISA. Apple could of course also just publish that, but I'd put the odds on that lower than the ISA extensions. That said, Apple has sometimes surprised me on these kinds of things.

anothernewdude 6y ago

No. It fails some very simple hurdles that are now fundamentally never going to change.

Guthur 6y ago

Ahem no. Going by Tiobe there is gulf between the top 4 languages and everything else. To put it into perspective Julia is only twice as relevant as Prolog and on par with Scratch. Of course I don't necessarily think Tiobe is a great metric for this but it was quoted in the article.

metreo 6y ago

Julia is simply a _much_ nicer to write lang than Python, it is more functional and it provides the user with far more ways to be expressive. I think the JIT warmup is less of an issue than its overall memory use but I can see that the former is more apparent to the average user sitting at their terminal. I wish we would see a larger fraction of the energy invested into propagating the 'Pythonic' approach were _properly_ redirected into improving relevant aspects of Julia.

qaq 6y ago

On what time scale? Julia is really nice lang. but it will take decades for it to put a serious dent in Python. If web side of things matures fast and someone builds a killer framework it might carve out a niche there too.

veddox 6y ago
It's not meant for web, it's meant for scientific computing. And it has already left a mark on that field.
- ku-man 6y ago
  Then Julia should stop describing itself as a general-purpose programming language.
  - veddox 6y ago
    I think its website makes it pretty clear that it's mostly targeting scientists... https://julialang.org/ https://julialang.org/, https://docs.julialang.org/en/v1/ https://docs.julialang.org/en/v1/ (The first two words of the Introduction are literally "scientific computing".)
  - StefanKarpinski 6y ago
    Julia absolutely is a general purpose language and has been from the beginning. However, there are plenty of languages that are fine for building websites, whereas there are no other languages with the combination of speed and usability that Julia offers in technical computing. It's a lovely language for doing all kinds of work and I personally mostly use it for non-technical computing these days — specifically to implement package management client/server infrastructure, which is mostly web + file system wrangling.
    - veddox 6y ago
      Oh, hello, interesting to see you here :D Perhaps you ought to say that you're a co-creator of the language...

pansa2 6y ago

I don’t know whether Julia will succeed as a general-purpose language, but its design seems ideal for numeric code. In particular, multiple dispatch makes operator overloading so much nicer than Python’s fragile “dunder” methods like `__add__` and `__radd__`.

lukeitup 6y ago

Python > Julia, currently not even a contest

rovr138 6y ago
This depends on the task/problem/project.

kitsune_ 6y ago

It's nice imo, the precompilation step is a bit slow imho. Also not sure whether I'm a big fan of its module system.

shmeano 6y ago
The precomp step will speed up significantly and move to pkg install time in the upcoming 1.6 release. There's a beta out if you want to try

mkl95 6y ago

Python has a battle-tested, humongous standard library, and a rich ecosystem. It is easy to learn and it's great at gluing every day stuff. Data scientists like it, engineers like it, even the cashier at Lidl likes it. I can see how Julia may challenge Python for academic use, but challenging Python in 2021 for industrial use is no joke.

dunefox 6y ago
> Python has a battle-tested, humongous standard library, and a rich ecosystem Use it then: https://github.com/JuliaPy/PyCall.jl https://github.com/JuliaPy/PyCall.jl

kuter 6y ago

Julia uses modern compiler technology to achieve close to native performance. This is not just generating LLVM IR. Julia also has it's own optimization system for language specific optimizations that LLVM struggle to do (due to language specific info getting lost in conversion to LLVM IR). Google's V8 (js interpreter) also uses modern compiler tech but I think it is not as capable as LLVM optimization vise (I don't think it is designed to be). Python will either adapt or perish. Even if it is not julia it would be a another language.

pansa2 6y ago
V8 and the Julia compiler work in quite different ways - because they solve quite different problems. In particular, Julia’s compiler only works well on code that is "type-stable", whereas V8 has no such limitation.
- kuter 6y ago
  I know that V8 does some interesting stuff with it's types. Julia's creators considered supporting optimization while designing the language. Whereas the first javascript engine that even generated machine code came much later it's creation. Js has weird features like being able to set a getter function to a array index. There was a memory corruption bug in V8 that the implementation of `Array.sort` would call a getter function in the array that would change the size of the array causing a memory corruption. This was used in a exploit. Creators of V8 created a domain specific language called Torque to implement the language lol.

ajankelo 6y ago

Julia is fantastic with a great community. The one issue I have though is the use of greek symbols, while great for those formally trained, may have a negative impact on wider adoption for deep learning.

chrispeel 6y ago
I don't think Julia requires you to Greek symbols, rather it allows them ;-)
DNF2 6y ago
Python also allows Greek letters. There are no Greek letters forced upon you, they aren't even used in Base, and barely if at all, in the stdlibs. It is a feature for you to use, if you want. (And they dramatically improve code readability in heavily mathematical code.)

D13Fd 6y ago

It’s extremely silly, but I don’t really like the name Julia for a programming language. It’s just a bit uncomfortable to have a programming language with a particular, kind of formal-sounding human name like Julia (or like Michael, Lauren, or Jonathan). It just feels weird to me. I know a number of people (family, friends, colleagues) named Julia. I honestly think it could have an effect on adoption. People have to say the name a lot in making a choice to adopt a language for a project. Names like C, C++, Java, Python are fairly neutral. “Julia” is just an awkward name in this context, in my opinion.

mhd 6y ago
What about "Ada", "Miranda" or "Haskell"? First names, too, albeit ones much less common these days. ("Linda" the language isn't even in that category, popularity-wise, although the source of the name seems to be a weirder story)
- D13Fd 6y ago
  I had no idea that “Ada” and “Haskell” were intended to be people names. Those are not super common names. And I had totally forgotten about Miranda, which I agree has the same issue.
  - Jtsummers 6y ago
    Ada was named after Ada Lovelace, for context. And it’s definitely not a common name anymore, at least in the US. It dropped off significantly through the 20th century with a spike several years ago.
  - mhd 6y ago
    I see, that's what I thought. No problem with naming languages after people, but it's easier if it's an homage to a certain person. Common first and last names alone often point to confusing people, and there might be a certain dissonance between the mental images ("I pulled some Julias pigtails in kindergarten, now I have her name on a CV?"). The same problem would probably arise if the last names would be more common, too. "Pascal" and "Turing are probably rare enough ('though "Pascal" was a bit in fashion as a boy's name in Germany when I was young).

querez 6y ago

I'm a researcher, doing lots of numerical work both professionally and in hobby projects. While Julia has a lot of technical merits, there are just some superficial, syntax-level design decisions that strongly rub me the wrong way: 1-based indexing (makes interfacing with C code hard), explicit begin/end (verbose & ugly) and column-major indexing (personal preference). I understand that these follow in the footsteps of Fortran (and matlab), but they always feel wrong to me. I grew up on C-based languages, and these things made working with R and Lua difficult whenever I had to interface with any non-numerical code (which somehow even most of my research projects ended up needing). It's a weird hill to die on, but I personally will avoid Julia (and actively discourage students from using it, in case I need to work with their code) for as long as I can due to these design decisions.

kescobo 6y ago
Who am I to say what hills are worth dying on? But I don't want you to die at all - in case you're ever compelled to switch, I can't help you with end, but OffsetArrays.jl can help with your indexing woes, and I think there are packages to rotate matrices too (though not certain of that).

amelius 6y ago

My gripes, feel free to disagree: 1. Julia uses base-1 indexing. 2. Julia uses an "end" keyword everywhere, which is imho too verbose (and the corresponding "begin" is missing so it's inconsistent).

jakobnissen 6y ago
I would argue that if those really are your major gripes about Julia, you either have very bad priorities, or don't know enough about Julia to contribute to this conversation.
psychometry 6y ago
If 0-indexing hadn't been the default for so many programmers for so many years (usually because the languages being used required actually thinking about arrays in terms of memory offsets) then it would feel very odd. Humans reason about counting in terms of the natural numbers, so 1-indexing is fine. Just ask any beginner CS student what they think of 0-indexing if you doubt this.
veddox 6y ago
I don't like those two either, but that doesn't change the fact that the rest of the language is absolutely ideal for what I do ;-) (ecosystem modelling)
dgb23 6y ago
Disclaimer: Not a Julia user. 1. Base-1 indexing is more natural and less verbose. My suspicion is that base-0 indexing grew out of language implementers wanting to reduce their mental overhead rather than a first-principles approach. AKA machine code leaking out to the higher level languages. 2. You have to have some way of structuring syntax. Whether you have "end", ")" or "}". It is not inconsistent to start with something else, like a function signature with the corresponding keyword. Again Julia opts for natural readability. Both of these complaints are rather superficial anyways. Julia is a marvelous piece of tech and has an interesting story to tell about type inference, multiple dispatch, performance, data-structures, general Lisp-yness and the merits of tailoring a language for a purpose/domain (and its users) in contrast to trying to adhere to paradigms and programmer culture (cults?).

dan-robertson 6y ago

I’ve used juli a few times over the years. For some numerical things it’s nice with easy interfaces to modern algorithms. I solved a differential equation recently and it just worked. And Julia feels like a much more proper programming language than matlab. At the lower level (which I haven’t looked at in a while so may have changed) I found it a bit confusing and messy. The subtyping and method selection are tricky to get right and they are fundamental to important parts of the language like it’s numeric tower. But libraries seem to just work. Macros were horrific and the ast is inscrutable and liable to change from one version to the next. Quasiquoting was also tricky. So I wouldn’t recommend trying to do anything weird with them. But maybe they are good now. Pluto notebooks seem a great concept. I tried them recently and mostly they worked (sometimes they didn’t get dependencies right but it’s still beta). I felt like I was fighting a bit with plots.jl. I don’t know if there are things that weren’t obvious to me that I was missing or if it can just be a bit annoying. I haven’t tried gadfly but I would like to at some point. I’ve heard good things about ggplot2 which it is inspired by. I felt like documentation was a bit lacking in good straightforward tutorials and examples. As well as documentation in general. But I don’t want to put too much emphasis on that.

xvilka 6y ago

If you want to help the adoption of Julia in the bioinformatics and medical applications - feel free to support BioJulia[1][2] on their OpenCollective page[3]. During the times of pandemic projects like these are of the special importance. [1] https://biojulia.net/ https://biojulia.net/ [2] https://github.com/BioJulia/ https://github.com/BioJulia/ [3] https://opencollective.com/biojulia https://opencollective.com/biojulia

salt-licker 6y ago

Julia’s type system is not particularly user-friendly. For example, it has both a “String” and a “SubString” type which cannot always be interchanged. Their language design seem to be much more concerned with execution speed than programmer productivity — Python has the balance in the opposite direction, but they’ve been gradually improving performance for years, and this is much easier to improve after the language design is set in stone, especially as more and more people add typing info to their programs. Also, 1-indexed arrays are a major turn-off.

stabbles 6y ago
julia> supertype(String) == supertype(SubString) == AbstractString true If you insist just use f(s::AbstractString)
oivey 6y ago
I’ve generally found they can be interchanged in the way you would expect as a Python user: duck typing. I have more experience using SubArrays, but I think the underlying machinery in the language is basically the same. Adding performance after the fact is not easy. This is why most numerical Python projects depend on C extensions rather improvements to the Python runtime. Writing C extensions or jamming your algorithm into the shape of existing C accelerated APIs is often not very time efficient.
huitzitziltzin 6y ago
IMO, array indices are a matter of taste which inspire feelings of religious intensity. You can change it if you prefer 0 or -14 or whatever number you like. Non zero effort is required, but if you otherwise like the language it can be changed AFAIK https://docs.julialang.org/en/v1/devdocs/offset-arrays/ https://docs.julialang.org/en/v1/devdocs/offset-arrays/

Xcelerate 6y ago

I’m amazed how many people are defending Python. It’s such a kludgy language. I’m curious what the Fortran holdouts said back in the day.

eigenspace 6y ago
The better comparison is to Perl. Everyone used to say that there was no way Python could replace Perl because Perl had such a big ecosystem.
pauljurczak 6y ago
> what the Fortran holdouts said back in the day. Fortran holdouts say today that there is still no competition to Fortran for optimizing code in multiprocessing/supercomputing environment and no volunteers to rewrite tons of proven and optimized to the extreme numerical and physics code in another language. Good, old languages die hard...

tpoacher 6y ago

I don't want to disparage Julia, it's actually a very nice language, and I was very excited to learn it a couple of years ago. But, honestly, I think their adoption at this point is less "linux-like" driven and much more "apple-like". In that, the language is 'ok', but the company is going to INCREDIBLE lengths with respect to shrewd marketing and buzz-creation at this point. Which is admirable but also kinda worrying at the same time.

eigenspace 6y ago
Very little Julia hype comes from JuliaComputing. The buzz you see is almost all from people who switched from other languages and found that Julia was a gigantic breath of fresh air. I can say that for me, it completely changed my attitude towards programming in general. Before, programming was something I did sometimes as part of my physics research. Now, it’s also my hobby that I probably spend too much time on. It’s hard not to get a little evangelical when you go through a change like this.
StefanKarpinski 6y ago
This "Julia marketing conspiracy theory" that many people on HN seem to believe is so bizarre. What big tech company do you think is behind this incredible, shrewd and presumably well-funded marketing campaign? Julia is the only new major programming language of the last decade that doesn't have a major tech giant backing it. Adoption and development are pretty much entirely grass roots. If you see a lot of enthusiastic posts about Julia on HN, that's because there are a lot of actual people out there using Julia who love it and write posts about it.
- ChrisRackauckas 6y ago
  Poor Go, Dart, Swift for Tensorflow. How is Google going to compete with Julia Computing in terms of marketing and advertising?
- oxinabox 6y ago
  Trying to think of others. Kotlin was 2011, and is JetBrains. JetBrain's is 1500 people. So big, but not giant. Rust is 2013 Mozilla is only 750 people So perhaps Major Tech Giant is over-stating it. But definately most other things in the last decade have a major established tech firm backing it. Julia has basically nothing. Starting out as a MIT project, and then Julia Computing is a tiny startup; with like what 50 people now?

laichzeit0 6y ago

Is it correct to state that in 5 to 10 years we’ll see Julia as the default for new Data Science projects? (ML and statistical inference). I’m not a biggie on switching tool sets just because something is becoming “hot”. I like to start using something when it’s boring and battle tested, the youngsters can do the bleeding. But it seems like the likely candidate if something is going to displace the Python and R ecosystem?

oivey 6y ago
I’m a huge Julia proponent (and before, a huge Python proponent over Matlab), but I would be careful about claiming that Julia will be the coming standard. Python has a crazy amount inertia and excellent projects still in the pipeline. I think Julia will eventually win because writing your code in one language which isn’t C or FORTRAN is extremely productive and leads to much more composable libraries. The progress that’s been made on, for example, deep learning frameworks is impressive given the lack of massive investment from FAANG. I hope this leads to it dethroning Python, but it might not. If anything will, I think it has the best chance. I’d suggest you give it a try anyway because its really not a hard language to learn. The ecosystem itself is quite good. The fact that you can write fast code without C extensions leaves you less dependent on the ecosystem, too.
evgen 6y ago
> Is it correct to state that in 5 to 10 years we’ll see Julia as the default for new Data Science projects? No, it is not correct to make this claim. Nothing is going to de-throne Python in the next five years and it is EXTREMELY unlikely that anything will de-throne it in 10 years. Any language that replaces Python in these tasks will need to be significantly better, and Julia just isn't that. Incremental improvement in a few areas that reek of premature optimization is not going to be a compelling argument for the masses. The language that de-thrones Python has not been invented yet, and it will probably need some sort of hardware-coupled advance to have a chance (e.g. if the next big leap in mass-produced hardware were to drop 4K cores into a cheap SoC then a simple scripting language that handled internal data and execution concurrency might take over.) Julia is nice, but if anything you are probably going to see more migration from MATLAB and similar older dead-ends to Python over the next five years than you are to see migration from Python to Julia.

x43b 6y ago

Any recommendations on beginner (to Julia) books to get started?

forgotpwd16 6y ago
The manual is great https://docs.julialang.org/en/v1/manual/getting-started/ https://docs.julialang.org/en/v1/manual/getting-started/. If you want something more step-by-step with some simple exercises, check https://benlauwens.github.io/ThinkJulia.jl/latest/book.html https://benlauwens.github.io/ThinkJulia.jl/latest/book.html.
- x43b 6y ago
  Thank you. I will look through both.

Const-me 6y ago

I wonder can I compile Julia code into a Windows DLL? For instance, with AVX2 and DirectCompute included? Currently writing C++/17 and HLSL. Would like to evaluate something higher-level. However, I think it’s unreliable in the long run to redistribute and support complicated packages like Python runtime or LLVM. Users mess with environment variables, update Windows, run antimalware, etc. Process startup time also matters, I don’t want to wait 40 seconds for the first output.

huitzitziltzin 6y ago
Not sure about your exact use case and this is not part of Julia which I have ever used myself but the answer might be here: https://github.com/JuliaLang/PackageCompiler.jl https://github.com/JuliaLang/PackageCompiler.jl There is a presentation from a recent JuliaCon by Kristoffer Carlson on the topic too, I believe. https://m.youtube.com/watch?v=d7avhSuK2NA https://m.youtube.com/watch?v=d7avhSuK2NA

phonebucket 6y ago

Julia offers a wonderful modular ecosystem. This is in no small part due to a clever design decision of language design of combining type genericism with multiple dispatch. For example, Turing.jl for Bayesian Inference plays well with Flux.jl for Neural Networks which plays well with DifferentialEquations.jl for ODEs. Basically, everything in pure Julia plays nicely with everything else. An example of how this useful: when neural ODES became more popular a couple of years ago, Julia users had to do almost nothing to implement them and extend them. DifferentialEquations.jl and Flux.jl already played nicely with each other, and you could just run wild. Meanwhile, in Python-land, there are devs building out ODE solvers built in Tensorflow and Pytorch, doing a load of duplicate work because the frameworks don't allow the same level of genericism. The whole ecosystem is like this. So I've decided to stay with Julia. I'm staying with Python too. It's no big deal.

alper111 6y ago
This seems very desirable. Though at the moment, when the self-attention got popular for the first time, it was already available in PyTorch. Python seems to have the edge just because there are lots of people using it. Maybe it is just a matter of time and users. Probably I will wait until the ecosystem gets larger, and then switch to it. (Yes, I am a lazy person to implement a transformer from scratch)
- BadInformatics 6y ago
  If NLP primitives are all that's keeping you from testing the waters, have a look at https://github.com/chengchingwen/Transformers.jl https://github.com/chengchingwen/Transformers.jl.

laplacesdemon48 6y ago

I've been using R nonstop for pretty much 5+ years. I'm happy that there's established competition coming from Python and new competition coming from Julia. Having these languages compete over similar types of programmers pushes each one to be better, which is awesome. I'm not a die-hard R person, I'd be more than happy to switch under the right circumstances. But...I think one thing gets overlooked way too often. For "data scientists" or "statisticians" or [insert new term here], the majority our non-modeling time is spent on just plain old data wrangling. To me, R is unbeatable here. I've tried Python ~2 years ago and pre-1.0 Julia. Using tidyverse you can do pretty much anything to any dataset, often *without a monstrous amount of keystrokes*. (The pipe syntax is awesome). If you really need speed you can always switch over to data.table for uglier but faster code. I really tried but I could never replicate the "brain cycles to keystrokes" speed of R in Python/Julia. That is, being able to intuitively and quickly just convert my thoughts into readable data wrangling code. Sure the base R language is not that "fast" and Julia/Python benchmarks are way faster. But in practice this doesn't matter to me. Most of the performance sensitive packages are written in C/C++/Fortran anyway (rstan, brms, glmnet, caret). I don't care that I could write 3x faster loops. The extra 5 seconds for that one piece of code doesn't make up for the absence of a good data wrangling ecosystem. My message to the Julia team: You can get a very large portion of the R userbase to switch over if you focus on a Julia version of the tidyverse (especially dplyr). I know that DataFrames.jl exists but it just doesn't even come close. There's a difference between "you can do this in Julia too" and "here's a clean/intuitive way to do this better without extra baggage". I'm sorry if the above seems harsh. I genuinely appreciate the Julia team's efforts. I can only imagine how hard it is to create a new language. I just wanted to be honest.

tikej 6y ago
I also like pipe syntax and I've found there is nice support for it in Julia. There are some nice packages to improve it over base [1]. Have you checked queryverse [2]? [1] https://github.com/jkrumbiegel/Chain.jl https://github.com/jkrumbiegel/Chain.jl [2] https://www.queryverse.org https://www.queryverse.org
- laplacesdemon48 6y ago

barfoobazy 6y ago

<clicks link to article> <clinks linked press release with the data> “Python is the 2020 Programming language of the year!” <logs off>

twobitshifter 6y ago

I have been using Julia only for a few months, but I’ve been surprised in the speed up that’s possible vs python code using pandas. Depending on the size of your datasets the JIT might slow you down a little, but the speed of Julia outweighs this. Liberally using functions really allows Julia to shine. One thing that I’ve recently seen which concerns me long term is the creation of various competing macro syntaxes for reducing the wordiness of Julia. There are many competing implementations of pipes and other syntax sugars. These macros definitely make things easier, but as you use them the code becomes more difficult for another to understand and since there is at this time, no one set of macros to use, you’ll have to know each of the competing sets to make since of examples.

krumbie 6y ago
I have created one of the recent competitors in this space [1], and I think it's not so bad, as long as the macros are reasonably simple to understand. If you look in the readme of my project, the four syntax examples actually look quite similar so I don't anticipate they'd cause a lot of confusion. When I got annoyed in my own work that some data wrangling syntax was repetitive I was just really glad that I could easily build my optimal solution and didn't have to just accept that there's one suboptimal (for me) way. In Python and R, if you like what they offer that's good, if not - not so good. Part of the problem comes from Julia not being geared towards DataFrames like R is, but I gladly trade a bit of convenience in one domain against a lot of expressive freedom with very clean rules that apply everywhere. For example, I think it's quite good that you can only have "weird" behavior in Julia with macros, but they give you a visual indicator with the @ that you're seeing non-standard syntax. While in R, the non-standard evaluation means that literally anything could happen to the variables you pass into any function. It makes for some convenient syntax in some cases, yes, but it's so confusing as a system for writing software! You never really know if you're looking at a variable or just a name, for example. [1] https://github.com/jkrumbiegel/Chain.jl https://github.com/jkrumbiegel/Chain.jl

dopu 6y ago

I'm a graduate student that's switched almost completely over to Julia. Prior to it I worked in both MATLAB (the IDE is so nice, and writing out matrix computations is just great) and Python (for ML). Julia is absolutely nicer to write in than either of the two. MATLAB is slow and at times feels less like a programming language and more like an incomplete and brittle interface with the JVM. Python is also slow, and it feels awkward to use given that it was not explicitly designed for scientific workflows. With Julia I get proper typing, incredible speed, easy parallelization, and a kick ass REPL. The only thing I truly miss in using Julia is the plotting capacities of MATLAB. I haven't found an environment that can match it in terms of interactivity. Give me the ability to (easily) save interactive figures for later use and Julia would be perfect.

StefanKarpinski 6y ago
Out of curiosity, have you tried using Plots.jl from VS Code? If so, what's missing from that experience?
- dopu 6y ago
  I have, though I've mostly stuck with the plain PyPlot.jl package due to the familiar syntax and interactivity. Perhaps things have changed, but I just recall being frustrated at the inability to zoom in/out, and again save interactive figs. Perhaps it was just due to the particular backend I was using. I'll give the VS Code experience another try!
superdimwit 6y ago
I would recommend Plotly.js in VSCode for interactive plotting.
- dopu 6y ago
  Wow, I just tried it out. This is really great. And it solves my interactive plot saving requirement. Easy as doing `Plotly.savehtml(fig, "test_fig.html")` :). Thanks!
- skybrian 6y ago

jti107 6y ago

"I saw the 87 percent increase and think it is wonderful to see Julia growing. I think that Julia has great potential to replace C/C++/Python (and of course Fortran) in scientific and technical computing as it matures." its really all about the ecosystem, community and ease of use. python took off once people developed numpy, pandas, Anaconda, etc.

krumbie 6y ago

The comparison between different languages gets tiring when it focuses on making a black-and-white statement like "Julia is better" or "Python is better" and "x is never going to overtake y". Yes, Python has many more libraries thanks to it being much older than Julia, same for R. But at the same time, Julia can be used for impressive work that R/Python struggle with and which only seem solvable in these languages because of large investments into certain packages by big companies. So I find the fact that many hard problems can be solved very generically and performant with small libraries written in Base Julia much more interesting than countering that much larger and older Python packages with millions of developer hours poured into them are currently more feature-complete. Yes, they are, right now. Why wouldn't they be. But does what is being done in Julia with much fewer resources not point to an impressive ability of the language to facilitate such development?

disgruntledphd2 6y ago
While I generally agree with your argument, it's worth noting that the median Julia programmer is probably more invested in the language/ecosystem than the median R/Python programmer. Back in the mid-90's Java was the new hotness, and it probably made problems that required 100+ lines of C easier, but it's not still full of above-average programmers, as any language/ecosystem that achieves success will inevitably regress to the mean.
- krumbie 6y ago
  That's true. I am of course biased in talking mostly to people on the Julia Slack etc. who enjoy the language a lot and do interesting things with it. That's one of the reasons, though, why I never find the "how many people are using it" argument the most convincing when talking about the merits of a language. Because most people I've seen using R, Matlab and Python, at university or work for example, used it really superficially, and therefore wouldn't have any interesting things to say about it. Neither do they add anything interesting to the respective ecosystems. I don't think it's the first interest of a new language to get this type of user, although of course in the long term you want to build tools that are easy to be picked up and used by a wide audience, and number of users is some indicator of that.

causalmodels 6y ago

Can anyone recommend some good resources to learn Julia? I am hoping there is something akin to the Rust Book [1] since watching youtube videos is too slow and the exercism option listed on the website is too cumbersome. [1] https://doc.rust-lang.org/book/ https://doc.rust-lang.org/book/

dunefox 6y ago
This might be helpful: https://benlauwens.github.io/ThinkJulia.jl/latest/book.html https://benlauwens.github.io/ThinkJulia.jl/latest/book.html
- causalmodels 6y ago
  This is perfect, thank you so much! I'm a bit surprised julialang.org only links to a the oreilly store page. Seems like you would want to call attention to a resource like this.

antpls 6y ago

> "Because Julia’s compiler is different from the interpreters used for languages like Python or R, you may find that Julia’s performance is unintuitive at first. If you find that something is slow, we highly recommend reading through the Performance Tips section before trying anything else. Once you understand how Julia works, it’s easy to write code that’s nearly as fast as C." If Julia needs a "Performance Tips" section to produce fast code, I might as well use Python. The "speed" from Julia comes from LLVM, but there is nothing stopping Python to use LLVM as well where it _makes sense_ (which is the case with XLA in TensorFlow, for example). I see no plus value in learning Julia over existing tools, there is nothing revolutionary or nothing that could alleviate future risks.

snicker7 6y ago

The most important aspect of any language are the trade-offs and values held by the designers and community. Julia takes a zero-compromise oath to approachability and performance. Julia is not (yet!) a perfect language, but those values make me want to invest in the ecosystem.

septc 6y ago

I'm interested in the following example (3x speedup), and is it possible to read more details about their project? (From the hpcwire article) "During his talk, Edelman presented an example in which a group of researchers decided to scrap their legacy climate code in Fortran and write it from scratch in Julia. There was some discussion around performance tradeoffs they might encounter in the move to a high level programming language. The group was willing to accept a 3x slowdown for the flexibility of the language. Instead, said Edelman, the switch produced 3x speedup."

mapledipdonut 6y ago

I recently decided to port some of my Python analysis code over to Julia since I've been doing a lot of ODE stuff lately. Overall I'm liking it, but I've found a couple things frustrating: 1) the docs and online issues/answers are a bit of a mess, partly because many of the accepted answers are from pre-1.0 days; 2) the error messages I've found are long and not very helpful. It takes much longer to track down a bug in Julia than Python code.