Space Age in Clojure: Complete Solution & Deep Dive Guide

Clojure Space Age: A Complete Guide to Calculating Interplanetary Age

Calculating interplanetary age in Clojure involves converting a time value in seconds to Earth years, then dividing by a planet's specific orbital period factor. This is elegantly handled using a map of planetary data and dynamically generated functions for each planet, showcasing Clojure's powerful, data-driven metaprogramming capabilities.

The year is 2525. You've just embarked on an epic journey to visit every planet in our Solar System. Your first stop is Mercury, where the local customs require you to fill out a standard entry form. As you hand the completed document to the officer, they scrutinize it, their brow furrowed in suspicion.

"Do you really expect me to believe you're just 50 years old?" they ask, pointing at your form. "Based on our temporal scans, you must be closer to 200!" Amused, you realize the problem: you filled out your age in Earth years, but on Mercury, where a year passes in just 88 Earth days, you are indeed much, much older. This cosmic bureaucracy highlights a fascinating programming challenge—one that Clojure is uniquely equipped to solve.

This guide will walk you through solving this "Space Age" problem, a classic exercise from the kodikra.com learning curriculum. We'll explore not just the solution, but the fundamental Clojure concepts that make it so elegant, from data-driven design to the magic of metaprogramming. You'll learn how to think in Clojure and write code that is both powerful and expressive.

What is the Space Age Calculation Problem?

The core task is to build a utility that, given an age in seconds, can accurately calculate how old someone would be on various planets in our solar system. The calculation hinges on a single, crucial constant: one Earth year is equivalent to 31,557,600 seconds (which is 365.25 days).

The age on any other planet is determined by its orbital period—the time it takes to complete one full orbit around the Sun—relative to Earth's. For example, since Mars takes 1.88 Earth years to orbit the Sun, a person would age more slowly there.

To solve this, we need the following orbital period data, expressed in Earth years:

The formula is straightforward:
Age on Planet = (Age in Seconds / Seconds in an Earth Year) / Planet's Orbital Period

The challenge lies not in the math itself, but in implementing it in a clean, scalable, and idiomatic Clojure way.

Why Clojure is a Perfect Fit for This Problem

Clojure, a modern Lisp dialect running on the Java Virtual Machine (JVM), offers a unique set of features that make it exceptionally well-suited for data manipulation problems like this one. Its philosophy encourages developers to build systems out of simple, composable parts.

Data-Driven by Nature

At its heart, Clojure treats data as a first-class citizen. The planetary orbital periods are a perfect candidate for being stored in one of Clojure's immutable data structures, like a map. This separates the data (the "what") from the logic (the "how"), making the code easier to read, maintain, and extend. If we discover a new planet, we just add an entry to the map—no code changes required.

Immutability and Pure Functions

Clojure's emphasis on immutable data structures and pure functions eliminates entire classes of bugs related to state management. In our Space Age calculator, the input (seconds) and the planetary data are never changed. Functions simply take this data and produce a new value (the age), leading to predictable and testable code.

Metaprogramming: Code as Data

As a Lisp, Clojure has a powerful feature called "homoiconicity," which means the code itself is represented by the language's own data structures (in this case, lists). This allows for metaprogramming—writing code that writes code. As we'll see in the solution, this enables us to dynamically generate a specific function for each planet from our data map, which is a highly idiomatic and powerful Clojure pattern.

Conciseness and Expressivity

Clojure's functional nature and rich standard library allow you to express complex ideas with very little code. The solution to the Space Age problem is remarkably compact yet highly readable once you understand the core concepts at play.

How to Implement the Solution: A Deep Dive

Let's dissect the idiomatic Clojure solution provided in the kodikra.com module. This approach leverages metaprogramming to create a clean, data-driven API where each planet has its own dedicated function (e.g., on-earth, on-mars).

Step 1: Defining the Core Constants

First, we define our fundamental constants. We need the number of seconds in an Earth year and the map of planetary orbital factors.

(ns space-age)

(def ^:private seconds-in-year
  "The number of seconds in one Earth year."
  (* 365.25 24 60 60))

