In addition to running cooler, Raspbian Buster appears to be using a lot less memory resources than before, such as when having many open tabs in Chromium. More often than not I could see on htop where swap was being hit with a regular load of Chromium, multiple open tabs on the Terminal with multiple editing sessions, and regular builds with any of Go, C++, Rust, Python 3 or Julia running. I’ve now had the Pi 4 up for five days with continuous use and I haven’t hit swap yet.

And speaking of Julia, I installed version 1.4.0 and then installed all the supporting packages I normally need. One of those packages is Winston, and it has problems. Winston under Julia 1.4.0 is dependent on more packages than ever these days, so much so that any Julia script I’ve written won’t run because not all the current Winston dependencies are met. As a consequence I’ve dropped back to running the prior release, Julia 1.3.1. My scripts still run, and for the time being I’m not updating any of its packages.

Tonight, I removed that installation and instead installed Atom via brew (https://brew.sh) using brew cask install atom. Installing Atom via brew seemed to do the trick. I was able to install uber-juno within Atom using the brew-installed version of Atom with no problems at all. As you can see it’s up and running and using Julia 1.1.1, the version I installed the previous night. I’m finally back to the tool set I used a year ago with Julia 1.0. Let’s see how this goes.

If you read the README, you’ll see I grew disillusioned with Julia September 2018. Coming back nearly a year later and a lot has changed, and working with Julia is now (for me) a lot more enjoyable. I also see the potential of Julia.

I draw you attention to the highlighted lines below, 39-43. Lines 39-40 are commented original Julia command and output. There is no matchall() anymore; I tested with version 1.0.4 as well as 1.2.0 RC3. I tried to recreate the functionality with collect(eachmatch(…)). And as you’ll note the new output structure doesn’t even come close to the output from matchall(). I guess that’s something I can figure out as I dive deeper into Julia.

One other thing I’ve discovered, and that’s all the links in the code as comments are broken. None of them go to where they’re supposed to. The websites are still there but the specific pages that correspond to specific functions in the example do not. I’ve checked all of them so far and they’re all broken.

I don’t know why they leave that site up. It’s misleading unless you take it as a personal challenge to fix it all and bring it all up to date. I’m doing that right now because it’s helping me to find the real up-to-date sources, and it’s beginning to stick. My latest sources for correct Julia (so far) are Introducing Julia (https://en.wikibooks.org/wiki/Introducing_Julia) and Julia 1.1 Documentation (https://pkg.julialang.org/docs/julia/THl1k/1.1.1/index.html). I’m sure there are others, and I’ll eventually find them. but for now these seem to be sufficient.

#!/usr/bin/env julia#s1 = "The quick brown fox jumps over the lazy dog α,β,γ"# find the first instance in the string of a given character.i = findfirst(isequal('b'), s1)println(i)#> 11# or a range if called with another stringr = findfirst("brown", s1)println(r)#> 11:15# replace one substring with another.r = replace(s1, "brown" => "red")show(r); println()#> "The quick red fox jumps over the lazy dog"# findfirst can also take a regular expressions by preceding the string with 'r'.r = findfirst(r"b[\w]*n", s1)println(r)#> 11:15# again with a regular expressionr = replace(s1, r"b[\w]*n" => "red")show(r); println()#> "The quick red fox jumps over the lazy dog"# there are also functions for regular expressions that return RegexMatch typesr = match(r"b[\w]*n", s1)println(r)#> RegexMatch("brown")# RegexMatch types have a property match that holds the matched stringshow(r.match); println()#> "brown"# r = matchall(r"[\w]{4,}", s1)#> SubString{UTF8String}["quick","brown","jumps","over","lazy"]r = collect(eachmatch(r"[\w]{4,}", s1))println(r)#> RegexMatch[RegexMatch("quick"), RegexMatch("brown"), RegexMatch("jumps"), RegexMatch("over"), RegexMatch("lazy")]r = eachmatch(r"[\w]{4,}", s1)for i in r print("\"$(i.match)\" ") endprintln()#> "quick" "brown" "jumps" "over" "lazy" r = "hello "^3show(r); println() #> "hello hello hello "# e.g., with one argument it strips the outer whitespacer = strip("hello ")show(r); println() #> "hello"# or with a second argument of an array of chars it strips any of them;r = strip("hello ", ['h', ' '])show(r); println() #> "ello"# (note the array is of chars and not strings)r = split("hello, there,bob", ',')show(r); println() #> ["hello"," there","bob"]r = split("hello, there,bob", ", ")show(r); println() #> ["hello","there,bob"]r = split("hello, there,bob", [',', ' '], limit=0, keepempty=false)show(r); println() #> ["hello","there","bob"]r = join(collect(1:10), ", ")println(r) #> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

As a consequence of that definition I’ve been trying to get Julia to run on the Raspberry Pi 4b/2GB under Raspbian Buster. I’ve succeeded. It’s been an interesting challenge. The version I’m using right now is 1.2.0 RC3. How I got to running that version is an interesting tale…

I started trying to run the latest Julia release, 1.1.1. I looked on the Julia website (https://julialang.org/), but discovered that there was no version of 1.1.1 for 32-bit ARM, only 64-bit. I tried to build a native copy, first by downloading the source tar file, then by cloning a copy of 1.1.1 from Julia’s GitHub repository. Both times I ran into issues.

The first issue was the lack of a ‘-latomic’ linker switch in the last Makefile of the build sequence that would have created the executable. That was something of a head scratcher until I found the right Makefile to add the necessary linker switch modification to, and then the build job finished and produced an executable.

The second issue, and the last straw, was running ‘make test’ to execute a full suite of SWITs. Tests seemed to succeed at first, then tests started to fail because certain library entry points couldn’t be found, and then all the tests after that seemed to fail completely with no real reason being printed out. (In hindsight I’m wondering if this is an issue with Julia 1.1.1 in general, and that’s why there is no official ARM 32-bit version on the Julia website).

This happened with both the tarball as well as the Git cloned repo sources. After the SWIT failures I wiped away the build areas and went looking back on the Julia site for any other pre-built binaries. That’s when I found ARM 32-bit releases for the long term support version, 1.0.4, and an early release candidate for the next Julia release, 1.2.0 RC3. I grabbed both and untarred both and started to work directly with both.

At this point you’re correct to ask why I didn’t install Julia from the Raspbian Buster repo. The answer is that the version in the repo is 1.0.3, which isn’t even the latest LTS release. It’s another example of why I stay away from the Debian repos in general; many software tools are notoriously behind the regular upstream releases. The Raspbian/Debian Buster release has made strong strides to “keep up” version wise with applications, especially with Python and GCC. With Python, Buster released version 3.7.3, which at the time of release was the most current. And GCC on Buster is at version 8.3, which is quite remarkable considering what was available on Stretch. In particular, GCC 8.3 supports up to the C++17 standard, and on the C side, its back-end ARM binary generation appears to be much better than any prior release. This efficient code generation has manifested itself in Buster on ARM as faster to much faster execution. Those are considered first tier languages, while Julia isn’t a first tier language, not yet. So I go out hunting. Fortunately, installing Julia (as well as Go and Rust) means a simple local install (un-tar) and execution in-place.

Once in place and added to my path, I then started to write Julia code. I’m certainly no Julia coding expert, so don’t expect any blazing insights. To get me going I’ve been looking at Julia By Example (https://juliabyexample.helpmanual.io/), where I’m downloading examples and then editing them inside of Vim with Julia plugins.

I was forced to use Vim with plugins because when I tried to follow directions and install the Jupyter/IJulia notebook extension, it never worked. Every time I tried to use IJulia in a web-based notebook, it insisted on downloaded the x86 version of Python and execute that instead of using the system ARM version, and of course it failed. To add insult to injury IJulia wanted to use an older Python release, 3.7.1. I couldn’t find anything on the web that told me how to stop this behavior, so I’ve given that up as well, using Vim. As a side note I even tried to use Visual Studio Code and then Atom with Juno, but they required building from sources on Raspbian, and of course following those directions led to many lost hours and many tears on my end. And so I use Vim because it just works.

What follows are some of the examples from Julia By Example, because even the examples didn’t work out-of-the box and required some tweaking to work with both versions 1.0.4 and 1.2.0 RC3 on Raspbian.

For functions.jl I added line 1 and then set the execution bit so that the script would execute like every other script under Linux. I had to add line 3 to import Printf to support the macro @printf, and then in line 28 I had to fully reference @printf. That’s nothing special, per se, as full qualification for functions are in many language. But it’s interesting, and I had to do it everywhere.

#!/usr/bin/env julia#import Printf# [function](http://docs.julialang.org:8000/en/latest/manual/functions/#functions) to calculate the volume of a spherefunction sphere_vol(r)# julia allows [Unicode names](http://docs.julialang.org/en/latest/manual/unicode-input/) (in UTF-8 encoding)# so either "pi" or the symbol π can be usedreturn 4/3*pi*r^3end# functions can also be defined more succinctlyquadratic(a, sqr_term, b) = (-b + sqr_term) / 2a# calculates x for 0 = a*x^2+b*x+c, [arguments types](TODO: links) can be defined in function definitionsfunction quadratic2(a::Float64, b::Float64, c::Float64)# unlike other languages 2a is equivalent to 2*a# a^2 is used instead of a**2 or pow(a,2)sqr_term = sqrt(b^2-4a*c)r1 = quadratic(a, sqr_term, b)r2 = quadratic(a, -sqr_term, b)# multiple values can be returned from a function using tuples# if the [return](http://docs.julialang.org:8000/en/latest/manual/functions/#the-return-keyword) keyword is omitted, the last term is returnedr1, r2endvol = sphere_vol(3)# @printf allows number formatting but does not automatically append the \n to statements, see belowPrintf.@printf "volume = %0.3f\n" vol #> volume = 113.097quad1, quad2 = quadratic2(2.0, -2.0, -12.0)println("result 1: ", quad1)#> result 1: 3.0println("result 2: ", quad2)#> result 2: -2.0

The file formatting_converting_strings.jl builds on the first script, with line 1 setting it up as a stand-alone script and line 4 importing Printf. Line 8 is interesting, where a string representation of e is converted into a float. The original script called a float function, but in order to make it work I used parse, which is the same interestingly for line 11 converting a string representation into an integer. The rest of the highlighted lines are the use of @printf, especially line 19, where I had to again fully qualify @sprintf.

Quite frankly these are minor issues, and probably represent changes between the pre-release 1.0 versions of Julia and 1.0 and later. I say this because I had to do the same changes for both 1.0.4 and 1.2.0 RC3. I’m going back to try these on my MacBook which has Anaconda installed and working, and add Julia into the mix.

#!/usr/bin/env julia## strings can be converted using [float](http://julia.readthedocs.org/en/latest/stdlib/base/#Base.float) and [int](http://julia.readthedocs.org/en/latest/stdlib/base/#Base.int):import Printfe_str1 = "2.718"# e = float(e_str1)e = parse(Float64, e_str1)println(5e)#> 13.5914num_15 = parse(Int, "15")println(3num_15)#> 45# numbers can be converted to strings and formatted using [printf](http://julia.readthedocs.org/en/latest/stdlib/base/#Base.@printf)Printf.@printf "e = %0.2f\n" e#> 2.718# or to create another string [sprintf](http://julia.readthedocs.org/en/latest/stdlib/base/#Base.@sprintf)e_str2 = Printf.@sprintf("%0.3f", e)# to show that the 2 strings are the sameprintln("e_str1 == e_str2: $(e_str1 == e_str2)")#> e_str1 == e_str2: true# available number format characters are [f, e, g, c, s, p, d](https://github.com/JuliaLang/julia/blob/master/base/printf.jl#L15):# (pi is a predefined constant; however, since its type is # "MathConst" it has to be converted to a float to be formatted)Printf.@printf "fix trailing precision: %0.3f\n" float(pi)#> fix trailing precision: 3.142Printf.@printf "scientific form: %0.6e\n" 1000pi#> scientific form: 3.141593e+03# g is not implemented yetPrintf.@printf "a character: %c\n" 'α'#> a character: αPrintf.@printf "a string: %s\n" "look I'm a string!"#> a string: look I'm a string!Printf.@printf "right justify a string: %50s\n" "width 50, text right justified!"#> right justify a string:width 50, text right justified!Printf.@printf "a pointer: %p\n" 100000000#> a pointer: 0x0000000005f5e100Printf.@printf "print a integer: %d\n" 1e10#> print an integer: 10000000000

I will admit that Julia is a lot faster now than it was when 1.0 was first released. That release was so slow I deleted it and stopped using on the Raspberry Pi 3B+ under Raspbian Stretch. That was last year. Who knows what has transpired since that initial release. But if I’m going to determine what the promise is of Julia on the Raspberry Pi, then the convergence of the Raspberry Pi 4B with Raspbian Buster makes that a much better platform to explore, let alone run, Julia.