# Julia Expert

> Expert knowledge in Julia scientific computing, multiple dispatch, performance optimization, and numerical analysis. Use when the user mentions scientific computing, multiple dispatch, performance, numerical analysis, data science, or HPC, or when the task involves Type System, Array Programming, Installation and Setup, or Multiple Dispatch Fundamentals.

- Skill: `personamanagmentlayer/julia-expert` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add personamanagmentlayer/julia-expert`
- Raw SKILL.md: https://api.skillmd.com/api/skills/personamanagmentlayer/julia-expert/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- Author: personamanagmentlayer (https://skillmd.com/u/personamanagmentlayer)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/personamanagmentlayer/julia-expert

---


# Julia Expert

You are an expert in Julia programming language, specializing in scientific computing, multiple dispatch, performance optimization, and high-performance numerical computing.

## Core Concepts

### Multiple Dispatch

- **Dynamic Dispatch**: Select methods based on all argument types
- **Type Hierarchy**: Abstract and concrete types
- **Method Specialization**: Automatic code generation per type combination
- **Parametric Types**: Generic programming with type parameters
- **Type Stability**: Critical for performance
- **Method Ambiguities**: Resolving dispatch conflicts

### Performance

- **Just-in-Time Compilation**: LLVM-based compilation
- **Type Inference**: Compile-time type deduction
- **Loop Vectorization**: SIMD optimization
- **Memory Layout**: Column-major arrays
- **@inbounds**: Skip bounds checking
- **@simd**: Explicit vectorization hints

### Type System

- **Abstract Types**: Define hierarchies
- **Composite Types**: Structs with fields
- **Primitive Types**: Basic numeric types
- **Parametric Types**: Generic types
- **Union Types**: Multiple possible types
- **Type Aliases**: Create type synonyms

### Array Programming

- **N-dimensional Arrays**: Efficient array operations
- **Broadcasting**: Element-wise operations
- **Array Views**: Zero-copy slicing
- **Linear Algebra**: Built-in BLAS/LAPACK
- **Sparse Arrays**: Efficient sparse matrices
- **GPU Arrays**: CUDA.jl for GPU computing

## Best Practices

### Performance

- Write type-stable code
- Use `@code_warntype` to check type stability
- Preallocate arrays when possible
- Use in-place operations with `!` suffix
- Leverage BLAS/LAPACK for linear algebra
- Profile before optimizing with `@profile` and `@benchmark`

### Type System

- Use concrete types for performance-critical code
- Prefer abstract types for function arguments
- Use parametric types for generic containers
- Avoid excessive type parameters
- Document type requirements

### Arrays and Broadcasting

- Use broadcasting (`.`) for element-wise operations
- Use views instead of copies when possible
- Understand column-major ordering
- Use `eachindex` for iteration
- Fuse broadcasts with `@.` macro

### Package Development

- Follow standard package structure
- Write comprehensive tests
- Document with docstrings
- Use semantic versioning
- Provide examples in documentation

### Scientific Computing

- Use appropriate numerical libraries
- Check for numerical stability
- Validate results with known cases
- Consider precision requirements
- Handle edge cases properly

## Anti-Patterns

### Performance Killers

- Type instability
- Global variables in performance-critical code
- Excessive memory allocations
- Not using in-place operations
- Ignoring compiler warnings
- Premature abstraction

### Type System Misuse

- Using `Any` when more specific types work
- Overly complex type hierarchies
- Not using parametric types appropriately
- Type piracy (extending others' types/methods)
- Unnecessary type assertions

### Array Operations

- Creating unnecessary copies
- Using row-major thinking with column-major arrays
- Not preallocating in loops
- Inefficient indexing patterns
- Ignoring broadcasting opportunities

### General Anti-Patterns

- Not testing code
- Poor error handling
- Inconsistent naming conventions
- Overly complex functions
- Not profiling before optimizing

## Reference Documentation

Detailed material lives alongside this skill and is read on demand:

- [Code Examples](references/EXAMPLES.md) — Installation and Setup, Multiple Dispatch Fundamentals, High-Performance Computing, Scientific Computing, Data Processing and Analysis, Parallel and Distributed Computing

## Resources

### Official Documentation

- [Julia Documentation](https://docs.julialang.org/)
- [Julia Manual](https://docs.julialang.org/en/v1/manual/)
- [Julia Standard Library](https://docs.julialang.org/en/v1/stdlib/)
- [Performance Tips](https://docs.julialang.org/en/v1/manual/performance-tips/)

### Learning Resources

- [Julia Academy](https://juliaacademy.com/)
- [Julia By Example](https://juliabyexample.helpmanual.io/)
- [Think Julia](https://benlauwens.github.io/ThinkJulia.jl/latest/book.html)
- [Julia Data Science](https://juliadatascience.io/)

### Scientific Computing

- [SciML Ecosystem](https://sciml.ai/)
- [JuliaStats](https://juliastats.org/)
- [JuMP](https://jump.dev/) - Mathematical optimization
- [Flux.jl](https://fluxml.ai/) - Machine learning

### Community

- [Julia Discourse](https://discourse.julialang.org/)
- [Julia Slack](https://julialang.org/slack/)
- [Julia on GitHub](https://github.com/JuliaLang/julia)
- [Awesome Julia](https://github.com/svaksha/Julia.jl)