Grundlagen von Leiningen und Deps.edn

In Clojure, build tools are essential for automating tasks like managing dependencies, compiling code, running tests, and packaging your application. They simplify project setup and ensure consistency.

Without them, you'd manually download libraries, set up classpaths, and invoke the JVM, which quickly becomes cumbersome for any non-trivial project.

Leiningen is a popular and mature build automation tool for Clojure projects. It's inspired by Maven and handles everything from creating new projects to deploying them.

Its primary configuration file is project.clj, a Clojure data structure itself, making it very flexible.

You can create a new Leiningen application project using the lein new command. This command quickly generates a standard directory structure with boilerplate code.

Run this command in your terminal:

The project.clj file defines your project's metadata and configuration. Key elements include:

• :dependencies: A list of external libraries your project needs.
• :main: Specifies the main entry point for your application.
• :version: Your project's current version.

It's written in Clojure syntax, allowing for powerful, dynamic configurations.

After creating your project, Leiningen provides an easy way to run your application. The lein run command executes the main function specified in project.clj.

Here's the default core.clj content that lein new app generates. Try running it!

deps.edn is Clojure's official and more lightweight dependency management and build tool, introduced with Clojure 1.9. It focuses solely on managing dependencies and classpaths.

It uses EDN (Extensible Data Notation), a subset of Clojure, for its configuration, making it very readable and easy to parse.

Unlike Leiningen, deps.edn doesn't have a new command to scaffold projects. You typically create the necessary files and directories manually.

A minimal project requires a deps.edn file in your project root and a source directory (e.g., src) for your code.

The deps.edn file defines your project's dependencies and source paths. Key elements include:

• :paths: A vector of directories where your source code is located.
• :deps: A map of external libraries and their versions, typically using Maven coordinates.

It's simpler than project.clj, focusing on classpath construction.

To run a deps.edn project, you use the clj command (the Clojure CLI tool). You specify the main namespace using -m.

Here's a simple core.clj file that can be run with clj -m my-deps-app.core. Try it out!

Both Leiningen and deps.edn are excellent tools, but they serve slightly different philosophies:

• Leiningen: An all-in-one project manager with extensive plugin support for various tasks (testing, deployment, etc.).
• deps.edn: A simpler, more focused tool for dependency and classpath management, often used with other CLI tools for specific tasks.

Many modern Clojure projects use deps.edn for its simplicity and directness, sometimes alongside Leiningen.

We've explored the fundamentals of Clojure's two primary build tools:

• Leiningen: A full-featured tool using project.clj for configuration, offering project creation and task automation.
• deps.edn: A lightweight, official tool using deps.edn for classpath and dependency management, typically used with the clj CLI.

Both are crucial for managing Clojure projects efficiently, allowing you to choose based on your project's needs.