Essential Packages

Progressive introduction to Julia's scientific computing ecosystem

Julia's package ecosystem is designed for scientific and technical computing. This guide introduces packages progressively: start with essentials, then explore intermediate tools, and finally discover the advanced ecosystem when you're ready.

Learning Objectives

By the end of this guide, you should be able to:

  • [ ] Install and use the 10 most essential Julia packages for scientific computing
  • [ ] Understand when to use intermediate packages for specialized tasks
  • [ ] Navigate the advanced ecosystem for expert-level computing
  • [ ] Choose the right packages for your specific workflow

Legend:

  • [base] = Julia Base / stdlib (no install needed)
  • [extra] = Needs installation (Pkg.add("..."))

Essential Packages (Start Here) - 10 minutes

Goal: Core Julia packages every scientific computing user needs When to read: Right after installing Julia, before starting any project

These 10 packages form the foundation of scientific Julia. Learn these first:

Must-Have Core (Install these first)

PackagePurposeBase?Why Essential
LinearAlgebraMatrix operations, decompositions[base]Every scientific computation uses matrices
StatisticsMean, std, correlation[base]Basic data analysis in any workflow
DataFramesTabular data (like pandas)[extra]Most data comes in tables/spreadsheets
PlotsVisualization and plotting[extra]See your results, debug your code
CSVRead/write CSV files[extra]Most common data exchange format

Essential Scientific Computing

PackagePurposeBase?Why Essential
DistributionsStatistical distributions, sampling[extra]Model uncertainty, generate test data
RandomRandom number generation[base]Simulations, sampling, reproducible research
FFTWFast Fourier Transform[extra]Signal processing, frequency analysis
OptimOptimization algorithms[extra]Parameter fitting, minimization problems
BenchmarkToolsAccurate performance timing[extra]Essential for Julia performance development

✅ Try This (8-12 minutes)

Exercise: Complete "Working with Data" from Julia Academy Link: https://juliaacademy.com/p/intro-to-julia (Section 5) Goal: Master DataFrames.jl and Plots.jl for data analysis Time: 8-12 minutes

Interactive Tutorial: Follow "DataFrames.jl Tutorial" Link: https://dataframes.juliadata.org/stable/man/getting_started/ Focus: Tabular data manipulation, grouping, joining

Plotting Practice: Complete "Plots.jl Tutorial" Link: https://docs.juliaplots.org/latest/tutorial/ Goal: Create publication-quality visualizations

📖 Why These Matter

Foundation for everything: These packages appear in 90% of Julia scientific workflows. Master them first before exploring specialized tools. They provide the core functionality that other packages build upon.


