Julia Advice to Curious Python Developers

Are you a long term Python developer and interested in exploring Julia?

This is an random assortment or remarks based on questions and observations I have made of people transitioning to Julia from Python.

What Julia Version Does a Course or Book Need to Cover?

The current version of Julia is 1.6, and certainly you want to learn the latest version. However, good books or courses may not have been made for the very latest version. What to look out for?

Anything made prior to 1.0 will be more difficult as there has been a number of syntax changes. Curiously, I still get positive feedback from people who have watched my video course: Getting Started With Julia.

It has surprised me since that course was made for Julia v0.5, but many viewers have made it work anyway, by simply looking up the changes. However, this may not work for all. The safest bet is any course or video made for Julia 1.0 or higher. Above 1.3 is ideal as some important changes happened then. My more up-to-date Julia for Beginners book mostly targets v1.5.

Ultimately you have to balance how good you think the teaching material is against how up-to-date you want it.

What Development Environment Should I Use?

Today the most recommended environment is VS Code. It has the strongest Julia support and lots of people already use it. But what if you think VS Code is a bloated memory hog and don’t want to use it? Will Julia be impractical to use without it? Not at all. In fact, I personally use a much simpler text editor TextMate. The trick is to understand how you use simple editors effectively together with Julia’s interactive command line (REPL).

I made this video specifically because it is hard to get across in writing how you work effectively with a dynamic language in a command line. Even if you are an experienced Python developer, there is likely a lot of useful tricks for you to learn in this video. In fact I have a whole series of videos help you get use to the Julia REPL:

• Using Julia REPL Modes — Looking up help, adding packages, running shell function. Julia has different modes which change behavior of the REPL, to allow you do to other things than writing code.
• Writing Code in the Julia REPL — This is about editing code directly in the Julia REPL environment without use of a text editor.
• Workflow for Developing Code in a Julia REPL — Combining the REPL with a text editor. So unlike previous video we don’t write the code in the REPL itself.
• How to Effectively use a Text Based Debugger — Debugging code in Julia. Demonstrates power of Julia REPL modes as the debugger is just a mode in the REPL.

Documentation and Discovering Functionality

Python developers are used to extensive documentation and use a lot of introspection features such as dir to get what methods are available on an object.

Python

For instance a Python developer can look up methods on an object with the dir() method:

