Kristoffer Carlsson

[Package extensions](https://pkgdocs.julialang.org/dev/creating-packages/#Conditional-loading-of-code-in-packages-(Extensions)) are a new feature for packages available in Julia 1.9. It aims to solve the problem where you might be reluctant to take on a package as a dependency just to extend a function to a type in that package due to e.g. increased load time of the package.

The multiple dispatch paradigm of Julia makes it very easy to extend functionality to new types. A package can just define a new method of a generic function that accepts a type in another package, and anyone that calls that function with that type will get the extended behavior. An example of this could be a plotting package that extends a plotting method to various types in the Julia ecosystem.

However, to extend a method with a type from another package, one needs to make that package a dependency. This has a cost, most noticeably in package load time. This means that for a package author, there is always a conflict between wanting to provide useful method extensions and keeping the load time of the package small.

The go-to solution for the problem above has been the Requires.jl package. In Requires.jl one defines a piece of code that gets automatically executed when another package is loaded. This code typically adds some extra method for one of the types in the package. Since you are not directly depending on the package, you no longer unconditionally pay the loading cost of it.

Unfortunately, Requires.jl comes with some drawbacks:
- The code that gets executed when a package gets loaded is `eval`-ed into the module which means that that code can not be precompiled, leading to worse latency.
- It is not possible to set any compatibility constraints on the packages triggering the
- Requires.jl had issues with PackageCompiler since it needed access to files during runtime.

The new ["package extension"](https://pkgdocs.julialang.org/dev/creating-packages/#Conditional-loading-of-code-in-packages-(Extensions)) functionality in 1.9 is meant to fully replace the usage of Requires.jl while solving the issues mentioned above. This talk will give an overview of how the new extension system works, discuss best practices and give some examples of its usage from the package ecosystem.

Continuous Improvement of the CI ecosystem in Julia

26-100

Package extensions

The Julia release process is important since it's the process by which all the work that goes into the Julia language gets delivered to users.  
This talk details the various steps that are made to ensure that Julia releases are of high quality with few regressions, both in correctness and performance.

The Julia release process is important since it's the process by which all the work that goes into the Julia language finally gets delivered to users in the form of an official release. Faults and regressions in Julia releases leads to confusion, disappointment and potentially reduced trust in Julia as a language. Therefore, there are quite a few steps in the Julia release process that are there to try catch potential issues before an official release is made.

This talk will show how these various quality checks are done in practice and some examples of regressions found by them. It will also detail various parts where there improvements could be made as well as how the general Julia community can help make creating new high quality releases easier for the release managers.

Making a Julia release

This is a light hearted talk that looks at some interesting statistics and tidbits of the Julia repo from the almost 15 years it has existed.

The Julia repository has existed for almost 15 years with the first commit being done at Sat Aug 22 20:39:06 2009. Over 50'000 commits has been made, 22'000+ issues and 25'000+ PRs have been opened and 130+ releases have been tagged. 

This light hearted talk presents some of the more interesting statistics from the Julia repo. Among others, here are some of the questions that will be answered:

- How has the ratio of open to closed PRs and issues evolved over time? How does this compare to the repositories of other languages. Are there any conclusions to be made from this.
- How has the frequency of Julia releases changed over time. 
- What PR has the longest title? What PR was the fastest from creation to merge? What PR took the longest from getting created to getting merged? Etc.

As a bonus, the presentation for this talk is made completely programatically and can be regenerated with a single command to incorporate the future data.

Kristoffer Carlsson

Talks:

Package extensions

Making a Julia release

A brief history of the Julia repository

Platinum sponsors

Gold sponsors

Silver sponsors

Bronze sponsors

Academic partners

Local partners

Fiscal Sponsor