I agree that something like Julia vs. Python + libraries written in C++ seems like a better fit. However, there is such a vast wealth of tooling around Python, and high level development services like Huggingface, that for the foreseeable future, Python dominates.
I think Julia has a pretty good path forward since it is often faster than C++ (especially once you consider language interop overhead), and it is much more pleasant to write than c++. Since Julia and most of the packages are written in Julia (for the most part), Julia makes it really easy for users to become developers. Python and R have much bigger barriers to entry since users will usually hit a binary blob, which makes it much harder to interact with library implimentations.
Theoretically Julia is better for scientific computing, the only issue is its package ecosystem isn't as mature as Python's. But it's growing incredibly fast and there have already been libraries available for a few years that would be really impractical to write and maintain at such a level in C++ for Python. I assume that for science at least Julia will catch on a lot.
Python (with all the bells and whistles that interop with C/C++ like numpy, pytorch, tensorflow, numba, cython...) is very performant
I know. I spend much of my days writing 'high performance' Python, and Python is still my go to tool for just about everything. Julia's big advantage is, kind of like Fortran vs C back in the day, that it's fast even if you're just writing things in the most obvious and natural way for your domain.
Yes Julia is interesting, but for most use cases the languages is (to my knowledge) still significantly slower than C, while not having the great library ecosystem that e.g. Python has. This might change in the future though, and I know that really bright people like Stefan Karpinski are behind the language, so I'm sure it might become a serious contender to Python in the future.
Julia is fast but not faster and very memory hungry. If you care about squeezing every bit of performance you generally go to C++. If you too lazy for C++ you go D.
Hence to me, Julia is an odd tool. Interesting but more as a language with some cool scientific libs that Python might not yet have.
I took a look at Julia a couple years ago. As far as I could see, the only reason to consider it over python is the speed improvements, and if I'm in a situation where python isn't fast enough, I've already got c, c++, and java to reach for. (Also at the time the library support was lacking (I just checked and the graphs package, which I needed at the time, is still pretty minimal)).
Is this a personal or business decision you are talking about?
Can you elaborate the cons that made you decide to move away from Python, C++, and Julia?
Julia makes sense to me, as the youngest production language and community.
But Python? It is the #1 most popular programming language globally. C++ is also very popular. This means you can easily find people to hire globally (making business easier and more economical). You can also easily find code doing almost anything you want---speeding up time to value and time to ship.
I'm wondering what cons are driving your decisions to move on from Python and C++?
Julia is much, much faster than Python. For numeric code it's almost as fast as C++. They've used lots of cool tricks to become crazy fast on numeric workloads. It's also definitely got support for multithreading, clusters, etc...
Julia was written in C++ in early stages if I remember correctly then Julia ;) The point here is that NumPy is heavily fine-tuned and will beat almost any other language implementation out there. The community is bigger and therefore there are much more free hands.
Complexity matters. Python originally had success because it was easy to use. It was one of the first languages I learned after C++ to just get stuff done.
People are not leaving Python for Haskell, Rust, Swift and Scala because those languages are too complex to deal with.
However what we see time and again is that languages that are easy to use and which offer real advantages gain adoption. Look at the rising popularity of Go as a good example.
This is why I belive Julia has a real chance against Python. It hits all the right checkboxes: It is easy to learn, simple tools, while also being highly productive and giving great performance.
Sure Python is not suddenly going to get knocked off the crown. But the fact is that Julia has far more growth potential. Packages are built faster as there is no need for C/C++. Packages are combined way easier due to multiple dispatch and lack of C/C++ dependency. This is a hard one to explain in a short text but Julia has a unique ability in how packages can easily combine. Hence with a couple of Julia packages you get squeeze out the same functionality as a dozen Python packages.
Julia is probably the most likely competitor for Python in the data science space. It's designed for such use cases and it's very good at it.
Still, Python does have so much momentum that it's almost certainly going to continue its rise. But other languages can still succeed, the ecosystem doesn't need to end up as winner-take-all.
I tried Julia in 2018 as my new programming language to learn that year. The syntax is clean and simple, and I remember it as a "Pascal for scientific computing" - as easy to read as Python yet faster execution.
I liked the static type checking and compilation, but found it frustrating at the time that the sample code from a book I had purchased didn't work; overall, the language seemed to be still too much in flux to be entrusted with an important project, although I have spoken with fellow scientists who use it as their main language for experimentation and are happy.
Python is clearly winning because most important libraries are C++ under the bonnet - or even Cython (which is used e.g. by SpaCy), and its ecosystem with IPython, Jupyter notebooks and comprehensive data science libraries (pandas, matplotlib, sklearn, numpy, ...).
This is serious nonsense! Julia is way nicer than Python. If Python was faster than Julia, I would still have picked Julia, unless I really needed the performance.
With Julia I get first class meta programming. I get awesome multiple dispatch. I get environments and package system really well integrated. I get awesome integration with the shell. Better module system. More natural syntax for arrays. Much better system for closures. Better named functions.
REPL programming in Julia is just light years ahead of anything in Python. The OOP design of Python really kills the REPL experience.
Unless you are a very skilled C++ programmer, Julia is going to outperform you as the program gets larger. C++ programmers are going to get themselves tangled up when trying to run multi-threaded code, running on multiple machines on GPUs and specialized hardware. Julia does this effortlessly.
C++ cannot do JIT, hence as soon as you deal with complicated machine learning algorithms with custom kernels, C++ is going to tie itself into a knot.
Why do you think large Astronomy projects like Celeste and the next major climate models are built in Julia and not C++? Because developers realized that when you need to run massive calculations on super computers on hundreds of thousands of cores, C++ is going to get in the way.
As for libraries and tools. All the Python tools I have tried to match my Julia tools have just sucked. Julia tools often excel over much older Python tools.
Library development moves much faster on Julia than Python. It is not hamstrung by relying on complicated C++ code based. Also Julia libraries integrate very well, while Python libraries are often their own deserted island. That means a few Julia libraries can do what must be accomplished with dozens of Python libraries.
As far as I understand, Julia is the language that will certainly be a worthy replacement of Python once it gets enough library functionality (I admit actually didn't follow how much it gets, I'd appreciate if somebody writes the current state). It's really nice that it was designed from the start to be fast.
I’m a bit surprised Julia is ranked below Python for how much developers love the language. I’ve programmed extensively in both, and with Julia it’s an absolute joy, while I always feel like I’m fighting with Python to get it to do what I want (efficiently, at the very least).
* Julia is now at the point that it can be used for interactive development and experimentation without time-to-compile issues;
* the Julia ecosystem is coming along nicely; and
* Julia has always provided near-C performance in production.
reply