Julia Community 🟣: Logan Kilpatrick

Case Study: Documenting machine learning models in a Julia ML framework

Logan Kilpatrick — Wed, 30 Nov 2022 17:06:52 +0000

Julia is a relatively new, general purpose programming language. MLJ (Machine Learning in Julia) is a toolbox written in Julia providing a common interface and meta-algorithms for selecting, tuning, evaluating, composing and comparing a variety of machine learning models implemented in Julia and other languages.

Authors: Anthony Blaom, Logan Kilpatrick and David Josephs
Problem Statement

While MLJ provides detailed documentation for its model-generic functionality (eg, hyperparameter optimization) users previously relied on third party package providers for model-specific documentation. This is physically scattered, occasionally terse, and not in any standard format. This was viewed as a barrier to adoption, especially by users new to machine learning, which is a large demographic.

Proposal Abstract

Having decided on a standard for model document strings, this project’s goal was to roll out model document strings for individual models. For a suitably identified technical writer, this was to involve:

Learning to use MLJ for data science projects
Understanding the document string specification
Reading and understanding third party model documentation
Boosting machine learning knowledge where appropriate to inform accurate document strings
Collaborating through code reviews in the writing of new document strings

Details of the proposal are on the Julia website.

Project Description

Creating the proposal

Our Google Season of Docs process always starts with an open solicitation to the community for project ideas. Those are generally crowd sourced and added to the Julia website. From there, the core Julia team evalautes each possible proposal based on the level of contributor interest, impact to the community, and enthusiasm of the mentor. As we have learned with Google Summer of Code over the last 10 years, the contributor experience is profoundly shaped by the mentor so we work hard to make sure there is someone with expertise and adequate time to support each project if selected.

This year, we were lucky enough to have a project that checked all three boxed. MLJ’s usage in the Julia ecosystem has expanded significantly over time so it seemed like a worthwhile investment to support the project with documentation help, especially around something critical like model information.

Once we officially announced that the MLJ project was the one selected, we shared this widely with the community for input. Generally, unless people are close to the proposed project itself, people don’t have much to say. Nonetheless, this process is still critical for transparency in the open source community.

Budget

Our budget was estimated based on previous years of supporting technical writers in similar domains and scopes of work. Estimating is always more of an art than science which is why we tend to add a buffer of time/budget to support unexpected hiccups.

Initially, we intended to have two main mentors but due to mentor availability, we only ended up with one person (Anthony), who did most of the mentoring work. We ended up spending the full amount allocated for the project per our expectations (expect ordering our wrap up t-shirts which is still in progress).

Participants

List the project participants. MLJ’s co-creator and lead developer Anthony Blaom managed the project, reviewed contributions, and provided mentorship to the technical writer David Josephs. Several third party model package developers/authors were also involved in documentation review, including GitHub users @ExpandingMan, @sylvaticus, @davnn, @tlienart, @okonsamuel. Logan Kilpatrick co-wrote the proposal, helped with recruitment, and took care of project administration.

When we knew we would be getting funding, we immediately shared the hiring details with the community on Slack, Discourse, and posted a job listing on LinkedIn to cast the widest possible net. Prospective candidates were asked to write a little about their background, describe previous technical writing experience and open-source contributions. This information, together with published examples of their technical writing, were evaluated. Two candidates were invited for one-on-one zoom interviews, which followed up on the written application and gave candidates an opportunity to demonstrate oral communication skills, which were deemed essential.

Did anyone drop out? No.

Since familiarity with Julia was strongly preferred, and some data science proficiency essential, it was challenging finding a large pool of candidates. In the end we selected a candidate who was strong in data science but less experienced with Julia. That said, our writer David had just started working for a company that codes in Julia, and that worked out nicely for us. David was quickly up-to-speed with the Julia proficiency we needed. Our experience reaffirms to us the importance in our work of scientific domain knowledge (machine learning) and good communication skills, over specific technical skills, such as proficiency with a certain tool.
Timeline

Our original proposal details a timeline. Our initial ambition included documentation for all models, with the exception of the sk-learn models; time was divided equally among model-providing packages. In hindsight this was a poor distribution as some packages provide a lot more models than others. Gauging progress was further complicated by the fact that some models had vastly more hyper-parameters to document.

Results

A tracking issue nicely summarizes results of the project and its status going forward beyond Google Season of Docs 2022. Documentation additions were made in the following packages, linked to the relevant pull requests:

Also, the technical writer made these code additions, to synthesize multi-target supervised learning datasets, to improve some doc-string examples:

Were there any deliverables in the proposal that did not get created? List those as well. The following packages did not get new docstrings, but were included in the original proposal:

Did this project result in any new or updated processes or procedures in your organization? No.

Metrics

What metrics did you choose to measure the success of the project? Were you able to collect those metrics? Did the metrics correlate well or poorly with the behaviors or outcomes you wanted for the project? Did your metrics change since your proposal? Did you add or remove any metrics? How often do you intend to collect metrics going forward?

Initially progress was measured by the number of third party packages documented but, as described above, a better measure was the proportion of individual models documented. As the project is quite close to being finished, I don’t imagine we need to rethink our metrics for this project.

Analysis