>>> dir("hello")
[capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs
', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isasci
i', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'ispr
intable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lst
rip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'r
partition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'str
ip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

I had to edit this or the list would be too long. Of course, with more capable Python REPL environments such as bpython you can just type a string, write a dot and hit tab to get a list of relevant methods:

>>> "hello".
┌────────────────────────────────────────────────────────┐
│ capitalize   casefold     center       count           │
│ encode       endswith     expandtabs   find            │
│ format       format_map   index        isalnum         │
└────────────────────────────────────────────────────────┘

In Python if you want to lookup some online help on a function or method you can use the help function. To get info about how to use the print function, I would write:

>>> help(print)

This would produce the following output:

Julia Documentation

Documentation in Julia is both a strength and weakness. Being a much younger language, the developers have not gotten time to document every library to the same extent as with Python. However, being younger also gives an opportunity to think fresh about documentation. Julia doc strings, which are used to document Julia functions and types, use markdown and are thus styled when looked up.

Compare the documentation of print in Julia with that of Python. I would argue this is much more helpful, as it gives nice REPL session examples to help you understand how the function is used.

In addition, example code is heavily used and this code in typically run in unit-tests to make sure it is always valid. Julia has support for marking of code examples inside text strings to be tested. Here is another arbitrary example showing the capitalize function for strings. Again you can see helpful code examples. There are even mentions of similar types of functions such as lowercase, titlecase and uppercasefirst.

In Python you find much less helpful information. There are no code examples or references to related method:

Help on method_descriptor:

upper(self, /)
    Return a copy of the string converted to uppercase.

However, as soon as you go outside of the standard libraries, you may get frustrated by lacking documentation in Julia. It varies. For the more popular libraries, I think the documentation is very good.

It is also worth understanding that Julia documentation lookup is not based on calling a function like help, but on issuing statement in help mode. Hence you could write any kind of expression on the Julia REPL and decide you want help for it. Just jump to the start of the line and hit ?, this will take you into help mode and the prompt changes to a yellow help>. Thus you could ask for help for something like an addition:

Julia deduces that you want help for the + operator from this expression. In fact this is very much a necessity for Julia as functions in Julia have multiple methods. Every combination of arguments calls a different method which has different behavior and documentation. For example, the multiply operator could be used to multiply numbers or concatenate strings.

Julia Function and Method Lookup

In object-oriented language, you typically type an object, write a dot and hit tab to get some completions.

But Julia is not object-oriented. It is more functional, so how do you discover functionality? You can lookup what methods involve a particular type with the methodswith function call. I have edit this output slightly for clarity and highlighted the method names.

julia> methodswith(StepRange)
[1] findfirst(p::Union) in Base at array.jl:1915
[2] firstindex(::StepRange) in Base at range.jl:568
[3] float(r::StepRange) in Base at float.jl:899
[4] getindex(r::StepRange, s::AbstractRange) in Base at range.jl:766
[5] intersect(r::StepRange, s::StepRange) in Base at range.jl:873
[6] isempty(r::StepRange) in Base at range.jl:517
[7] length(r::StepRange) in Base at range.jl:558
[8] map(::Type{T}, r::StepRange) where T<:Real in Base at abstractarray.jl:1104
[9] step(r::StepRange) in Base at range.jl:543
[10] view(r1::StepRange, r2::AbstractRange) in Base at subarray.jl:194

While less convenient than the Python counterpart, it is worth observing that this lets you discover more functionality. For example, the Python version never lets you know that ranges can be used with the map function. Julia however does because it is not limited to methods attached to an object. It shows all methods which may involved the range type.

However, this is not how a functional programmer thinks anyway. I know this is hard to grasp if you have done OOP for many years. I know because that was what I was used to. I could not fathom for years how people could organize anything with just functions or find functionality. OOP way of doing things seems like the natural way. But as you get accustomed to functional programming, you realize that it isn’t the natural way. It is just what you happen to be used to. Now I am used to functional programming and find OOP style difficult to deal with. I want to search for a function to call, but it is hidden behind an object as a method. I have to figure out what type the function I am looking for is attached to. That seems like a detour.

Introspection

In Python there are various ways to check what variables exit in current scope in various IDEs. How does this work in Julia? You can lookup this kind of information on the REPL with the varinfo function.

julia> r = Rect(2, 4, 20, 40)
Rect{Int64}(2, 4, 20, 40)

julia> p = Point(8, 4)
Point{Int64}(8, 4)

julia> v = Vec2D(10, 20)
Vec2D{Int64}(10, 20)

julia> varinfo()
  name                    size summary        
  –––––––––––––––– ––––––––––– –––––––––––––––
  Base                         Module         
  Core                         Module         
  InteractiveUtils 266.594 KiB Module         
  Main                         Module         
  ans                  0 bytes typeof(varinfo)
  p                   16 bytes Point{Int64}   
  r                   32 bytes Rect{Int64}    
  v                   16 bytes Vec2D{Int64}

Julia IDE functionality through VS Code gives similar capability.

Is Julia Really Fast?

This is the big question for a lot of newcomers to Julia. Many come from Python, Matlab and R looking for higher performance. They may consider Go, Rust, C/C++, Swift and Julia. Why pick Julia? It is big enough topic that I moved this into its own story: Is Julia Really Fast?

But we can cover the major selling points here. Julia allows similar workflows as in Python, Matlab and R because it is a dynamic language as well. You can modify code on the fly, re-run your functions, plot new data etc, all without recompile and reloading your whole program as C/C++, Rust and Go would require. And of course Julia has a rich set of libraries for scientific computing missing in many of the other languages. E.g. I did a lot of Swift programming in the past. Swift is great for GUI programming, but it really lacks scientific libraries.

Julia is a First Class Numerical Programming Language

Julia unlike the other languages is also optimized for numerical computing. Below you can e.g. see the number hierarchy in Julia. You can even add your own custom number types and use in algorithms without any performance penalty. You can write algorithms specifically for signed integers without specifying bit sizes. You can use fractions instead of floating point numbers for accurate calculations.

Work in Progress…

This was a bigger topic than I first realized, so I am cutting in short for now, but will add a lot more info here later. I will have to discuss, for example, how you can learn a lot of Julia coding by looking at the source code and how easy that is.