By: Jacob Zelko

Re-posted from: https://jacobzelko.com/10082023195125-julia-learning-resources/index.html

Resources for Learning the Julia Programming Language

Date: October 8 2023

Summary: A non-exhaustive list of recommendations for how I suggest learning Julia to language newcomers

Keywords: #julia #programming #beginners #recommendations #learning #archive #blog

Bibliography

Not Available

Table of Contents

Motivation

I saw an interesting post on BlueSky recently that got me thinking about Julia learning resources. I tend to give out a lot of advice about how to go about learning Julia but I realized I have never really centralized one place where I keep that information. This blog post talks about my personal opinions both within the Julia ecosystem and recommendations for how to learn Julia.

Before Programming with Julia, Let's Set It Up

The fantastic initiative, Modern Julia Workflows, spearheaded by Guillaume Dalle and co has a number of sections that can help with getting set-up fast (I'll be referring to their work quite a bit throughout this post). In particular, here are the sections I'd recommend to get set-up fastest:

1. How to install Julia on your computer

2. What you need to write Julia. A special note on this from me is that you really do not need much – you could use something like NotePad on Windows, textedit on OSX, or KWrite on *nix systems. I like the stance Dalle takes in recommending VSCode however as this gives you the best mileage whether you are a beginner or expert programmer.

Suggestion 2 here will most likely take you the longest if you have never worked with a text editor before (a piece of software to create and edit most different types of files). So, no worries and enjoy the learning here!

Julia Programming for New Programmers

If you are completely new to programming in general, I'd recommend the course, Julia Programming for Nervous Beginners, by Dr. Henri Laurie. It really eases you through how to start with programming and uses Julia as that learning tool. Otherwise, skip to the next section.

Quickly Picking Up Julia Programming

To pick up Julia programming, I recommend Introduction to Julia (for programmers) by Dr. Jane Herriman. This will get you going with Julia the fastest – especially if you already know some programming.

What Is a Julian?

Before continuing your Julia adventure, it is worth a pause to discuss a couple aspects of Julia that one may not immediately recognize but are crucial in a productive Julia workflow. Otherwise, one may end up despairing over the supposed virtues of Julia. Here are some specific pieces:

1. Julia is a REPL-centric workflow. If you are unfamiliar with what a REPL is, please see this reference for details but in short, the Julia REPL is a continuous loop that accepts all valid inputs. From loading a file, experimenting with code, or calling functions, the REPL serves as a scratchpad to iteratively build your overall Julia software instantly.

2. Julia is compiled – packages and functions will take a moment to load for use. This builds on the previous point, but yes, as Julia is compiled, any package or function you want to use may execute slightly longer initially but then will be compiled for the duration of your work session. This is why you want your Julia workflow to be REPL-centric as you can get around this issue.

3. Julians organize Julia software into "projects" or packages. Whether you are writing a collection of small scripts to analyze some data or developing a completely new software package, to effectively maneuver through your Julia code, make liberal use of Pkg.jl. Dalle has an excellent reference that talks about this concept of project environments as well as how to build your own local package.

4. Working within Julia can be extremely efficient – if you know how. This is a circular statement as it naturally raises the question of, "how do I actually build a concrete Julia workflow?" Thankfully, much has been written about this

5. Julians want to help you. What is wonderful about the Julia community is that, in contrast to perhaps alternative internet communities, the bulk of Julians greatly enjoy helping not only other Julians but other programmers in general (there has been numerous occasions where I have seen Julians help other language users become even more proficient in their workflows). This is an invaluable assortment of where to find your fellow Julians.

I hope this section does not come off as overtly prescriptive, but I have seen the notion of "you are holding the tool wrong" or "what is Julian" (i.e. how do proficient Julia users do X) pop up too many times for new Julians or those experimenting with the language. I hope with this nudging guidance here, a new Julian can more clearly understand the "why" of what other more proficient Julians recommend.

Building Up Expertise in Julia Programming

At this stage, we can now move from the beginner to intermediate Julian stage. Here, I think the world of Julia quite truly opens up to the new user. To delve deeper into Julia, here are some resources I would personally recommend:

• Believe it or not, the Julia documentation is actually really nice to read and accessible. Now, I don't just say this as I have helped write some of it, but I do truly think it worth looking through to get a better feel for aspects of Julia one may not consider. I would suggest starting with the Manual section of the documentation.

• Check out the MIT Computational Thinking Course to have a more hands-on introduction to scientific computing. I have never personally gone through it, but I hear it highly praised.

• Try solving problems on Exercism.io to practice and improve your skills. I am a mentor here although don't have as much time anymore to help review. I still find this to be a really great place to further your learning and to get better at programming Julia – you'll often get feedback from expert Julia users which, in itself, is extremely valuable.

Domain Specific Workflows in Julia

I will probably spin out the following sub-sections into their own blogs, but here are some selected domain specific workflows I have used or become familiar with that I use regularly within Julia.

Working with Data

This admittedly broad workflow encompasses much, but the most important packages in this space are:

• DataFrames.jl: This package provides a powerful data manipulation and analysis tool for Julia, similar to the pandas library in Python.

  • Additionally, the author of the package, Bogumił Kamiński, is an extremely prolific blogger who shares many different ways of using DataFrames.jl.

I highly suggest his blog.

• CSV.jl: Utility library for working with CSV and other delimited files in the Julia programming language

• TerminalPager.jl: a REPL-based Julia variable and documentation explorer

Plotting

When I first started within Julia, this was the only area I felt that was sorely lacking within the ecosystem. However, I am happy to say that this is no longer the case! In my mind, the best Julia plotting package is Makie.jl. It is an interactive data visualization and plotting ecosystem that has support for multiple backends ranging from publication quality static images, 3D images, to fully interactive plots and visualizations. I use it whenever I can.

Conclusion

NOTE: This blog post is a continuous work in progress.

As this blog post is a continuous work in progress, please feel free to comment below on questions about how I could improve it or explain more. That said, my goal with this blog post was not to cover every aspect of the Julia ecosystem but how to quickly go from knowing nothing about programming to becoming a self-sufficient Julian. May this concise guide help you in your way to achieving all that you want within Julia.

How To Cite

Zelko, Jacob. Resources for Learning the Julia Programming Language. https://jacobzelko.com/10082023195125-julia-learning-resources. October 8 2023.

References:

Discussion:

By: Jacob Zelko

Re-posted from: https://jacobzelko.com/06202023182947-notes-open-orgs/index.html

Notes on Managing Open Source Organizations

Date: June 20 2023

Summary: A collected overview on various comments from Julia organization organizers on how to effectively build up an open source organization

Keywords: #github #open #source #community #organization #blog #archive #julia

Bibliography

J. Zelko, “Julia Orgs, How Do You Manage Logistics?,” Julia Programming Language, Jun. 16, 2023. https://discourse.julialang.org/t/julia-orgs-how-do-you-manage-logistics/100430 (accessed Jun. 20, 2023).

Table of Contents

Motivation

As I have been involved with and have started various open source organizations in the past, I wanted to learn more about how other organizations within the Julia community manage this. In particular, as I am getting more serious about bolstering JuliaHealth, I want to make sure to do this as effectively as possible. These were some comments and notes from folks within the Julia Community who made suggestions on how to approach this effectively.

Structure Organization for Sustainability

• Limit dependency on any one person – Jakob Nissen, George Datseris

• All repositories and shared documents should have write access for multiple people, ensuring continuity even if some contributors are unavailable – Jakob Nissen, Guillaume Dalle

• Furthermore, packages should be designed with longevity in mind, as maintenance can be a significant challenge – Jakob Nissen, Georgia Datseris

• Build trust with frequent contributors – George Datseris

  • Could review their PRs more leniently

  • Provide detailed reviews for newcomers

Organization Guidelines

• Think about what is the criteria (such as reviews or approvals) before action on a pull request is taken – Guillaume Dalle

• Setting clear timeframes for feedback should be established – Guillaume Dalle

• Allocate review time (around 70-80%) to evaluating design aspects, logical connections between input-output arguments, and documentation of features – George Datseris

• Adapt the intensity of a PR review based on its potential impact to a package – George Datseris

  • PRs with package wide consequences should receive thorough evaluations

  • PRs that are independent of existing code could be reviewed more quickly

  • Bug fixes that affect small parts of the package could be reviewed faster

Managing Package Development

• Use GitHub issues to outline development roadmaps for a given package – Guillaume Dalle

• Use labels to prioritize GitHub issues as important and relevant to a given package – Guillaume Dalle

• Prioritize discussions within GitHub issues to foster transparency and consolidate discussions in location – George Datseris

• Maintain source code simplicity – George Datseris

Community Outreach and Communication

• Avoid making promises about deliverables or timelines – Jakob Nissen

• Community calls for triage discussions or long-term package orientation can help build community – Guillaume Dalle

• Actively invite individuals to join the organization – George Datseris

  • Provide them with administrative rights to relevant GitHub teams and repositories to foster participation

How To Cite

Zelko, Jacob. Notes on Managing Open Source Organizations. https://jacobzelko.com/06202023182947-notes-open-orgs. June 20 2023.

References:

Discussion:

By: Jacob Zelko

Re-posted from: https://jacobzelko.com/05102023043333-perfect-abundant-deficit/index.html

A Fun Exploration of Perfect, Abundant, and Deficient Numbers

Date: May 10 2023

Summary: A computational treatment and exploration of abundant and deficient numbers

Keywords: #blog #abundant #deficient #number #theory #julia #programming #perfect #aliquot #sequence #archive

Bibliography

Not Available

Table of Contents

Motivation

I was at the gym working out when I started thinking about locker numbers in the men's locker room. I was reminded of perfect numbers and was thinking about perfect number examples. I started testing random numbers in my mind and noticed numbers which had divisors that summed up to greater than their number and also less than their number. I had no idea about the existence of abundant and deficient numbers and got curious about these numbers and to see what characteristics I could find about them.

What Are These Numbers?

In Number Theory, there exist three species of numbers that depend on the divisors of a given number (excluding the number itself as a divisor). Here are the three species and their simple characteristics:

Deficient Numbers – these numbers have divisors whose sum is never greater than the number being examined. An example is the number \(4\) which has as divisors \(1\) and \(2\) – those divisors only sum up to \(3\).

Perfect Numbers – these numbers have divisors which sum to exactly to the number being examined. An example is the number \(6\) which has as divisors \(1, 2, 3\) which sum together to \(6\).

Abundant Numbers – these numbers have divisors whose sum is greater than the number being examined. An example is the number \(12\) whose divisors are \(1, 2, 3, 4, 6\) and sum to \(16\).

As it turns out, there are infinite deficient, perfect, and abundant numbers. However, only around 50 perfect numbers have ever been discovered to this day! \(6\) is the smallest perfect number but then perfect numbers grow to be hundreds of digits long! For that reason, this fun exploration will really only explore abundant and deficient numbers.

Examining Divisors of These Numbers

Out of curiosity, I wanted to know if there were any trends to be noticed in the divisors of the deficient and abundant number species. So, I whipped together some code to explore this within Julia (if you are not interested in the code, you can skip it and just go to the results for each section). To get started, I first defined a function to calculate divisors of a number:

import Primes: factorfunction divisors(n)    d = Int64[1]    for (p, e) in factor(n)        t = Int64[]
        r = 1        for i in 1:e
            r *= p
	    for u in d
	        push!(t, u * r)
	    end
	end	append!(d, t)
    end    return sort!(d)end

With this function defined, now, I am going to calculate some deficient and deficient numbers (since perfect numbers are hard to calculate, I am going to look up a few to explore). To do that, we will use the following snippet to find \(1000\) abundant and deficient numbers:

i = 1 
deficient_numbers = []
abundant_numbers = []
while true
  divisor_sum = divisors(i)[1:end-1] |> sum
  if divisor_sum < i && length(deficient_numbers) != 1000
    push!(deficient_numbers, i)
  elseif divisor_sum > i && length(abundant_numbers) != 1000
    push!(abundant_numbers, i)
  end  i += 1  length(abundant_numbers) == 1000 && length(deficient_numbers) == 1000 ? break : continue
end

We are set to explore further these numbers!

Abundant Numbers

As a first pass, let's calculate the divisors of the abundant numbers and plot their frequency:

import DataStructures: counter
import UnicodePlots: barplotabundant_divisors = vcat(divisors.(abundant_numbers)...) |> counter |> Dict |> sort;vs = collect(values(abundant_divisors));
ks = collect(keys(abundant_divisors));barplot(ks[1:20], vs[1:20], xlabel = "Count", ylabel = "Divisors", title = "Divisor Count for First 1000 Abundant Numbers")

Which gives the following plot:

Divisor Count for First 1000 Abundant Numbers 
               ┌                                        ┐ 
             1 ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 1 000   
             2 ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 995     
             3 ┤■■■■■■■■■■■■■■■■■■■■■■ 677                
             4 ┤■■■■■■■■■■■■■■■■■■■■■ 623                 
             5 ┤■■■■■■■■■■ 308                            
             6 ┤■■■■■■■■■■■■■■■■■■■■■■ 672                
             7 ┤■■■■■■■ 216                               
             8 ┤■■■■■■■■■■■ 347                           
             9 ┤■■■■■■■■ 229                              
   Divisors 10 ┤■■■■■■■■■■ 303                            
            11 ┤■■■■ 116                                  
            12 ┤■■■■■■■■■■■ 336                           
            13 ┤■■■ 96                                    
            14 ┤■■■■■■■ 211                               
            15 ┤■■■■■ 139                                 
            16 ┤■■■■■■ 188                                
            17 ┤■■ 68                                     
            18 ┤■■■■■■■ 224                               
            19 ┤■■ 61                                     
            20 ┤■■■■■■■ 201                               
               └                                        ┘ 
                                  Count

Without any real methodology, what I notice is that there seems to be an interesting pattern where certain divisors are being repeated more than others as more and more divisors are found. It almost feels like a kind of decaying sequence where counts seems to spike on any multiple of \(3\) or \(4\) more consistently than any other number. Even though, it seems like multiples of \(3\) are not as consistent.

Deficient Numbers

Now, let's calculate the divisors of the deficient numbers and plot their frequency:

import DataStructures: counter
import UnicodePlots: barplotdeficient_divisors = vcat(divisors.(deficient_numbers)...) |> counter |> Dict |> sort;vs = collect(values(deficient_divisors));
ks = collect(keys(deficient_divisors));barplot(ks[1:20], vs[1:20], xlabel = "Count", ylabel = "Divisors", title = "Divisor Count for First 1000 Deficient Numbers")

Which gives the following plot:

Divisor Count for First 1000 Deficient Numbers 
               ┌                                        ┐ 
             1 ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 1 000   
             2 ┤■■■■■■■■■■■ 337                           
             3 ┤■■■■■■■ 220                               
             4 ┤■■■■ 124                                  
             5 ┤■■■■■■ 168                                
             7 ┤■■■■ 119                                  
             8 ┤■■ 51                                     
             9 ┤■■ 73                                     
            10 ┤■ 36                                      
   Divisors 11 ┤■■■ 82                                    
            13 ┤■■ 71                                     
            14 ┤■ 25                                      
            15 ┤■ 43                                      
            16 ┤■ 18                                      
            17 ┤■■ 56                                     
            19 ┤■■ 50                                     
            21 ┤■ 31                                      
            22 ┤■ 22                                      
            23 ┤■ 42                                      
            25 ┤■ 33                                      
               └                                        ┘ 
                                  Count

What's interesting here is that I did not see any immediate pattern or phenomena with these divisors at first glance. However, when I examined the plot using a log10 scale, I then saw that consistently, the counts for odd divisors for outnumber those for even divisors:

Divisor Count for First 1000 Deficient Numbers 
               ┌                                        ┐ 
             1 ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 1 000   
             2 ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 337          
             3 ┤■■■■■■■■■■■■■■■■■■■■■■■■■■ 220            
             4 ┤■■■■■■■■■■■■■■■■■■■■■■■ 124               
             5 ┤■■■■■■■■■■■■■■■■■■■■■■■■ 168              
             7 ┤■■■■■■■■■■■■■■■■■■■■■■■ 119               
             8 ┤■■■■■■■■■■■■■■■■■■■ 51                    
             9 ┤■■■■■■■■■■■■■■■■■■■■ 73                   
            10 ┤■■■■■■■■■■■■■■■■■ 36                      
   Divisors 11 ┤■■■■■■■■■■■■■■■■■■■■■ 82                  
            13 ┤■■■■■■■■■■■■■■■■■■■■ 71                   
            14 ┤■■■■■■■■■■■■■■■ 25                        
            15 ┤■■■■■■■■■■■■■■■■■■ 43                     
            16 ┤■■■■■■■■■■■■■■ 18                         
            17 ┤■■■■■■■■■■■■■■■■■■■ 56                    
            19 ┤■■■■■■■■■■■■■■■■■■■ 50                    
            21 ┤■■■■■■■■■■■■■■■■ 31                       
            22 ┤■■■■■■■■■■■■■■■ 22                        
            23 ┤■■■■■■■■■■■■■■■■■■ 42                     
            25 ┤■■■■■■■■■■■■■■■■■ 33                      
               └                                        ┘ 
                           Count (Log10 Scale)

Any Connection to Aliquot Sequences?

Out of curiosity, I wondered if there could be any overlap of abundant and deficient numbers' divisors with their respective aliquot sequences. Now, an aliquot sequence is a rather fun thing. It has the following form:

\[
s_{0} = k
\]
\[
s_{n} = s(s_{n-1}) = \sigma_{1}(s_{n-1}) – s_{n-1} \text{if} s_{n-1} \gt 0
\]
\[
s_{n} = 0 \text{if} s_{n-1} = 0
\]

I decided to implement a small algorithm to compute the aliquot sequence for a given number as follows:

function aliquot_sequence(num; max_itrs = missing)
  sequence = [num]
  s = num  while true
    s = sum(divisors(s)) - s
    if !ismissing(aliquot_sequence) && length(sequence) == max_itrs
      return nothing
    elseif s == 0 
      push!(sequence, s)
      break
    elseif in(s, sequence)
      break
    else
      push!(sequence, s)
    end
    
  end  return sequenceend

In my implementation, I decided to limit the sequence to no repeating sequence values for a number. Let's plot these sequence values and see what could be seen as before.

NOTE: As a limitation, some of these sequences have an immensely high number of iterations which cause my computer to explode (looking at you, abundant number \(138\))! For that reason, I am only calculating sequences for an abundant number that has only 10 maximum iterations within their aliquot sequence.

Aliquot Sequences of Abundant Numbers

Let's calculate the aliquot sequences for \(500\) abundant numbers that have at most \(10\) terms within their sequence:

import DataStructures: counter
import UnicodePlots: barplotabundant_aliquot_sequences = []for i in 1:1000000
         divisor_sum = divisors(i)[1:end-1] |> sum
         if divisor_sum > i 
           seq = aliquot_sequence(i, 10)
           !isnothing(seq) ? push!(abundant_aliquot_sequences, seq) : continue
         end         i += 1         length(abundant_aliquot_sequences) == 500 ? break : continue
         
       end
        
abundant_aliquot_terms = vcat(abundant_aliquot_sequences...) |> counter |> Dict |> sort;vs = collect(values(abundant_aliquot_terms));
ks = collect(keys(abundant_aliquot_terms));barplot(ks[1:20], vs[1:20], xlabel = "Count", ylabel = "Terms", title = "Aliquot Term Count for 500 Abundant Numbers")

Which yields the plot:

Aliquot Term Count for 500 Abundant Numbers 
            ┌                                        ┐ 
          0 ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 448   
          1 ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 448   
          3 ┤ 3                                        
          4 ┤ 3                                        
          6 ┤ 3                                        
          7 ┤■ 9                                       
          8 ┤■ 9                                       
          9 ┤ 3                                        
         10 ┤ 1                                        
   Terms 11 ┤ 4                                        
         12 ┤ 1                                        
         13 ┤■ 11                                      
         14 ┤ 1                                        
         15 ┤ 3                                        
         16 ┤ 1                                        
         17 ┤ 3                                        
         18 ┤ 2                                        
         19 ┤■ 8                                       
         20 ┤ 1                                        
         21 ┤ 4                                        
            └                                        ┘ 
                               Count

Here, I really cannot discern any relatable pattern as well as significance that can be tied back to abundant numbers. I am not sure if there is a way to tie significance back to abundant numbers at all in this scenario.

Aliquot Sequences of Deficient Numbers

Let's calculate the aliquot sequences for \(500\) abundant numbers that have at most \(10\) terms within their sequence:

import DataStructures: counter
import UnicodePlots: barplotdeficient_aliquot_sequences = []for i in 1:1000000
         divisor_sum = divisors(i)[1:end-1] |> sum
         if divisor_sum < i 
           seq = aliquot_sequence(i, 10)
           !isnothing(seq) ? push!(deficient_aliquot_sequences, seq) : continue
         end         i += 1         length(deficient_aliquot_sequences) == 500 ? break : continue
         
       end
        
deficient_aliquot_terms = vcat(deficient_aliquot_sequences...) |> counter |> Dict |> sort;vs = collect(values(deficient_aliquot_terms));
ks = collect(keys(deficient_aliquot_terms));barplot(ks[1:20], vs[1:20], xlabel = "Count", ylabel = "Terms", title = "Aliquot Term Count for 500 Deficient Numbers")

Which yields the plot:

Aliquot Term Count for 500 Deficient Numbers 
            ┌                                        ┐ 
          0 ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 487   
          0 ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 487   
          1 ┤■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ 487   
          2 ┤ 1                                        
          3 ┤■■ 28                                     
          4 ┤■■ 27                                     
          5 ┤ 1                                        
          6 ┤■ 10                                      
          7 ┤■■ 24                                     
          8 ┤■■ 23                                     
   Terms  9 ┤■■ 26                                     
         10 ┤■ 10                                      
         11 ┤■ 17                                      
         12 ┤ 2                                        
         13 ┤■ 15                                      
         14 ┤■ 9                                       
         15 ┤■■ 25                                     
         16 ┤■ 7                                       
         17 ┤■ 13                                      
         18 ┤ 1                                        
         19 ┤■■ 25                                     
            └                                        ┘ 
                               Count

Again, I really cannot discern any relatable pattern as well as significance that can be tied back to deficient numbers.

Conclusion

This was a small exploration that I wanted to do of these numbers to see if I could find any patterns or significance within aspects of these numbers. It seems like there may be some present within the factors of abundant and deficient numbers, but when looking at their corresponding aliquot sequences, I am unable to determine anything from a computational sense. To that end, I was also curious about how effective computation can be in helping to derive or provide hints about what may underlie these numbers. In short, it would appear that computation is quite helpful to give rise to initial questions. For example, I'd be curious to what extent the patterns I noticed within abundant and deficient numbers prolong for and if they are actually legitimate observations. At that point, one could then start applying basic data science skills to group, explore, and summarize potential trends within these numbers.

For now, my curiosity is sated and it might be worth a return to in the future. One thing this blog post did make me think about is analogies. The idea of deficient, perfect, and abundant numbers are really fascinating as it lends itself to analogs within set theory relationships (like many-to-one -> deficient number, one-to-one -> perfect number, one-to-many -> abundant number). I wonder if it could be used as analogy outside of mathematics strictly and in terms like healthcare (sub-type of a disease -> deficient number, canonical disease diagnosis -> perfect number, disease family -> abundant number). Might be worth further exploration in the future.

How To Cite

Zelko, Jacob. A Fun Exploration of Perfect, Abundant, and Deficient Numbers. https://jacobzelko.com/05102023043333-perfect-abundant-deficit. May 10 2023.

References:

Discussion: