Advent of Code with OCaml: Building a Complete Automation Pipeline

Every December, thousands of developers participate in Advent of Code, a series of 25 programming puzzles released daily. This year, I decided to tackle it using OCaml and built something special: a completely automated pipeline that handles everything from input downloading to solution submission.

The Vision: Zero Manual Steps

The typical Advent of Code workflow involves a lot of manual steps:

1. Navigate to the website
2. Copy the puzzle input
3. Create a solution file
4. Run your solution
5. Copy the answer back to the website
6. Submit and hope for the best

I wanted to eliminate all of this manual work. The result? A sophisticated OCaml project that can solve and submit puzzles in seconds, all from the terminal.

🎥 See It In Action

The video above shows the complete pipeline in action, including the beautiful Christmas tree visualization for Day 14 Part 2!

Project Architecture

The project is structured around a powerful Makefile system that orchestrates everything:

advent-of-code-ocaml/
├── 2024/dayXX/          # Individual day solutions
├── day_template/        # Template for new days
├── inputs/2024/         # Downloaded puzzle inputs
├── answers/2024/        # Generated answers
├── benchmark/           # Performance results
└── Makefile             # The automation magic

Key Features

1. Automatic Day Creation

make new-day

This command:

• Creates a new day directory from a template
• Fetches the problem title from Advent of Code
• Sets up the basic OCaml structure
• Prepares test files

2. Smart Input Management

make download DAY=01
make run-day DAY=01 INPUT=download

The system can:

• Automatically download puzzle inputs using your session token
• Cache inputs locally to avoid unnecessary requests
• Support multiple input sources (downloaded, custom files, test data)

3. Lightning-Fast Execution

make run-release DAY=01 INPUT=download

OCaml's performance shines here. Solutions typically run in under 0.3 seconds, even for complex puzzles!

4. Intelligent Submission

make submit DAY=01 PART=1
make run-submit DAY=01 INPUT=download

The submission system:

• Prevents duplicate submissions
• Allows individual part submission
• Provides interactive prompts for bulk submission
• Saves answers automatically

The OCaml Advantage

Why OCaml for Advent of Code? Several reasons:

Pattern Matching Excellence

OCaml's pattern matching makes parsing puzzle inputs elegant:

let parse_instruction = function
  | "forward" :: x :: [] -> Forward (int_of_string x)
  | "up" :: x :: [] -> Up (int_of_string x)
  | "down" :: x :: [] -> Down (int_of_string x)
  | _ -> failwith "Invalid instruction"

Immutable Data Structures

Functional programming concepts like immutability help avoid common bugs in algorithmic challenges:

let rec solve grid visited current =
  match current with
  | [] -> visited
  | pos :: rest when Set.mem pos visited -> solve grid visited rest
  | pos :: rest -> 
      let new_positions = get_neighbors grid pos in
      solve grid (Set.add pos visited) (new_positions @ rest)

Strong Type System

OCaml catches many errors at compile time, which is invaluable when racing against the clock:

type direction = North | South | East | West
type position = { x: int; y: int }
type state = { pos: position; dir: direction; steps: int }

Development Workflow

The typical workflow is incredibly streamlined:

1. Morning preparation: make new-day
2. Get the input: make download DAY=XX
3. Develop solution: Edit the OCaml code
4. Test and run: make run-current INPUT=download
5. Submit: make submit DAY=XX PART=1

That's it! No browser switching, no copy-pasting, no manual steps.

Performance Insights

OCaml's performance characteristics make it excellent for competitive programming:

• Compilation speed: Incremental builds are nearly instantaneous
• Runtime performance: Most solutions complete in milliseconds
• Memory efficiency: Functional data structures are surprisingly memory-efficient
• Debugging: Strong types catch logic errors early

Testing and Quality

The project includes comprehensive testing support:

make test          # Run all tests
make test-01      # Test specific day
make fmt          # Format code
make benchmark-01 # Performance testing

Environment Setup

Getting started is straightforward:

# Install OCaml and opam
opam install dune core

# Clone the repository
git clone https://github.com/aguluman/advent-of-code-ocaml
cd advent-of-code-ocaml

# Set up authentication (optional)
echo "AUTH_TOKEN=your_session_token" > .env

# Create your first day
make new-day

Advanced Features

Nix Integration

For reproducible builds across environments:

nix develop  # Enter development environment

Smart Input Handling

The system intelligently handles different input sources:

• INPUT=download: Fetch from Advent of Code
• INPUT=puzzle_input: Use repository inputs
• INPUT=custom.txt: Use custom file

Answer Management

All answers are automatically saved to answers/2024/ for easy reference and resubmission.

Lessons Learned

Building this automation taught me several valuable lessons:

1. Tool investment pays off: Spending time on tooling early saves hours later
2. OCaml scales beautifully: From simple scripts to complex automation
3. Functional programming fits: Immutability and pure functions reduce bugs
4. Performance matters: Fast feedback loops improve the development experience

Future Enhancements

The project continues to evolve with ideas like:

• Automatic solution templates based on problem patterns
• Integration with OCaml documentation tools
• Performance regression testing
• Solution visualization tools

Conclusion

This Advent of Code OCaml project demonstrates that with the right tooling and language choice, competitive programming can be both efficient and enjoyable. The complete automation pipeline eliminates friction and lets you focus on what matters: solving interesting problems.

The combination of OCaml's expressiveness, strong typing, and excellent performance makes it an ideal choice for algorithmic challenges. Whether you're a functional programming enthusiast or looking to try something new for next year's Advent of Code, I highly recommend giving OCaml a try.

Check out the complete project on GitHub and see the automation in action!

Quick Start Commands

# Get started
make help

# Create a new day
make new-day

# Download input and run
make run-day DAY=01 INPUT=download

# Submit solution
make submit DAY=01 PART=1

Happy coding! 🎄✨