The DataFrames.jl tutorial pins its environment and keeps the versions honest

The tutorial states the version it targets

The tutorial is written for DataFrames.jl 1.8.2, and that version statement is the first substantive line after the title. It is a short document by design, a brief introduction to the basic usage of DataFrames, with the date on the front page showing it was refreshed in February 2026.

The version targeting is not decoration. A tutorial that shows API calls without saying which release they belong to is a tutorial you cannot follow without guessing, and the Julia package ecosystem moves fast enough that the difference between a 0.19-era and a 1.8-era DataFrames is visible in the code. The author also says he will try to keep the tutorial up to date as the packages evolve, which is a promise about maintenance rather than a schedule, but the dated front page makes the currency checkable.

The scope is stated too. The tutorial covers DataFrames.jl and CategoricalArrays.jl, because those two constitute the core of DataFrames.jl, along with selected file reading and writing packages.

One command makes the notebooks reproducible

Before opening any notebook, the environment has to be prepared, and the project folder holds a Project.toml and a Manifest.toml. The command to do it is one line in the Julia package manager, activating the project and instantiating it:

julia -e 'using Pkg; Pkg.activate("."); Pkg.instantiate()'

That single line is the whole installation step, and it is what makes the rest of the repository work. With a Manifest.toml present, instantiate resolves to exactly the versions recorded there rather than to the newest compatible ones, so the code in the notebooks behaves the way it did when the author wrote it.

The dependency list in the README shows how wide that environment is. Beyond DataFrames 1.8.2 and CategoricalArrays 1.1.1 there is CSV, Arrow, JSONTables, JLSO, ZipFile and CodecZlib for files, Tables and PooledArrays for the table interface, DataFramesMeta for the macro style syntax, FreqTables for frequency counts, StatsPlots for plotting, NamedArrays and Chain and FileIO, IJulia for the notebook kernel, plus BenchmarkTools and Statistics. The tutorial was tested under Julia 1.13.0.

Thirteen notebooks, ordered by the task you are doing

The curriculum is thirteen notebooks numbered from 01 to 13, and the order is the interesting part of the design. It is organised by task rather than by package, so each file answers one question.

The first four are the foundation: 01_constructors covers creating a DataFrame and converting to one, 02_basicinfo covers getting summary information, 03_missingvalues covers handling missing values, and 04_loadsave covers loading and saving. The middle block is the working vocabulary of a data frame: 05_columns for working with columns, 06_rows for working with rows, 07_factors for categorical data, 08_joins for joining frames, 09_reshaping for reshaping them, and 10_transforms for transforming them.

The last three are where a tutorial usually stops and where this one does not. 11_performance is a set of performance tips, 12_pitfalls is a list of possible pitfalls, and 13_extras covers additional packages.

The two files for rows and for performance have a history worth noting from the changelog. A row extraction example was added in April 2018, a byrow! example in May 2018, and the performance tips in December 2017, so the chapters were shaped by what readers kept asking about.

Categorical data gets its own chapter

The decision to cover CategoricalArrays.jl alongside DataFrames.jl is a deliberate scoping choice, and it is what makes chapter 07 a subject in its own right rather than an aside.

A factor in DataFrames is not just a string column with extra steps, and a tutorial that treated it that way would be teaching the wrong mental model. By giving the package its own chapter, the tutorial can treat the distinction between a categorical column and an ordinary one as a first class idea, and by including it in the pinned environment, the examples are checked against a specific version of the package rather than whatever a reader happens to have.

This is also where the tutorial's stated philosophy shows. The author describes the last chapter as mentioning selected functionalities of selected useful packages that he finds useful for data manipulation, and the three named are FreqTables.jl for frequency counts, DataFramesMeta.jl for its macro style manipulation syntax, and StatsPlots.jl for plotting. Selection implies a judgement about what a reader needs, and it is a judgement you can disagree with and then follow the links to the packages themselves.

Performance and pitfalls are curriculum, not appendices

Chapter 11 is a set of performance tips and chapter 12 lists possible pitfalls. Both were added within the first two weeks of the tutorial's life, in December 2017, which says something about the author's priorities, and both were reworked for the Julia 1.0 release in August 2018.

The pairing matters more than either chapter alone. Performance advice without a warning list is a list of rules to memorise, and a warning list without performance advice is a list of things to fear. Read together they answer the two questions a Julia newcomer actually has about a data frame: why is this slow, and why did this do something surprising.

The changelog shows the same files being maintained as the ecosystem changed. The 0.14.0 and 0.14.1 updates in 2018 added a couple of functions, the 0.16.0 update in January 2019 added serialization instructions, and the 0.17.0 update added passmissing, a function that maps over columns while keeping missing values intact. Those are the kind of small API additions that make a tutorial's examples stop working, and the changelog records each repair.

The changelog is the real maintenance record

The README carries a dated changelog that runs from the initial release on 2017-12-05 to the entries of 2019, and it is more informative than the tag list.

The tags tell a confusing story at first. The most recent release is v0.19.0 from 2019-07-16, described as the tutorial for DataFrames 0.19.0, and before that there are tags for Julia 0.6.4 and for DataFrames 0.11.6. Those tags describe the tutorial as it was for old package versions, and they stopped moving years ago, while the content kept going: the changelog records updates to DataFrames 0.19.3 and Julia 1.2 in August 2019, and the front page of the README now says the tutorial is for DataFrames 1.8.2 and was tested under Julia 1.13.0.

So the git history and the changelog, not the release tags, are where the history of this project lives. The last push was on 2026-09-12, the repository is not archived, and the licence is MIT with the LICENSE file at the root.

Where this tutorial stops and the documentation takes over

The obvious limit is that this is an introduction, not a reference. Thirteen notebooks on constructors, summary information, missing values, load and save, columns, rows, factors, joins, reshaping, transforms, performance, pitfalls and extras cover the working surface of DataFrames.jl, and everything beyond that surface is a link away.

The second limit is that it is version-bound in a way that matters. The notebooks target DataFrames 1.8.2 and CategoricalArrays 1.1.1, and while the pinned environment keeps them running, a reader who copies a snippet into their own project with a different version may find the behaviour has moved, particularly in the missing value handling and the transformation chapters, where the API has changed across the 0.x to 1.x transition.

The third is that it is not a course in data analysis. There is no statistics content, no modelling, no cleaning methodology, and the plotting chapter is a pointer to StatsPlots rather than a treatment. If what you need is to learn how to work with data frames in Julia, this is an efficient route. If you need to learn how to analyse data, it will not take you there.

Editorial conclusion

The tutorial fits a Julia developer who wants a working, ordered introduction to DataFrames.jl and CategoricalArrays.jl with the environment already solved, since a Manifest.toml means the notebooks run against the versions the author tested rather than whatever the registry serves today. It is not a substitute for the DataFrames.jl documentation, and it is not a course in statistics or modelling. Before you work through it, check three things: that your Julia is 1.13.0 or that you are willing to use the pinned environment as the author set it up, that you actually need DataFrames and CategoricalArrays rather than a lighter table interface, since the tutorial is organised around those two, and that you read the pitfalls chapter, which the author put in the curriculum deliberately. The licence is MIT, the tutorial targets DataFrames 1.8.2, and the last push was on 2026-09-12.

Frequently asked questions

Official sources

1. bkamins/Julia-DataFrames-Tutorial on GitHub
2. Issues
3. License: MIT
4. README
5. Releases