(def ^:private factors
  "A map of planets to their orbital period in Earth years."
  {:mercury 0.2408467
   :venus   0.61519726
   :earth   1.0
   :mars    1.8808158
   :jupiter 11.862615
   :saturn  29.447498
   :uranus  84.016846
   :neptune 164.79132})

• (ns space-age): This declares our namespace, which is a way to organize code in Clojure.
• (def ^:private ...): We use def to define top-level "vars" (variables). The ^:private metadata tag makes these vars accessible only within the current namespace, which is good practice for implementation details.
• seconds-in-year: We calculate this value directly rather than hardcoding it. This makes the code's origin clearer: 365.25 days * 24 hours * 60 minutes * 60 seconds.
• factors: This is the heart of our data-driven approach. It's an immutable Clojure map where keys are keywords (e.g., :mercury) and values are the orbital periods.

Step 2: The Metaprogramming Magic with `doseq`

This is where the solution truly shines. Instead of manually writing a function for each planet, we use a loop to generate them dynamically from our factors map.

(doseq [[planet factor] factors]
  (let [fn-name (symbol (str "on-" (name planet)))
        doc-str (str "Calculates age in " (name planet) " years.")]
    (eval
      `(defn ~fn-name
         ~doc-str
         [seconds#]
         (/ (/ seconds# seconds-in-year) ~factor)))))

This block of code is dense, so let's break it down piece by piece.

• (doseq [[planet factor] factors] ...): doseq is a macro used for iterating over a sequence for its side effects. Here, it iterates through our factors map. On each iteration, it destructures the map entry [:mercury 0.2408467] into two local bindings: planet (the keyword) and factor (the number).
• (let [...] ...): let creates local bindings.
  • fn-name (symbol (str "on-" (name planet))): This is the crucial part for creating the function name.
    • (name planet): Converts the keyword :mercury into the string "mercury".
    • (str "on-" ...): Concatenates the strings to form "on-mercury".
    • (symbol ...): Converts the string "on-mercury" into a symbol on-mercury. Symbols are Clojure's identifiers for functions and variables.
  • doc-str (str "..."): We dynamically generate a documentation string for each function.
• (eval `(defn ...)): This is the metaprogramming core.
  • The backtick (`), known as the syntax-quote, tells Clojure to treat the following code block (defn ...) as data (a list of symbols and values) rather than executing it immediately.
  • The tilde (~), known as unquote, is used inside a syntax-quoted form. It tells Clojure to evaluate the specific part and splice its result back into the data structure. We use it on ~fn-name, ~doc-str, and ~factor to inject the values we just calculated.
  • seconds#: The # at the end is a convention to generate a unique symbol name, preventing accidental name clashes.
  • (eval ...): Finally, eval takes the fully formed data structure, like (defn on-mercury "..." [seconds] ...), and evaluates it as actual Clojure code, defining the function in our namespace.

After this doseq block runs, our namespace will contain eight new functions: on-mercury, on-venus, on-earth, and so on, each perfectly tailored to its planet.

ASCII Diagram: Metaprogramming Flow

This diagram illustrates how the `doseq` macro processes the data map to generate executable functions.

    ● Start with `factors` map
    │
    ▼
  ┌─────────────────┐
  │  doseq loop     │
  │ for each planet │
  └────────┬────────┘
           │
           ├─ Iteration 1: [:mercury 0.2408467]
           │   │
           │   ▼
           │ ┌─────────────────────────┐
           │ │ Build code as data:     │
           │ │ `(defn on-mercury ...)` │
           │ └───────────┬─────────────┘
           │             │
           │             ▼
           │          [eval]
           │             │
           │             ▼
           │      Function `on-mercury`
           │      is now defined.
           │
           ├─ Iteration 2: [:venus 0.61519726]
           │   │
           │   ▼
           │  ... (repeat process) ...
           │
           ▼
    ● End: All 8 functions exist

How to Use the Generated Functions

Using the code is now incredibly simple and readable. To run it, you can start a Clojure REPL (Read-Eval-Print Loop).

Assuming your project is set up with Leiningen, you can run:

lein repl

Or with the Clojure CLI tools:

clj

Then, inside the REPL, you can load your file and call the functions:

user=> (require '[space-age :as space])
nil
user=> (space/on-earth 1000000000)
31.68808762412338
user=> (space/on-mercury 1000000000)
131.5684533929944
user=> (space/on-neptune 1000000000)
0.1923488349233283

An Alternative Approach: The Single Function Method

While the metaprogramming solution is clever and very "Clojure-y," it might be considered overly complex for such a simple problem. A more direct, and arguably more practical, approach is to create a single function that takes the planet as an argument.

This alternative design is often easier to reason about, debug, and test, especially for developers new to Clojure's metaprogramming capabilities.

Refactoring for Simplicity

Let's rewrite the logic into a single public function called age-on. The constants remain the same.

(ns space-age-alt)

(def ^:private seconds-in-year (* 365.25 24 60 60))

(def ^:private factors
  {:mercury 0.2408467
   :venus   0.61519726
   :earth   1.0
   :mars    1.8808158
   :jupiter 11.862615
   :saturn  29.447498
   :uranus  84.016846
   :neptune 164.79132})

(defn age-on
  "Calculates age on a specific planet given an age in seconds."
  [planet seconds]
  (if-let [factor (get factors planet)]
    (/ (/ seconds seconds-in-year) factor)
    (throw (IllegalArgumentException. (str "Unknown planet: " planet)))))

Code Walkthrough of the Alternative

• (defn age-on [planet seconds] ...): We define a single function, age-on, that accepts two arguments: planet (which we expect to be a keyword like :earth) and seconds.
• (if-let [factor (get factors planet)] ...): This is a concise way to handle logic that depends on a value being present in a map.
  • (get factors planet) attempts to look up the planet keyword in our factors map.
  • If the key exists, if-let binds its value to the name factor and executes the "then" branch.
  • If the key is not found (get returns nil), it executes the "else" branch.
• "Then" Branch: (/ (/ seconds seconds-in-year) factor) is the same calculation logic as before, using the retrieved factor.
• "Else" Branch: (throw (IllegalArgumentException. ...)) provides robust error handling. If a user passes an invalid planet keyword, the program will fail with a clear error message instead of returning nil or causing a NullPointerException.

ASCII Diagram: Single Function Flow

This diagram shows the simpler, more direct logic of the alternative approach.

    ● Start with inputs:
      (planet, seconds)
    │
    ▼
  ┌──────────────────┐
  │ Call `age-on` fn │
  └─────────┬────────┘
            │
            ▼
    ◆ Lookup `planet`
      in `factors` map?
   ╱                   ╲
 Found (factor)     Not Found (nil)
  │                      │
  ▼                      ▼
┌─────────────────┐  ┌───────────────────┐
│ Calculate age:  │  │ Throw             │
│ age / factor    │  │ IllegalArgument   │
└────────┬────────┘  │ Exception         │
         │           └───────────────────┘
         ▼
    ● Return result

Pros and Cons: Metaprogramming vs. Single Function

Choosing between these two patterns involves trade-offs. Neither is universally "better"; the best choice depends on the context of the larger application.

Frequently Asked Questions (FAQ)

(def ^:private factors
    {:mercury 0.2408467
     ; ... other planets
     :neptune 164.79132
     :pluto   248.59})
  

Conclusion: Thinking in Data and Functions

The Space Age problem, while mathematically simple, serves as a fantastic vehicle for exploring the core philosophy of Clojure. We've seen how a data-driven approach, using a simple map, decouples our logic from our data, making the system instantly extensible.

More importantly, we contrasted two powerful and valid solutions: one leveraging advanced metaprogramming to generate a beautiful, declarative API, and another using a more direct, pragmatic functional approach. Understanding both patterns and their respective trade-offs is a key step in mastering the language. The choice between them depends on your project's specific needs for API design, readability, and complexity.

By completing this exercise from the kodikra.com curriculum, you've not only learned how to calculate your age on Mars but have also gained deeper insight into writing clean, powerful, and idiomatic Clojure code.

Disclaimer: The code in this article is written for clarity and has been tested with Clojure 1.11.x running on a modern JVM (Java 21+). The core concepts are fundamental and stable across Clojure versions.

Ready to tackle the next challenge? Continue your journey on the Clojure learning path and discover more exciting problems. To deepen your overall understanding, explore our comprehensive Clojure guides.

Published by Kodikra — Your trusted Clojure learning resource.