Julia from the perspective of a pythonista

Actually I think there is quite a lot of books, videos, tutorials about Julia now. I asked about the Python manual because I have the hypothesis that having an official manual is sometimes playing against Julia, because people get frustrated by how it is written and quit without searching for other sources. The manual perhaps could start by pointing to other sources of information and state clearly that it should not be considered as the ultimate and unique source of learning resources.


Excerism has a julia track.
It is (from what i hear) pretty well regarded
Several members of the community (not me) mentor for it.


Try Julia Academy for some basics, though maybe it falls short of a full “Julia course”. It seems you’ve found the MIT Computational thinking class, which I really like myself (replace “Spring21” with “Fall20” to get to last years one that has completed). I have not tried this Julia course from Coursera since I knew the basics before I discovered it, but it seems to have good reviews (4.5/5 stars). I also was a big fan of “Think Python” by Allen Downey – it’s how I learned classes – and there is an equivalent Think Julia book that is very nice as well.

Though with any training material, be very mindful of the Julia version being used. For instance, “Think Julia” uses v1.1.0, so there may be some syntax differences if you’re on v1.5.3. If you’re not sure of the Julia version, just look at the publication date.


Something like you’ve written here I think should be written in the first paragraph of the Manual, in the “Getting Started” section. And should updated without much ceremony every time a good learning material comes by.


With a background in engineering where I do a fair bit of vibration testing and analysis, some using major packages and some using MathCad, and Matlab, I was attracted to Julia because it is open source, high level, Matlab like, and seems like it has great promise.

My style of learning is to jump in and try something, and then look for documentation, and particularly examples of something similar to what I am doing.

On one project, I wanted to read a data file that the Gantner data acquisition system wrote. I had available a shared library, a dll file that a matlab mex file uses to read the file. Based on this I was able to create a Julia file with many ccalls to read the data file. Another project was to read the MCC 172 vibration data acquisition card with Julia, again using many ccalls to a shared library. In this case, as a new Julia user, I found the manual chapter on ccall confusing, probably because I did not understand all the terminology. More examples, especially the use of Ref{} and Ptr{} would have been useful. I did find Julia discourse most helpful, with a senior Julia expert answering my questions on a Saturday. That was most impressive.

Trying to understand when to use Ref{} and Ptr{} for ccalls was not very clear in the manual. I think I decided that Ref{} is used for scalers, and Ptr{} for arrays. Correct me if I am wrong, and if I am right the manual could be clarified.

One of the styling tips suggests that variable Types be as general as possible for multiple dispatch. Yesterday I was experimenting with passing an array to a function using the most general Type possible. I finally decided that because arrays are passed by pointer, that they need to be very specific when passed to a function. I did not find that discussed in the manual. It probably should have a sentence or paragraph in the styling tips, and also somewhere in functions. Or maybe it is hiding in there somewhere and didn’t jump out at me.

I tried to recreate a Pluto environment I have on a Win 10 machine on a Win 7 machine. Julia runs fine on Win 7, but Pluto was a disaster. There should be something in the Pluto documentation steering us away from Win 7.

I have found MathCad to be a very useful environment for performing calculations as documenting them. The equations look like they would with pencil and paper, but they calculate automatically. The environment is ideal for Roark and Young type handbook formulas. It can show a figure which documents the variables used for say a moment of inertia calculation. It natively uses units for all calculations. (I have not yet tried units in Julia, so can’t comment on them.) It is not a good environment for large scale programming though. Overall it is still my goto environment for “back of the envelop” type calculations. The real challenge is how to integrate the good things of MathCad (inserting a photo or scanned image and equation formatting) into an environment like Pluto. MathCad Prime is available for trial, and after the trial period it is still available with basic functionality.

1 Like

I also just saw this Discourse post about beginner videos for Julia that may be useful.

I think that’s probably a good idea. It would be seem very natural to point to other non-official, but well-written, tutorials before diving into the docs.

[Edit: There actually is a link to the learning resources page at the bottom of the Getting Started section. But it’s very much a footnote rather than an advertisement.]


Probably you are confused about invariance, e.g. you should have declared a parameter as AbstractVector{<:Real} but you declared it as AbstractVector{Real} instead — the former allows Vector{Float64} and the latter does not. This comes up a lot in the forums, e.g. here and here and here and here etcetera.


