To my surprise, this newsletter is now running for a whole year...
A monthly newsletter, mostly on Julia internals: a biased, incomplete, editorialized list, with contributions from the community. Subscribe by email on Discourse.
A new Documenter.jl frontend provides for nice “modern looking” documentation pages. Some folks are experimenting with converting the default Julia docs to this new frontend. Also discussed on slack.
Frame’s frustration with generic error() exceptions without valuable metadata led to discussion of Timothy’s draft proposal for better error reporting in Julia.
A slack discussion on duck typing and interfaces in Julia vs Rust.
Discussion on the paradigm differences between Julia and Rust which lead to Julia being comparatively slower to compile (chiefly stemming from Julia’s “open world” extensibility).
Why is it difficult to provide certain other Rust-like ergonomics, e.g. amazing interactive type-stability reports as you type your code in your IDE?
Maybe you should not do this, but here is a brief discussion on how far can you push Julia’s goto for manipulating your own (potentially faster) call stack.
Improvements to the matrix multiplication dispatch tree, potentially significantly improving type stability and performance.
About.jl is getting fancier and fancier. It now gives a pretty nice overview of infer_effects for any function (i.e. it reports what the compiler has proved/assumed about a function).
deepcopy(nothing) vs copy(nothing) is a convenient reason to revisit some of the semantics of the copy interface.
OpenBLAS now has an interface to cooperate with threads provided by an external runtime. Maybe soon enough we will have freely nestable multithreading aware of OpenBLAS threads.
Significant performance improvements might be possible if we start special-casing the construction and storage of small strings.
Folks are looking into more ways to visualize reports from the full-ecosystem continuous integration runner (nanosoldier)
A few stories on what “Undefined Behavior” is for the Julia compiler, on slack and github
Upgrading Julia’s LLVM backend to v17 is almost finished.
Get ready for another bikeshedding session as we are discussing the potential for creating anonymous “get property” functions (e.g. .foo as shorthand for x -> x.foo). Check out the PR.
The “Performance Tips” section of the documentation has finally been structured to reflect the main categories of advice, see the new docs and the PR
Issue bounties are still up for grabs at the Plots.jl repository
Version 1.0 of ADTypes.jl (the autodiff package chooser) has been released, with support for all existing autodifferentiation packages and a more coherent handling of sparsity. Updating dependents is an ongoing process.
Lux.jl now supports much better nested autodifferentiation.
Folks sharing tips and tricks on their preferred approach to data science in Julia.
Tidier, the tidy-verse-style Julia data science ecosystem has new docs.
Native Julia engine for quarto using QuartoNotebookRunner.jl
A new advanced extremely fast random sampler that is soon to be incorporated in most of Julia foundational statistics packages: AliasTables.jl
Rambus.jl is a new serialization / message passing toolkit for Julia and other languages.
BayesianTomography.jl was recently released for quantum state tomography.
A lovely list of well documented packages that you can use as an inspiration for your documentation writing.
An essay and paper of Julia’s potential for being best-in-class statistical software framework.
Prometheus is an open source software for tracking the performance of servers and systems. We have a convenient Julia interface for Prometheus now.
Changelog.jl can help with managing and prettifying a Changelog file (potentially as part of a Documenter.jl deployment).
Discussion on the difficulties of creating a convenient interfacing package for binding Rust in Julia.
Interesting “experience report” from a developer that recently finished a big self-contained software project in Julia. Might be of value for people brainstorming dev tool improvements.
Gripes and suggestions on using Arrow, Parquet, and HDF5 as data storage formats from Julia.
Chapel is an interesting language to keep an eye on if you are into high-performance numerical computing. Their yearly conference is happening soon.
Rust is floating the idea of experimenting with “calling conventions”, i.e. how at machine-code level function arguments are mapped to CPU registers. Discussed on our slack and on hacker news.
A great thorough primer on Automatic Differentiation in Julia.
Consider subscribing to the French community newsletter (much of the shared materials are in English).
Consider subscribing to the community calendar to be informed of upcoming virtual meetings and talks.
Consider attending the triage meetings of the julia core contributors (organized on slack) – being a fly on the wall can be a great way to learn the nitty-gritty details of current priorities and development work. These are organized on the triage channel in slack.
Summer school on numerical methods in quantum information science, mostly presented in Julia. Happening in August, near Boston.
You can engage in the discussion of this newsletter on Discourse