Intermediate Packages (When You're Ready) - 20 minutes

Goal: Specialized tools for common scientific computing tasks When to read: After mastering essentials, when you need specific functionality

These packages solve common problems in scientific computing. Add them as your projects grow:

Advanced Mathematics & Statistics

PackagePurposeWhen You Need It
SpecialFunctionsΓ, ζ, Bessel, Airy functionsAdvanced mathematical functions
DifferentialEquationsODEs, PDEs, SDEs, DDEsSolving differential equations
RootsFind roots/zeros of functionsNumerical equation solving
LsqFitNonlinear curve fittingFitting models to data
HypothesisTestsStatistical testsRigorous statistical analysis
StatsBaseExtended statisticsBeyond basic mean/std
GLMGeneralized linear modelsStatistical modeling

Scientific Domains

PackageDomainWhen You Need It
Unitful, UnitfulAstroUnits (SI, astronomical)Physical calculations with units
MeasurementsError propagationHandling experimental uncertainties
AstroLibAstronomical utilitiesAstronomy calculations
DSPSignal processingDigital signal analysis
ImagesImage processingWorking with image data
MLJMachine learningData science, predictive modeling

Development & Productivity

PackagePurposeWhen You Need It
ReviseLive code reloadingFaster development workflow
DebuggerInteractive debuggingFinding bugs in complex code
ProgressMeterProgress barsLong-running computations
LoggingAdvanced loggingProduction code, debugging

✅ Try This (12-15 minutes)

Scientific Computing: Complete "Julia for Scientific Computing" tutorial Link: https://github.com/mitmath/julia-mit (Lecture 1) Goal: Units, measurements, and scientific workflows Time: 12-15 minutes

Units Practice: Work through "Unitful.jl Documentation" Link: https://github.com/PainterQubits/Unitful.jl (Tutorial section) Focus: Physical units, conversions, dimensional analysis

Error Propagation: Explore "Measurements.jl Examples" Link: https://github.com/JuliaPhysics/Measurements.jl (Examples) Goal: Uncertainty quantification in scientific computing

📖 Why This Level Matters

Specialized solutions: These packages solve specific problems efficiently. Don't try to learn them all at once - add them when your projects need their functionality. Each provides professional-grade tools for its domain.


Advanced Ecosystem (For Experts) - Reference

Goal: Comprehensive package landscape for specialized needs When to read: When you need highly specialized functionality or are building production systems

This comprehensive reference covers the full Julia ecosystem. Use it as a lookup when you need specific capabilities:

File Formats & Data Exchange

PackageFormatUse Case
JLD2Julia native binaryFast Julia data serialization
HDF5HDF5 scientific dataCross-platform scientific data
MATMATLAB .mat filesMATLAB interoperability
FITSIOFITS (astronomy)Astronomical image/table data
NetCDFNetCDF scientificClimate/atmospheric data
NPZ, NpyNumPy .npy/.npzPython interoperability

Advanced Visualization

PackageCapabilityUse Case
CairoMakiePublication 2D plotsScientific publications
GLMakieInteractive 3D graphicsData exploration
WGLMakieWeb-based plotsInteractive dashboards
PyPlotMatplotlib integrationPython workflow integration
AlgebraOfGraphicsGrammar of graphicsStatistical visualization
PlotlyJSInteractive web plotsDashboards, presentations

Development Environment

ToolPurposeUse Case
VS Code + JuliaFull IDEComplete development environment
IJuliaJupyter notebooksInteractive analysis
PlutoReactive notebooksTeaching, exploration
WeaveLiterate programmingReports, documentation
ProfileViewPerformance profilingCode optimization

High-Performance Computing

PackageCapabilityUse Case
CUDAGPU computingMassive parallel computation
MPIDistributed computingCluster computing
DaggerTask parallelismComplex parallel workflows
SharedArraysShared memoryMulti-process arrays
PackageCompilerBinary compilationDeployment, performance

Machine Learning & AI

PackageFocusUse Case
FluxNeural networksDeep learning research
MLJClassical MLComprehensive ML toolkit
KnetGPU-accelerated DLHigh-performance deep learning
ScikitLearnPython ML integrationFamiliar scikit-learn interface

✅ Check Your Understanding - Complete Package Journey

Before moving on, you should now be able to:

  • [ ] Install and use the 10 essential packages for any Julia project
  • [ ] Identify when you need intermediate packages for specialized tasks
  • [ ] Navigate the advanced ecosystem reference when needed
  • [ ] Choose appropriate packages based on your specific requirements

🚀 Hands-on Validation (20-25 minutes)

Complete Project: Build a mini data analysis project using essential packages Link: https://juliaacademy.com/p/introduction-to-dataframes-jl (Final Project) Goal: Demonstrate mastery of DataFrames, Plots, CSV, and Statistics Time: 20-25 minutes

Package Exploration: Create a Pluto.jl notebook with scientific computing workflow Link: https://github.com/fonsp/Pluto.jl (Sample notebooks) Focus: Combine multiple packages in interactive environment

Community: Browse and contribute to "Julia Packages" on GitHub Link: https://github.com/JuliaLang (Explore ecosystem) Goal: Understand package development and contribution patterns

🚀 What's Next?

Depending on your goals:

Expected next reading time: 30-120 minutes depending on your path

📖 Package Discovery Tips

Finding packages: Search juliahub.com or pkg.julialang.org Getting help: Julia Discourse, Slack, Zulip, StackOverflow, GitHub Best practices: Use ] activate . for project environments, Project.toml for reproducibility Language interop: PythonCall.jl for Python, RCall.jl for R, ccall for C/Fortran