What went well? What was unexpected? What hurdles or setbacks did you face? Do you consider your project successful? Why or why not? (If it's too early to tell, explain when you expect to be able to judge the success of your project.)

This documentation project was always going to have some tedium associated with it, and it was fantastic to have help. Our technical writer was super enthusiastic and eager to learn things beyond the project remit. This enthusiasm helped me (Anthony) a lot to boost my own engagement. All in all, the communication side of things went very well.

I think having our writer David working at a Julia shop (startup using Julia) was an unexpected benefit, as I that increased exposure of the MLJ project. We had a few volunteer contributions from a co-worker, for example. Of course our project and David’s company shared the goal of boosting David’s Julia proficiency quickly. I believe David’s new expertise in MLJ is a definite benefit for his company, which currently builds Julia deep learning models.

Another benefit of the project was that the process of documentation occasionally highlighted issues or improvements with the software, which were then addressed or tagged for later projects. Moreover, David provided valuable feedback on his own experience with the software, as a new user.

As manager of the project, I did not anticipate how much time pull-request reviews would take. I’ve learned that reviewing documentation is at least as intensive as code review. In doc review there’s no set of tests to provide extra reassurance; you really need to carefully check every word.

Fortunately, there were no big setbacks. I would definitely rate the project as a success: We were able to achieve most of our goals, and this is certain to smooth out the on-ramp for new MLJ users. The final analysis will come over time, as we check our engagement levels, and check user feedback. A survey has been prepared and is to be rolled out soon.

Summary

In 2-4 paragraphs, summarize your project experience. Highlight what you learned, and what you would choose to do differently in the future. What advice would you give to other projects trying to solve a similar problem with documentation?

In this project a Google Season of Docs Technical Writer added document strings to models provided by most of the machine learning packages interfacing with the MLJ machine learning framework. This writing was primarily supervised and reviewed by one other contributor, the framework’s lead author and co-creator.

The main lesson for the MLJ team has been that creating good docstrings is a lot of work, with the review process as intensive as code review. It is easy to underestimate the resources needed for good documentation. Recruiting for short-term Julia related development is challenging, given the language’s young age.

In recruitment, it pays to value domain knowledge and good oral and written communication skills over specific skills, like proficiency in a particular language, assuming you have more than a few months of engagement. Doing so in this case led to a satisfying outcome. (By contrast, we have found a lack of Julia proficiency in GSoC projects more challenging.)

Appendix

A blog post describes our technical writer’s experience working on the project.

Acknowledgements

Anthony Blaom acknowledges the support of a New Zealand Strategic Science Investment awarded to the University of Auckland, which funded his work on MLJ during the project.

Here’s why quantum computing could be the big break for the Julia Language

Logan Kilpatrick — Wed, 23 Nov 2022 14:46:58 +0000

In the world of programming languages, a new star is on the rise. The Julia language has been gaining popularity in recent years, thanks to its versatility and ease of use. And it could be about to get a big boost from an unlikely source: quantum computing.

In a paper published late October of 2020, a team of researchers from the Chinese Academy of Sciences and the University of Waterloo proposed using the Julia language as a tool for developing quantum algorithms. The paper, titled “Yao.jl: Extensible, Efficient Framework for Quantum Algorithm Design” presents a set of tools that quantum programmers can use to design and test quantum algorithms with features like GPU support, an automatic differentiation engine, and state of the art performance.

The paper’s authors believe that Julia is well-suited for quantum computing due to its high-level syntax, which makes it easy to express quantum algorithms. Furthermore, they argue that Julia’s Just-In-Time (JIT) compiler can be used to compile quantum programs into efficient native code, which is important for running quantum algorithms on real hardware.

While it remains to be seen whether or not the Julia language will become the standard for quantum programming, there’s no doubt that it has potential. If you’re interested in learning more about quantum computing, or if you’re simply curious about this emerging new programming language, be sure to check out the paper.

You might also want to check out check out this video about Yao.jl from JuliaCon 2019 which goes over the usage of the package:

So what even is quantum computing and how can I get started doing it in Julia? 🧐

At the most basic level, traditional computing operates in the space of 0’s and 1’s. This is an idea that is central to our computing experience as every single program in the world can be broken down to binary. This changed however with the advent of quantum computing. In quantum computing, there exists the idea that we are not limited to just 0’s and 1’s at any given moment and in fact, [00, 01, 10, 11] can all co-exist whereas traditional computing requires we have only one active state.

If you are like me, you might be scratching your head and thinking: “How is this at all useful”? Well, there are many different cases where quantum computing can be used to solve a bunch of different really complicated math problems that would otherwise not be practical to solve. I will spare you having to look at a math problem right now and instead suggest you watch the below video for an overview on quantum computing.

Let’s play around with a really simple example of using Yao:

julia> using Yao
julia> ArrayReg(rand(ComplexF64, 2^3))
ArrayReg{2, ComplexF64, Array...}
active qubits: 3/3
nlevel: 2

This code creates a register which is a quantum state of a batch of quantum states. This quantum register is analogous to the traditional register in computing you might have touched in C or Assembly.

Next, let’s create a quantum block:

julia> chain(2, put(1=>H), put(2=>X))
nqubits: 2
chain
├─ put on (1)
│  └─ H
└─ put on (2)
└─ X

What does the chain function do here you might be asking, well here is what the help section says:

Return a ChainBlock which chains a list of blocks with the same number of qudits. Let G_i be a sequence of n-qudit blocks, the matrix representation of block chain(G_1, G_2, …, G_m) is G_m G_{m-1}\ldots G_1 It is almost equivalent to matrix multiplication except the order is reversed. We make its order different from regular matrix multiplication
because quantum circuits can be represented more naturally in this form.

Again, a little complicated, but the basic gist is that we created a 2-qubit circuit. This is probably as far as we need to go to illustrate that quantum computing is really possibility in Julia. I will be honest that my own understanding of this material is very minimal but getting my hands dirty and playing around with some of these examples helped make things a little more concrete.

I suggest you check out the Yao.jl quick start guide if you want to learn more and see loads of other examples.

Using Julia for quantum computing on AWS ✨

Not only is there a ton of development happening in the the open source quantum computing space, but big players like Amazon are also doubling down on services (like Amazon Braket) that provide quantum computing on the cloud. If you want to play around with this service from Julia, check out the newly announced https://github.com/awslabs/Braket.jl which provides an interface to work with the service.

On November 15th, 2022, AWS announced and released an interface to work with Julia and the AWS Braket service:

https://forem.julialang.org/kshyatt/introducing-braketjl-10f2

While the package is still experimental, the announcement post went on to say:

We’ve created this package because we know there are a lot of current and future quantum experts in the Julia community. We want to allow you to experiment and try out this exciting new technology using all the Julia features we know and love — multiple dispatch, native parallelism, a great package management system, and first class performance. We also want to learn from the Julia community, and better understand how we can enable you to do groundbreaking work in the quantum space.

This is a really excited development for the Quantum Computing ecosystem and those interested in Julia. Stay tuned to see what else is coming!

Wrapping things up 🎁

The field of quantum computing is still in its infancy, but it holds immense promise for the future. And the Julia language may prove to be an important tool for making quantum computing more accessible to developers. So if you’re interested in keeping up with the latest developments in both quantum computing and programming languages, keep an eye on Julia — it may just be the next big thing.

If you want to support the Julia Quantum ecosystem, consider dropping a star on Yao.jl and Braket.jl.

The best Julia programming books going into 2023

Logan Kilpatrick — Tue, 25 Oct 2022 13:15:59 +0000

The Julia community is creating new books across various disciplines at an ever-accelerating rate. If you aren't familiar, Julia is a high-level, high-performance dynamic programming language for technical computing, with syntax that is familiar to users of other high-level programming languages. It provides a sophisticated compiler, distributed parallel execution, numerical accuracy, an extensive mathematical function library, and so much more! In this post, we will highlight some of the best Julia books you can pick up today.

Exciting Announcement: My Co-author and I are thrilled to share that pre-orders our new book, Julia Crash Course, are now live:

https://logankilpatrick.gumroad.com/l/juliacrashcourse

Stay tuned until the end for a sneak peek at some of the most anticipated Julia books yet to be released.

Before we dive in, if you prefer online courses over books, check out this post where I highlighted 5 of my favorite free online courses:

https://logankilpatrick.medium.com/5-free-courses-to-learn-julia-start-learning-today-66c1e3173ebc

Think Julia 🧠: How to Think Like a Computer Scientist

Think Julia is one of the most popular Julia books out there. It gives a high-level introduction to the language in a very polished way. The book is structured to teach you the following:

The basics, including language syntax and semantics
Get a clear definition of each programming concept
Learn about values, variables, statements, functions, and data structures in a logical progression
Discover how to work with files and databases
Understand types, methods, and multiple dispatch
Use debugging techniques to fix syntax, runtime, and semantic errors
Explore interface design and data structures through case studies

A few quick notes from my own experience owning 2 copies of this, there is still only 1 version available of this book which means the code examples and such have not been updated since the initial publication. The language has continued to develop a great deal since it was originally published so if you are looking for the latest info, this might not be for you.

Also, take this next comment with a grain of salt, but I have seen feedback from folks saying that Think Julia is more about how to type Julia code and less about how to be a Julia developer. There are subtle things that miss the mark if you want to really understand how to write great Julia code.

All of that being said, it is likely the most popular Julia book out there so it's worth picking up a copy if you want to take a learning path that has been blazed many times:

Check it out on Amazon

Julia Data Science 📊

Data Science is an ever evolving field and leveraging the latest and greatest tools are paramount to success. This book covers:

What is data science?
Why Julia?
Julia Basics
DataFrames.jl
Data Visualization and Makie.jl

I think one of the unique parts of this book is that it not only covers the basics of Julia in the data science space but also goes into Makie.jl, one of the most popular visualization frameworks for Julia. I also appreciate that this isn't a 500-page book so it makes getting up to speed on the topic something you can tackle in a couple of days instead of a few months.

Julia Data Science is one of my favorite books because they make a free web version of the book available to the world at: https://juliadatascience.io/

With that being said, if you have the means, it would be awesome to support the authors who have taken the time to share their knowledge with the world.

Check it out on Amazon

The Little Book of Julia Algorithms: A workbook to develop fluency in Julia programming 📣

The little book of Julia algorithms is one of the first Julia books I picked up. It is a simple hands-on introduction to learning Julia through the use of 50 small challenges. If you are just starting to learn the language, you should likely pick up this book and another one since this book does not actually walk you through all the different concepts but instead gives you things to practice as you learn the language.

This book covers:

Loops and conditionals
Structuring code with functions
Reading and writing files
Installing and using packages
Sorting and searching
Simple statistics and plotting

The craziest part of this book is that Ahan Sengupta started using Julia when he was only 11 years old and wrote this book early in high school. It is very well done and a fun way to practical experience with Julia!

Check it out on Amazon

Hands-On Design Patterns and Best Practices with Julia 🧑‍🎨

Tom Kwong is the author of this book and someone I consider to be a great contributor to the Julia ecosystem. We work together on helping run the annual JuliaCon and it just so happens that he is also the author of this book! When I read this book, I was surprised at how different it was from many of the other Julia books out there.

Tom does a great job of diving deep into design patterns and best practices. If you are a somewhat experienced Julia developer and interested in taking your skills to the next level, this is exactly the book you need.

Here is what you will learn in this book:

Understand the Julia language features that are key to developing large-scale software applications
Learn about design patterns to improve overall application architecture and design (this is something I had never been exposed to before this book)
Create reusable programs that are modular, extendable, performant, and easy to maintain
Be able to weigh up the pros and cons of using different design patterns for use cases
Find and explore methods for transitioning from object-oriented programming to using equivalent or more advanced Julia techniques (like structs and macros)

Overall, Tom does an incredible job with this book and there's a tremendous amount to learn here even just beyond the Julia concepts.

Check it out on Amazon

Interactive Visualization and Plotting with Julia 📈

Plotting and visualization in Julia are two of the most important concepts to understand if you want to use the language to its full potential. The author of this book, Diego, is a long-time Julia community contributor and one of the core folks helping maintain and build the plotting ecosystem. In my experience, visualizations can be a bit of a challenge in Julia so having resources like this is critical to the success of the ecosystem.

I got my copy of this book a few weeks ago and it has been a great experience so far! After reading this book, you will walk away learning how to:

Create interactive plots with Makie, Plots, Jupyter, and Pluto
Create standard statistical plots and visualize clustering results
Plot geographically distributed and biological data
Visualize graphs and networks using GraphRecipes and GraphPlots
Find out how to draw and animate objects with Javis, Plots, and Makie
Define plot themes to reuse plot visual aspect customizations
Arrange plots using Plots, Makie, and Gadfly layout systems
Define new plot types and determine how Plots and Makie show objects

Check it out on Amazon

Tanmay Teaches Julia for Beginners: A Springboard to Machine Learning for All Ages 🤖

Tanmay Bakshi is an amazing technical educator and an early adopter of the Julia ecosystem. He does a great job of writing a book that is both practically relevant but also extremely accessible to most people. I also really enjoyed that the book is set up to prepare you to begin your machine learning journey and while it does not cover ML in depth, it still helps you get closer to starting down that journey.

This book was published in 2019 and like Think Julia, it is still in its first version so it might be a little out of date but still a great resource. This book covers how to:

• Set up and configure your Julia environment
• Get up and running writing your own Julia apps
• Define variables and use them in your programs
• Use conditions, iterations, for-loops, and while-loops
• Create, go through, and modify arrays
• Build an app to manage things you lend and get back from your friends
• Create and utilize dictionaries
• Simplify maintenance of your code using functions
• Apply functions on arrays and use functions recursively and generically
• Understand and program basic machine learning apps

Check it out on Amazon

Statistics with Julia: Fundamentals for Data Science, Machine Learning and Artificial Intelligence 🧑‍💻

Statistics with Julia is a deep dive into the math behind the concepts of Data Science and ML written by Yoni Nazarathy. Yoni has given a bunch of awesome workshops (including one in Hebrew) over the years at JuliaCon. If you want to get a sense of what Yoni talks about in this book, check out his talk:

You can also find the code for the book online for free here: https://github.com/h-Klok/StatsWithJuliaBook
My honest experience reading this book is that it goes heavily into the math which for me was quite difficult but if that is the angle you are looking for as you learn Data Science and ML then this is the perfect book for you. It also includes over 200 code examples that help you bridge from math to practical applications.

Check it out on Amazon

More books to consider 📚

So far, the books I have talked about are ones that I have personally picked up a copy of. The next few books are either upcoming or I have heard good things about them via word of mouth in the community.

Julia as a second Language is a practical guide for folks, you guessed it, learning Julia as their second language. I have seen great things about this book but have yet to pick up a copy. The author, Erik Engheim, is well-regarded in the Julia ecosystem and I have read some of his articles before.

Check it out on Amazon

Practical Julia is a book I am very excited about! The author, Lee Phillips, is also someone who is reputable in the ecosystem and I have seen his writing before. This book is available for pre-order and I suggest you get your copy soon!

Check it out on Amazon

Julia for Data Analysis is an upcoming book but prolific Julia contributor Bogumil Kaminski. Bogumil is the real deal, whether it be the top contributor to Julia on Stack Overflow or being the lead developer of DataFrames.jl, he is someone that you will want to learn from.

Check it out on Amazon

Web Development with Julia and Genie is another upcoming book co-authored by Adrian Salceanu, the creator of Genie.jl. Julia has a huge potential in the web ecosystem and Adrian is working hard to make sure the potential is realized there.
Web Development with Julia and Genie:

Check it out on Amazon

If you're looking to get started with Julia programming in 2022 and beyond, these books are a great place to start! Get started on your development journey today and please do share other books you have found valuable as you are learning Julia.

If you'd like to receive future updates, subscribe below!

You must first sign in to Julia Community 🟣.

The only way you should be splitting a String in Julia - Julia Base.split()

Logan Kilpatrick — Tue, 20 Sep 2022 14:32:32 +0000

Splitting a string is one of the most common operations you can perform in any programming language. In this article, we will go over the different ways of splitting strings in Julia, including extensive examples of the different approaches.

The basic split syntax 🖖

We will start by declaring a basic string:

julia> my_string = "Hello.World"
"Hello.World"

Next, we will call the split() function and pass in the string as well as the delimiter (what you want the split to occur on).

julia> split_strings = split(my_string, ".")
2-element Vector{SubString{String}}:
"Hello"
"World"

In this case, since the string had only 1 period, we end up with two separate strings. Note that the new strings do not have the delimiter included in them, so the overall length of the combined strings decreased by 1 in this case. Let's look at a more robust example of splitting a string:

julia> my_sentence = "Hello world. This is an extended example with more sentences to show what happens. I am going to add only a few more. Okay, last one. Wait, what is this?"
I just want to highlight what it looks like when there are more items to be split. Let's look at this in action:
julia> split_sentences = split(my_sentence, ".")
5-element Vector{SubString{String}}:
"Hello world"
" This is an extended example with more sentences to show what happens"
" I am going to add only a few more"
" Okay, last one"
" Wait, what is this?"

Notice that again, the punctuation is gone but there is white space at the beginning of the sentence. We would have to use a strip function call to remove it.

For now, this is the most basic form of using the split function.

Next, we will explore more advanced use cases!
One more quick thing to keep in mind is that if we don't specify a delimiter, the split function defaults to using a space as the delimiter, if you forget to add one, you will get a wildly different result:

julia> split_sentences = split(my_sentence)
30-element Vector{SubString{String}}:
"Hello"
"world."
"This"
"is"
⋮
"what"
"is"
"this?"

Advanced split examples 🧗

If you want to move beyond the basics of using split and try out some advanced examples, this section is for you. We will start by playing with the optional limit argument which lets us set the max number of items we want to be created.

julia> split_sentences = split(my_sentence, limit=10)
10-element Vector{SubString{String}}:
"Hello"
"world."
...
"with"
"more"
"sentences to show what happens." ⋯ 40 bytes ⋯ ", last one.

Wait, what is this?" Since we set the limit at 10, we essentially stop splitting on the delimiter after the 10th item. The final item in this vector has multiple sentences in it.

Next, we will look at the keepempty optional argument. It allows us to specify if we want to keep empty items in the resulting vector. It's probably easiest to see this in practice. We will re-define our string to include more text:

julia> my_sentence = "Hello world. This is an extended example with more sentences to show what happens. I am going to add only a few more. Okay, last one. Wait, what is this? . . . . . . . . ........"
"Hello world. This is an extended example with more sentences to show what happens. I am going to add only a few more. Okay, last one. Wait, what is this? . . . . . . . . ........"

Now, let's see this in action with both options:

julia> split_sentences = split(my_sentence, ".", keepempty=false)
13-element Vector{SubString{String}}:
"Hello world"
" This is an extended example with more sentences to show what happens"
" I am going to add only a few more"
" Okay, last one"
" Wait, what is this? "
...
" "
" "

Here we can see that since keep empty is false, we have no resulting items where the value is an empty string (""). If we switch the value to true, we get the following:

julia> split_sentences = split(my_sentence, ".", keepempty=true)
21-element Vector{SubString{String}}:
"Hello world"
" This is an extended example with more sentences to show what happens"
" I am going to add only a few more"
" Okay, last one"
" Wait, what is this? "
" "
⋮
""
""

Again, since the original example has lots of periods in a row ( ....... ), the keepempty option set to true gave us a bunch of empty strings.

That's all we can do with the basic split function. Let's explore some of the other ways to handle string splitting in Julia!

Base.rsplit( )- Starting from the end 🧵

Similar to the split function, there is also a rsplit function that does the same thing as split, but it starts from the end (interestingly enough though, the order of the resulting data is not reversed). Let's look at a simple example in practice:

julia> my_string = "Hello.World.This.Is.A.Test"
"Hello.World.This.Is.A.Test"

Now, let's compare how this is different from just the regular split function:

julia> a = split(my_string, ".")
6-element Vector{SubString{String}}:
"Hello"
"World"
"This"
"Is"
"A"
"Test"

julia> b = rsplit(my_string, ".")
6-element Vector{SubString{String}}:
"Hello"
"World"
"This"
"Is"
"A"
"Test"

julia> a == b
true

But hold on a second, if rsplit is:

Similar to split, but starting from the end of the string.
why does it not invert the order?

Well, this is a great question and something I asked on Stack Overflow in order to try and get context for this.

The biggest time this will make a difference is if you provide the limit argument. In that case, the results will be different:

julia> a = split(my_string, "."; limit=2)
2-element Vector{SubString{String}}:
"Hello"
"World.This.Is.A.Test"

julia> b = rsplit(my_string, "."; limit=2)
2-element Vector{SubString{String}}:
"Hello.World.This.Is.A"
"Test"
julia> a == b
false

All of the other argument options hold true for rsplit so there's no need to re-hash those details.

Using eachsplit - Introduced in Julia 1️⃣.8️⃣

In Julia 1.8+, there is a new eachsplit function that allows you to split items just like we did before, but in this case, we return an iterator by default. This can be helpful when you want to work with an iterator instead of just returning a Vector by default. Let's see this in action:

julia> a = "Ma.rch"
"Ma.rch"
julia> split(a, ".")
2-element Vector{SubString{String}}:
"Ma"
"rch"
julia> eachsplit(a, ".")
Base.SplitIterator{String, String}("Ma.rch", ".", 0, true)

Now, if we want to replicate the behavior of the split function, we need to do the following:

julia> collect(eachsplit(a, "."))
2-element Vector{SubString}:
"Ma"
"rch"

The collect function allows us to chair together the items through the iterator. Personally, I think the docs could use some improvement here so I have an open issue seeking to address this.

But what even is an iterator to begin with? Well, according to the docs:

Sequential iteration is implemented by the iterate function. Instead of mutating objects as they are iterated over, Julia iterators may keep track of the iteration state externally from the object. The return value from iterate is always either a tuple of a value and a state, or nothing if no elements remain.

If you want to read more about this, check out the full docs section on Iterators.

Wrapping things up 🎁

In this post, we walked through the basics of using the split function along with rsplit and eachsplit. These functions provide the basic groundwork for string splitting in Julia.

There is lots more out there in the String-averse (ha, get it) to explore. I suggest checking out https://github.com/JuliaString/Strs.jl as a starting place for what is possible!

Why Julia 2.0 isn’t coming anytime soon (and why that is a good thing)

Logan Kilpatrick — Mon, 12 Sep 2022 13:02:19 +0000

If you have been programming for a while, there’s a good chance you have lived through breaking changes in ecosystems which may have left a bad taste in your mouth. Many people I have met speak disparagingly of the transition the Python ecosystem went through from version 2.X to 3.0. While most would likely agree that it was worth it in the long run, this transition still consumed a significant amount of resources for the ecosystem.

But what about Julia? Does having a 1.X version give people the idea that the ecosystem is still too immature? Would a 2.0 release spark mass adoption and be the catalyst for Julia becoming a top 5 programming language?

In this article, we will explore why Julia is unlikely to get a 2.0 release anytime soon and why that is actually a good thing for current and prospective Julia developers.

Historical Context (v0.6 ➡️ v0.7 ➡️ v1.0)

In the early days of the Julia ecosystem, much of the criticism of Julia stemmed from the volatility of the ecosystem. The language’s core API would change which left developers scrambling to adapt to changes. These frequent changes prevented industry adopters from having confidence in the language which was why many initial use cases were academic or hobby projects.

As the path to 1.0 and stability got closer, the core development team released Julia 0.7 which was the bridge to Julia 1.0 and included many warnings about how the API would change in the new version. On a personal note, this time period was exactly when I started using Julia. My first experience with the language was working through deprecation warnings and updating the syntax for a large Julia project I was working on at NASA.

What is the next Julia version? 1️⃣.9️⃣

The forthcoming major Julia release is Julia 1.9. This version will likely be around in 3–4 months given the current release schedule. You can read about what the proposed changes are on GitHub:

https://github.com/JuliaLang/julia/blob/master/NEWS.md

One big change that I am personally excited about is:

@kwdef is now exported and added to the public API ([#46273])

This is a long-standing open request from the community that was previously something you had to use an external package to accomplish. Another new feature that is being added is:

New pkgversion(m::Module) function to get the version of the package that loaded a given module, similar to pkgdir(m::Module). ([#45607])

This should give users more context on what versions are being loaded into certain modules which was something that you used to have to tediously figure out.

All of this is to say that there are still lots of amazing new features, bug fixes, and improvements coming in each new Julia major version.

So what is next after Julia 1.9 ⁉️

Well, after Julia 1.9 is….. Julia 1.10 😄. No really! Core Julia developer and co-creator of Julia Jeff Bezanson said at JuliaCon this year:

“There is no 2.0 plan. There’s no date, there’s no spec for it. There really is no such plan in the works. If anyone ever thinks of something that sounds like a good idea but would be breaking, we just tag it 2.0 as an issue and leave it for if or when that happens.”

If you want to see the type of issues that are being thought about for 2.0, check out:

https://github.com/JuliaLang/julia/milestone/23

As you can see, the details are rather scarce since most ideas that are being proposed can be implemented without breaking changes.

Why is it good that 2.0 isn’t coming anytime soon? 🎊

The stability of Julia is something users and developers have grown to love over the years (especially for those who lived through the early Julia days with constant changes). From a design perspective, it truly speaks to the high-quality decisions that were made that we have made it all the way to 1.8.1 now (4 years since 1.0 was released) without breaking changes.

Jeff goes on to say further that:

“But as for me personally, of the things that I would want to see, I don’t believe any of them really require breaking changes. Anything that I can see we should do can be done in a 1.X non-breaking way. So I don’t see a need for 2.0 right now.”

This could obviously change over time as the needs and opinions of the core Julia team changes, but developers today can rest easy knowing that if they invest time, money, and intellectual capital into building systems with Julia, the API will be stable for years to come.

While I do personally think a 2.0 release would bring a lot of great visibility to the language, it is probably better to keep things as stable as possible while the ecosystem continues to grow exponentially. One small counter-point is that if there was going to be a 2.0 release, doing it sooner rather than later is likely better since the longer we wait for this, the more Julia code will have to be updated to make things work. Hopefully, if the day ever comes, Keno Fischer can reboot the Julia FemtoCleaner which automatically updated deprecated syntax for you.

What do you think about Julia 2.0? Drop a comment below and let me know!

3 features just added in Julia 1.8 you won’t want to miss!

Logan Kilpatrick — Sun, 21 Aug 2022 14:24:12 +0000

Julia 1.8 is hot off the GitHub release pipeline jam packed with tons of helpful new features. If you want a full overview of all of the new changes, check out the release blog post from the core development team: https://julialang.org/blog/2022/08/julia-1.8-highlights/
In this post, I will highlight 3 of the features mentioned in the link above which get me the most excited about this release!

Improved support for Apple Silicon 🍎💻

With more and more developers starting to make the transition to using Apple Silicon, the need for open source tools to work well out of the box on this architecture is increasingly more important. Julia 1.8 solves a host of issues related to:

how Julia internally uses LLVM to generate and link the code for this platform and were eventually solved in Julia 1.8 by moving to a more modern linker, which has better support for ARM CPUs on macOS.

While the issues and frequent segmentation faults were fixed for Julia 1.8, the issues could not be back ported to Julia 1.7, so that release will always have issues with Apple Silicon. If you are using Julia 1.7 and were experiencing any of these issues, it is recommended to update to 1.8 since the release changes Apple Silicon to Tier 2 support (with Julia 1.9 likely bringing Tier 1 support for Apple Silicon).

It is awesome to see so much effort being put into getting stability for the Apple Silicon Mac users. As one of those users myself, I have run into a few rough edges during the transition period but for the most part, these issues seems to be quickly decreasing in frequency. Also, in case you missed it, a technical preview of the Metal.jl, the package to program Apple M1 GPUs in Julia, was announced in late June of 2022, find out more on the Julia GPU blog.

The future is bright for M1 Mac Julia users!

Typed globals ⌨️ 🌎

In previous versions of Julia, it was not possible to specify the type of non-constant global variables. In Julia 1.7 and before, the language would give an error like the following if you tried this:

In this example, we are trying to set the type of a to be an Int but Julia gives an error when we do so.

In Julia 1.8, you can see the behavior has been updated to support this functionality:

The 1.8 blog post also notes that:

Type annotating global variables removes much (but not all) of the cost of using non-constant global variables.

which is great to hear since a core part of the reason to previously avid global variables was that it introduced a large computational overhead. This change should remove a small sharp edge for new and experienced Julia users alike!

Pkg status update with upgradable package indicator 📦

Anyone who has read any of my previous articles (like this one) knows that the Package Manager in Julia is one of my favorite features. It truly makes doing things in Julia a real pleasure as I can be confident that I am not going to have any weird issues getting things running on my local computer.

With Julia 1.8, another awesome quality of life improvement related to package versions is available. In previous Julia versions, when you run the status command in the package manager, you would get a print out of all the packages in your active environment. While this can be helpful, it does not always give the full context you need if you want to know what version of a package you should be using or the most up to date version available.

Now in Julia 1.8, the package manager gives a visual indication if there is a newer version of one of your installed packages available, as well as if the package version can be successfully updated given the version constraints of the other packages. Let’s take a look at this example from the announcement post:

Here, we can see when we run the st command (short hand for status), we get the different types of up arrows denoting the two different behaviors. This new feature will make it a lot easier to tell if a package has a new available version along with if there’s a reason you can’t update said package.
If you want a little more context on this, I would encourage you to read the full blog post.

Other cool things in Julia 1.8 👀

Julia 1.8 is jam packed with tons of great features. I wanted to highlight three in this post that I was especially excited about. With that said, I would be remiss to not mention some great JuliaCon 2022 talks which highlighted some of the work that took place in 1.8. For starters, Tim Holy and Valentin Churavy did a talk on “Improvements in package precompilation” which were part of Julia 1.8 (I actually already highlighted this video in my other article “5 important talks you might have missed at JuliaCon 2022”):

Another video worth checking out is from Nathan Daly and Pete Vilter on the topic of Hunting down allocations with Julia 1.8’s Allocation Profiler which was a new feature introduced with Julia 1.8:

With so much amazing stuff happening in 1.8, I can only begin to imagine what helpful new features are coming in Julia 1.9 (hopefully more Package Manager stuff)! Stay tuned and please do share with me what features in the release you are most excited for.

5 important talks you might have missed at JuliaCon 2022

Logan Kilpatrick — Tue, 16 Aug 2022 13:52:33 +0000

JuliaCon 2022 wrapped up on Saturday July 30th with the annual virtual hackathon. As one of the conference organizers, the live conference days during JuliaCon are usually filled putting out fires and making sure that everything is running smoothly. So much so that I tend to miss a lot of the best talks that take place and have to go back after the conference to try and catch up. 2022 was no exception, so here's 5 talks that I missed and you might have missed too!

Julia in VS Code — What’s New 🆕

VS Code is the officially supported IDE for the Julia Programming Community. Each year at JuliaCon, the core team that works on the IDE extension get together and share what has been built in the last year. This years talk highlighted:

New profiler UI
New table viewer UI
Revamped plot gallery
Cloud indexing infrastructure
Integration with JuliaFormatter.
New test explorer UI integration.

And more! If VS Code if your daily driver for Julia development, you are going to want to check this out.

What makes a programming language successful? (with Jeremy Howard) 🤔

One of the 2022 JuliaCon keynote speakers was Jeremy Howard, co-creator of fast.ai. In this talk, Jeremy highlighted what programming language ecosystems need to do to be successful in the long run. Jeremy also offered specific feedback on features that would make him more likely to use Julia on a day to day basis. One of the ones that sticks out to me was the idea that Julia needs to be able to support small executable files that can run on any operating system. Right now, there is PackageCompiler.jl but it is not yet at the general purpose stage yet.

Check out Jeremy's full talk here:

The State of Julia (In 2022) with Jeff Bezanson 🎤

Part of the annual JuliaCon tradition is to have the core Julia development team present what they have been working on over the last year and what to expect in the near future. This year, Jeff Bezanson (Julia co-creator) presented the State of Julia talk. He actually mentioned near the middle of his talk that Jeremy's keynote is well timed since there is lots of active work ongoing to make the ability to create executables with Julia much simpler and also with smaller footprints.
Jeff also went through other important topics like:

Key updates to the compiler
Threading Roadmap in Julia
Overview of release timelines

And lots of other interesting (and compiler heavy topics). Check out the full talk below:

Interactive data visualizations with Makie.jl 👀

Makie.jl is without a doubt one of the most loved Julia packages in the ecosystem because of all of the amazing interactive visuals you can create using it. This next talk was actually a 2.5 hour workshop presented by Simon Danisch & Julius Krumbiegel. They kicked off with some really exciting updates for the Makie ecosystem including that:
Makie is transitioning to it's own GitHub org
Makie is applying to NumFOCUS to become an official project
The new Makie website!

Simon also gave a deep dive into the funding of the Makie project over the years which highlights (to me at least) the need for Makie to continue to mature so that it can attract funding in a more sustainable way. After that, Simon and Julius gave a really great introduction to Makie and how to do all of the interactive visualization things you could ever want to do.

Check it out for yourself and also take a peak at https://lazarusa.github.io/BeautifulMakie/ which will soon become https://beautiful.makie.org:

Improvements in package precompilation 📈

No JuliaCon would be a success without a highlight of how, despite doing incredible work in 2021, Julia developers still somehow figure out how to make different things in Julia way faster in 2022. In this year's addition, core developers Tim Holy and Valentin Churvay (JuliaCon co-chair) kicked off by giving motivation for the work they have done, why Julia is as fast as it is right now, and where things can be improved.
Tim then gave a quick demo of the package precompilation improvements coming in Julia 1.8 and showcased how they significantly reduced precompile times across the ecosystem. Package precompilation has always been a pain for those in the Julia ecosystem so these advancements are a huge step in the right direction.

Interestingly, time showcased that for package loading, Python is still an order of magnitude faster than Julia and for plot rendering, it is 2 orders of magnitude. This is a huge deal and again something that people have long said makes them not comfortable switching to Julia. To hear about Tim and Valentin's solution to some of these issues, check out the full talk:

JuliaCon 2022 in a nutshell 🐿
This year's JuliaCon was another amazing step forward for the community packages with so many great talks (as you can see, it was hard to limit this post to only 5). You might also be interested in the JuliaCon 2022 highlights post the organizing committee put together this year which shares lots of important metrics for the event: https://julialang.org/blog/2022/08/juliacon-highlights-2022/

You can also find the full JuliaCon talk playlist here (more than 290 videos): https://www.youtube.com/playlist?list=PLP8iPy9hna6TRg6qJaBLJ-FRMi9Cp7gSX

One last quick note, if you enjoy using Julia and want to help advocate for the language, check out my talk on "How to be an effective Julia advocate":

See you all in person at JuliaCon 2023!

JuliaCon 2022 Keynotes Announced with Speakers Erin LeDell, Jeremy Howard, and Husain Attarwala Headlining

Logan Kilpatrick — Thu, 30 Jun 2022 14:41:37 +0000

The JuliaCon 2022 organizing committee is excited to share our amazing lineup of keynote speakers for the JuliaCon 2022 conference.

JuliaCon has a rich history of brining in both prolific Julia users / advocates as well as leaders in fields that are relevant for the JuliaCon audience. Let's learn more about our 2022 keynotes!

(If you are excited about JuliaCon, consider sharing this tweet about our keynote announcement: https://twitter.com/JuliaLanguage/status/1542505310387990529?s=20&t=kksEdOQL-ttne6roUSuWWA)

Dr. Erin LeDell

Dr. Erin LeDell is the Chief Machine Learning Scientist at H2O.ai, where she develops the open source, distributed machine learning platform, H2O, and is the founder of the H2O AutoML project. She has a Ph.D. in Biostatistics with a Designated Emphasis in Computational Science and Engineering from University of California, Berkeley. Her research focuses on automatic machine learning, ensemble machine learning and statistical computing. She also holds a B.S. and M.A. in Mathematics.

Before joining H2O.ai, she was the Principal Data Scientist at Wise.io and Marvin Mobile Security, and the founder of DataScientific, Inc. She is also founder of the Women in Machine Learning and Data Science (WiMLDS) organization (wimlds.org) and co-founder of R-Ladies Global (rladies.org).

Jeremy Howard

Jeremy Howard is a data scientist, researcher, developer, educator, and entrepreneur. Jeremy is a founding researcher at fast.ai, a research institute dedicated to making deep learning more accessible, and is an honorary professor at the University of Queensland. Previously, Jeremy was a Distinguished Research Scientist at the University of San Francisco, where he was the founding chair of the Wicklow Artifical Intelligence in Medical Research Initiative, the founding CEO of Enlitic, President and Chief Scientist of Kaggle, and CEO of FastMail as well as Optimal Decisions Group.

Dr. Husain Attarwala

Husain Attarwala is a clinical pharmacologist, pharmacometrician and a researcher in drug development. Currently, he is serving as Head of Clinical Pharmacology and Pharmacometrics at Moderna. His research focus on developing predictive models to guide clinical dose decisions for mRNA vaccines and therapeutics. Previously, Husain was a Principal Scientist at Alnylam Pharmaceuticals where his research helped guide dose selection for various novel siRNA therapeutics, 5 of which have received global regulatory approvals. He has obtained PhD and MS degrees in Pharmaceutical Sciences and Drug Delivery Systems from Northeastern University, and a Bachelors in Pharmacy from Al-Ameen college of pharmacy.

Concluding Thoughts

This year's keynote speaker lineup will not only give you a great look into what Julia is being used for in the wild today but also give perspective on solving some of the most challenging problems facing us today.

From Jeremy's experience scaling Fast.ai (one of the largest ML communities in the world), to Dr. LeDell's leadership in the ML space and relentless advocacy for equality, to Dr. Attarwala's contributions at Moderna which have touched many of our lives in the Covid-19 era, this is going to be an amazing set of talks.

If you have not already, make sure to register for free today: https://juliacon.org/2022/tickets/

We look forward to seeing you at JuliaCon 2022!

Breaking: Julia ranks in the top 5 most loved programming languages for 2022

Logan Kilpatrick — Thu, 23 Jun 2022 15:30:45 +0000

It should come as no surprise to those following the growth and expansion of the Julia Programming Language ecosystem that in this year's Stack Overflow developer survey, Julia ranked in the top 5 for the most loved languages (above Python - 6th, MatLab - Last, and R - 33rd).

As the Julia ecosystem continues to grow, more and more use-cases are becoming best in class. For example, in a blog post by Chris Elrod, Niklas Korsbo, and Chris Rackauckas, they showed that Julia can actually be 5x faster than PyTorch for small network development: https://julialang.org/blog/2022/04/simple-chains/. There are more and more examples like this where Julia is beginning to take the lead and drive more growth for the community.

Why do rankings like this matter?

One of the most important reason these rankings matter is in shifting the perception that Julia is not a production ready nor a stable language. Much has been said about Julia in the last few months and it's strengths as a language but surveys like this highlight that people who use the language are getting a tremendous amount of value from it and enjoy the experience. By publicizing these findings, hopefully we can shift the perception and highlight all of the ways people are enjoying Julia today.

How to make the most of oncoming Julia wave?

I have said time and time again that the companies, people, and projects betting on Julia early are going to garner a disproportionate amount of the value created by the ecosystem. While some have pushed back on this idea, it is truly a clear case of first movers advantage that plays out in the tech space all the time. Assuming you are convinced that Julia is the next big thing, and if you aren't you should read these articles I wrote #1, #2, #3, then the logical question is how to get involved.

Probably one of the best avenues to get a pulse on what the Julia community is up to is the annual JuliaCon conference: https://juliacon.org. It is a great way to see Julia in action with workshops, talks highlighting awesome use cases, and more from core ecosystem developers showing what the future for the language looks like. There are also a bunch of opportunities to meet people in the ecosystem which for me personally is a huge part of why I believe so deeply in the future of Julia.

The conference is free and takes play starting July 27th so make sure to sign up soon! Check out this video for a better sense of what the conference is like (note we are virtual this year but have local meetups):

Wrapping things up

Overall, the Julia community has never been in a better spot and surveys like this are an awesome way to validate this! I look forward to hopefully connecting with you at JuliaCon.
If you are as excited as I am about this survey, consider sharing it with folks on Twitter: https://twitter.com/OfficialLoganK/status/1539956444853846017?s=20&t=ZPR5aXuzdssUNIMSA1DEyw

Welcome to the Julia Community

Logan Kilpatrick — Wed, 01 Jun 2022 04:00:49 +0000

Welcome to the Julia Project community!

Leave a comment below to introduce yourself! You can talk about what brought you here, what you're learning, or just a fun fact about yourself.

Reply to someone's comment, either with a question or just a hello. 👋

Great to have you in the community!

The Julia Forem: What it is, why we made one, and how to use it!

Logan Kilpatrick — Sun, 15 May 2022 21:31:58 +0000

Welcome to the Julia Forem! If you are reading this, you are on our new Forem instance. You might be asking yourself a lot of questions like what is this new platform, why did we set it up, or maybe what the best way to use it is. Well, we are going to answer all of these questions and more in this post so stay tuned!

What is Forem?

Forem is the platform used to build https://dev.to and is now an open source project and company (similar in nature to discourse). I suggest reading a bit about Forem on their site: https://www.forem.com.

TLDR (too long didn't read): Forem is a community platform that allows you write technical and non-technical content alike in a way that lets people:

better engage with your content through comments and threads
automatically have great SEO so people actually read what you write
moderation tools
integration with other writing platforms and much more!

Why we are using Forem

Something people frequently say to me with respect to why they don't use Julia is that "there is not enough Julia content out there". While this is true to a certain degree, a much larger issue is that much of the content is very scattered on personal blogs, random sites, and other places which makes it hard to find and engage with. Even if someone can find your blog post, there might not be a comment functionality. On Medium for example, where I have posted a few articles, I have seen my own posts get 10k+ views without any meaningful conversation around the post (besides on Twitter).

Forem is an attempt at giving people a world class tool to write and share their Julia content with a community of people who can read, discussion, and amplify that content.

Note that while we have lots of community platforms like Discourse, Slack, Zulip, a Julia Twitter community, and many more, we see Forem as filling a gap that none of these other tools do. We don't expect Forem to replace any of them but rather act as a central hub to share, write, and discuss new Julia content.

How to use Forem

Think of Forem as your own personal blogging platform. You can come here, write a post, or just read some of the cool stuff others have been working on. You can also setup your Forem account to automatically pull articles from places like Medium or the like so you can cross post them here. You are also able to set the canonical URL which is a fancy SEO term that just means you can copy an article here and then tell Google (or other search engines) that this is just the copy and you really want people to go to this other link (like your personal blog for example).

You can read the Forem FAQ here: https://forem.julialang.org/faq

The bottom line, this is a space for the community to create and share content. We hope it will improve the experience of making content, increase the reach of said content, and reduce barriers for those looking to write about Julia.

What is next?

Forem is a new platform for us. So we aren't expecting anything crazy in the first couple of weeks. But we do hope that folks find value here and decide to post their articles for the community. If you have any questions, we will do our best to answer them!

Join us at JuliaCon 2022!

Logan Kilpatrick — Fri, 13 May 2022 00:31:45 +0000

In case you missed it, JuliaCon 2022 is fast approaching. The 3 day virtual conference will take place July 27th, 28th, and 29th with workshops happening before the main conference.

If you want to pick up a ticket, head to https://juliacon.org and register today.

We plan to have posters, workshops, talks, social events, swag, and much more! You are not going to want to miss JuliaCon this year 🎊