Exactly, the hard work of curating the material is already done. For a beginner in programming a good advertisement and guidance to go for that material at the very start would probably avoid some bad initial experiences.


the worst feature I saw in Julia’s language is the lack of proper packages and libraries. For example, I was looking for a suitable package for symbolic algebra in Julia and found that instead of using the unique features of the Julia language, they suggest calling the Python SymPy module. The point is, if I want to work with SymPy, I can easily use it in Python, and I do not need to endure the long initial start times in Julia.

Most languages, including many very mature ones, don’t have a library like SymPy. Full-fledged computer algebra systems take a ton of work to build, and they don’t get built until someone with the time and wherewithal has a compelling reason to do it. Furthermore, the convenience of calling SymPy from Julia makes it more difficult to justify building a Julia-native version. So what ends up happening is that this functionality evolves in specific contexts where SymPy doesn’t meet the needs of a given application (e.g., ModelingToolkit.jl), and it grows from there.

So really what you’re observing here is that Python enjoys an impressively extensive collection of packages. For any user that prioritizes that, their options in the short-to-medium term are to use Python or call Python libraries as needed from Julia (or some other language). What Julia offers is better interoperability between packages, including ones that are just Python wrappers. For example, I prefer SymPy.jl to using SymPy directly in Python, because it’s less verbose and offers some additional functionality via generic Julia methods.

Whenever you see a major, long-standing problem in a widely used piece of software (e.g., Julia’s time-to-first-plot, or Python/R/MATLAB’s execution speed), the safe bet is that a ton of effort has gone into addressing the problem, and any lack of success in those endeavors is due to the inherent difficulty of the problem.


I am wondering if you know PackageCompiler.jl. You can precompile PyPlot (or any other julia package) so that even your first plot take < 1 seconds.

# first command in my session
julia> @time begin; using PyPlot; ion(); plot(1:10); end
  0.339586 seconds (71.61 k allocations: 3.859 MiB)

Caveat: you need to recompile your system image every time you update PyPlot and for some reasons you need to explicitelty toggle the interactive mode with ion(). It would be great however if PackageCompiler (and Revise) would be somehow be integrated into Julia to make this simpler (and less confusing) for new users.


Was the Win7 system 32 bit or 64 bit?
In general, the problem with Win7 is that it is so old that it is not even supported by the Github CI (to my knowledge).

1 Like

Yes, there are some, but not enough, the quality of educational materials is much lower than educational materials in other languages.

I assure you that when someone really wants to learn a subject, they check all the available resources and complaining is the last thing they do.

I tried this but it is not like SoloLearn which has interactive and quiz based tutorial. Excerism is very similar to homework, but for doing homework you first need good tutorial.

actually I took Julia Academy courses. this is the proof :smiley:

This course was not bad but compared to something like CS50 it could became better in the future.

I read this book, it can help in the beginning of the learning journey.

You are right, if the educational materials are not updated regularly, they will gradually become obsolete.

1 Like

“really wants” is something subjective. When I teach something I want that the students that really want (or need) learn and enjoy, but that is generally easy. It is harder to make things enjoyable and profitable for the ones that want (or need) less. My suggestions are hopefully to catch the attention of those as much as possible.

I really cannot evaluate that and I trust your judgment. I liked many things I have viewed and read, but I have no parameter because I never used those resources in other languages. I think anyway that this feedback is important, because there might be people and companies willing to invest on that. To be truth, I myself have written quite extensive materials for the courses I teach. But they are not for the general public.

I really like and hope that this happens because Julia has great potential and more importantly, it is fun to write code in it.

a “problem” is defined after someone makes a claim and that “problem” prevents achieving that claim. There is no expectation from Python to have high execution speed, whereas there is such an expectation from Julia, based on Julia’s claim about speed. This makes Julia’s time-to-first-plot an important issue comparing to Python’s execution speed.


While I would also love to see startup times further improved, where does Julia make a claim about its time-to-first-plot speed? It’s the runtime speed it makes claims about.


I don’t think this is true if you run a business that would benefit from Python being faster.


Thank you for introducing this training course. It would be great if there was a topic that every time someone prepares a training course add its link to it.