●Stories
●Firehose
●All
●Popular
●Polls
●Software
●Thought Leadership
Submit
●
Login
●or
●
Sign up
●Topics:
●Devices
●Build
●Entertainment
●Technology
●Open Source
●Science
●YRO
●Follow us:
●RSS
●Facebook
●LinkedIn
●Twitter
●
Youtube
●
Mastodon
●Bluesky
Want to read Slashdot from your mobile device? Point it at m.slashdot.org and keep reading!
Forgot your password?
Close
This discussion has been archived.
No new comments can be posted.
Load All Comments
Full
Abbreviated
Hidden
/Sea
Score:
5
4
3
2
1
0
-1
More
Login
Forgot your password?
Close
Close
Log In/Create an Account
●
All
●
Insightful
●
Informative
●
Interesting
●
Funny
The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
byjythie ( 914043 ) writes:
Python, R, and MATLAB I can see, but C++ kinda surprises me. Maybe it is getting popular among people doing GPU heavy work?
twitter
facebook
bydamn_registrars ( 1103043 ) writes:
Python, R, and MATLAB I can see, but C++ kinda surprises me. Maybe it is getting popular among people doing GPU heavy work?
My guess was most of them learned C++ in undergrad and then started using Julia in their jobs; hence they'd go back to C++ before picking up another language. I guess I could write a Perl script to try to better parse their responses if I can find their raw data anywhere...
Parent
twitter
facebook
bygweihir ( 88907 ) writes:
Python, R, and MATLAB I can see, but C++ kinda surprises me. Maybe it is getting popular among people doing GPU heavy work?
Does not really make sense. Most would get that as a library and creating Python modules in C (or C++) is not really hard.
●ent threshold.
●nt threshold.
byKsevio ( 865461 ) writes:
Probably to pick up a C++ library for faster processing
bygoombah99 ( 560566 ) writes:
Julia is JIT and really emphasizes type. Put those together and you get something that isn't what you expect a typed language to behave like. Specifically you can write loosely, not declaring types if you like. But what happens under the hood is that every time you call the same function with a different type signature it gets re-compiled on the fly. So inside each functions the types are perfectly known and all speed benefits, memory benefits, type safety and dispatch rules work. You just got it all for free even though you are writing as sloppy as python or any duck typed language.
What's even nicer or rather amazing about that is that it doesn't have to know about a type ahead of time when the function is written. So for example, you get nearly all of autograd (automatic differentiation) for free. Every function you ever wrote can simply be passed a new type, a tracked float, instead of a float and it will recompile for that. Or for any mixture of tracked and tracked vars you pass in your call. Thus you don't need to work inside a walled garden like tensorflow types to be able to get this benefit. You already have it without re-writing any code.
This is why hideously complex algorithms that already exist (like say multivariate numerical integration) all can use autograd in Julia but break in python.
Of course you also can write typed code too. In fact all your function declarations and undeclared instantaneous variables already have a type, it's called "Any" type and is the global supertype of all others. But you can declare in the function def or declared variable that it must be an int or a float or whatever. So all typing mechanics is present however much you want to take advantage. Thus for example, all functions can be type signature dispatched.
And finally 1. all the numerical stuff isn't an afterthought like numpy, 2. you don't need bandaids like numba to for optimization and 3. the package maintainer is built into the language so the interfaces are language aware (even so it can also access all of conda or other package managers under the hood as well).
Where Julia drives people crazy is really just one, I think very bad, design choice. For some reason they wanted it to be like Fortran 90 or Matlab. Thus besides idiosyncrasiate like variables can by unicode greek letter, and arrays start at 1 not 0 by default, the really pernicious distraction is that there's no classes.
Really. there's no classes.
It breaks your brain because it does exactly the opposite of encapsulation. For example, normally you'd think that any object should have a "to_string" method so Print statements would be able to call that. In julia, you instead overload the system keyword (like say print) with a function that gets the dispatch when the to_string method would be needed.
At first you just want to slit your wrists. But after a month or so you find this isn't bonkers at all. Indeed it is actually kind of a class after all. It looks like a class. You create a type. then of course you can't do much with it unless you have some type specific methods. So you write underneath that. and after a while it just looks like a Class code block. That to_string method is right there in that code block just like it would be in a class.
So it really looks just like a class. There's just no class keyword wrapping it.
If you are familiar with add-in style of writing python or javascript objects, it looks like that.
And it is way way, way way, way way, more sane than for example C++ with it's bizarro rules about what has to be in the header, what in the .cpp, and how constants get declared in classes. C++ has to be the most brain breaking language ever and people get used to it.
So julia is quite awesome. wickedly fast. Just as easy as python's sloppy type. But it's a rough month to get over the confusion of indexing from 1 and the add-in style of overload based method development.
Julia would be about the perfect language if they had just not tried that matlab/fortran 90 retro style. However I think this probably is also why it works too. Without the class wrapper, all those functions get JIT compiled right not latently like in a class.
Read the rest of this comment...
Parent
twitter
facebook
bygoombah99 ( 560566 ) writes:
In Python if you need high performance the standard is to use things like numpy, scipy, tensorflow etc. There is even stuff like cython to code some performance critical parts in c which don't already have high performance versions.
those are band aids. You can't use any type of variable with numpy, or tensor flow or numba. Those libs have to know the type of the variable beforehand and normally it has to be a type declared in the library or a helper library. For example, Tensor flow can't do autograd on any var that isn't a tensor flow var and and calls the pre-written tensor flow methods. You can't just do a tensor multiply on any type. Julia can. Sure you can flounder around creating your own types that obey the interface for tensor flow but that's throwing the work on to you. When you are lucky someone has done this for you by say teaching tensor flow to dress numpy arrays.
Julia does the work of recompiling the other algorithms for your new type. There's nothing else like it.
Parent
twitter
facebook
byjgfenix ( 2584513 ) writes:
Julia was designed to cater to mathematicians in first place so the arrays that begin with 1 make more sense. In reality 0-based arrays are an unfortunate baggage from an implementation detail in old language. Its more logical to begin to count with 1 than with 0.
It would be very simple to add object notation to Julia to have a.function(b, c, d) instead of function(a, b, c, d). Dylan which is a language with a similar design to Julia has it. This would make the code look more familiar without losing Julias
bygoombah99 ( 560566 ) writes:
sure. Perl has classes too. But it's not really the idiom of the language.
●ent threshold.
byTechyImmigrant ( 175943 ) writes:
Having used Julia, Python, R, MATLAB and C/C++, I cannot see the motivation to switch to R. It's a nasty language. Its main benefit was direct support for statistics that other languages didn't support directly. But that lead has been lost to Python.
byjythie ( 914043 ) writes:
Yeah, learning R was one of the most surreal experiences in my career, and I have trouble picturing why people would use it unless they were coming in from SAS or something. On the other hand I've worked several projects where the other team(s) were really into R, so it seems to appeal to people with certain backgrounds.
byTechyImmigrant ( 175943 ) writes:
I was using it to do some statistical tests my wife needed when she was doing her PhD. The alternatives used in the department were SPSS and SAS which were GUI driven statistical packages for people who can't program. Those packages could not do MANOVA (Multivariate ANOVA). R could. I didn't think it was going to be a big thing, but of course a boat load of data-handling cruft grew up around the core analysis code. R had horrible data handling features. I ended up formatting data in python to make the R cod
byJenineOnlyy ( 7174607 ) writes:
Hey... My pussy gets so wet, look at .... Wanna come inside? >> kutt.it/KQWC8j
●nt threshold.
There may be more comments in this discussion. Without JavaScript enabled, you might want to turn on Classic Discussion System in your preferences instead.
Slashdot
●
●
Submit Story
It is much harder to find a job than to keep one.
●FAQ
●Story Archive
●Hall of Fame
●Advertising
●Terms
●Privacy Statement
●About
●Feedback
●Mobile View
●Blog
Do Not Sell or Share My Personal Information
Copyright © 2026 Slashdot Media. All Rights Reserved.
×
Close
Working...
Working...