Julia Community 🟣

Cover image for 5 important talks you might have missed at JuliaCon 2022
Logan Kilpatrick
Logan Kilpatrick

Posted on • Originally published at logankilpatrick.Medium

5 important talks you might have missed at JuliaCon 2022

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.

Julia vs Python loading times

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!

Top comments (3)

Collapse
digital_carver profile image
SundaraRaman R • Edited on

Thank you for posting this here! (Medium is difficult to use for non-logged-in users, so I'm glad to see this on Forem.)

I still have a list of talks I would like to watch. But among the ones I've watched, some of my favourites were:

  1. Compile-time programming with CompTime.jl
  2. Comonicon, a full stack solution for building CLI applications
  3. Interactive Julia data dashboards with Genie
  4. Build an extensible gallery of examples (DemoCards.jl)
  5. Julia REPL Mastery Workshop

I loved the ones you've mentioned too, especially: Makie is always awe-inspiring, and the VS Code extension is jumping ahead by leaps and bounds every update.

A few other honorable mentions that I liked too: "Juliaup - The Julia installer and version multiplexer", "Optimization of bike manufacturing and distribution (use-case)", and "Data Analysis and Visualization with AlgebraOfGraphics".

Collapse
notegrab profile image
notegrab

Great post, for a great Julia2022 con!

"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"
Couldn't stress that too much!

Maybe that's a bit idealistic, but Im dreaming of a workflow consisting in:

  • Doing REPL-based interactive package development
  • + static compilation that "prunes" the set of functions to be placed on a .so file, based on what's already compiled in the sysimage OR based on a set of unit tests.

Understandably, this would require a lot of hard work deep done into the Julia "core", but this would help so much in spreading its use ...

Collapse
tmigot profile image
tmigot

There was some many interesting talks, it is tricky to select only 5. I found Jeremy Howard's What makes a programming language successful? particularly interesting as it is a topic of high importance for those investing time and energy to Julia.

It seems as Julia is more dev-oriented than user-oriented.