Top 7 Clojure Static Code Analysis Tools

Looking to improve your Clojure code quality? Here's a quick rundown of the 7 best static analysis tools:

1. Eastwood: Thorough linter, finds hard-to-spot issues
2. Kibit: Suggests simpler code patterns
3. clj-kondo: Fast, works with editors, catches common errors
4. lein-bikeshed: Checks code formatting and style
5. lein-check-namespace-decls: Ensures clean namespace declarations
6. lein-docstring-checker: Verifies public vars have docstrings
7. yagni: Detects unused code

Quick Comparison:

All tools are free and work with JVM Clojure projects. Use them in your CI pipeline to catch issues early and maintain code quality.

Related video from YouTube

How We Chose These Tools

We picked the top 7 Clojure static code analysis tools based on four main factors:

1. What they can do
2. How easy they are to use
3. How much support they have
4. How they work

Here's a breakdown of what we looked at:

We chose tools that do a good job in these areas. We wanted to make sure they're helpful for both new and experienced Clojure developers.

We also looked at specific features like:

• Managing namespaces
• Checking for old dependencies
• Looking at line length and method complexity

1. Eastwood

Eastwood is a Clojure linter that checks code for issues and problems. It's named after the actor and is known for its thorough checks.

Main Features

Eastwood uses two Clojure projects: tools.analyzer and tools.analyzer.jvm. It looks at your code in the JVM and finds issues like:

• Vars that are defined more than once
• Docstrings in the wrong place
• Return values that aren't used
• Odd expressions
• Tests that always give the same result

How to Install and Set Up

To use Eastwood in your Leiningen project:

1. Add the Eastwood plugin to your project.clj file
2. Run the command lein eastwood

Here's an example of how to add Eastwood to your project.clj:

(defproject myproject "0.0.1"
  :description "Eastwood Sample Project"
  :license "Eclipse Public License 1.0"
  :url "http://www.bradcypert.com"
  :dependencies [[org.clojure/clojure "1.8.0"]]
  :plugins [[lein-tar "3.2.0"]
            [jonase/eastwood "0.2.4"]])

What It Does Well

Possible Drawbacks

Despite these small issues, Eastwood is still very helpful for Clojure developers.

2. Kibit

Kibit is a tool that checks Clojure code and suggests ways to make it better.

Main Features

Kibit looks for code patterns that could be written in a simpler way. It can suggest:

• Using when instead of if
• Easier ways to check for nil
• Simpler ways to write expressions

How to Install and Set Up

To use Kibit in your Leiningen project:

1. Add this to your project.clj file:

(defproject myproject "0.0.1"
  :description "Kibit Sample Project"
  :license "Eclipse Public License 1.0"
  :url "http://www.bradcypert.com"
  :dependencies [[org.clojure/clojure "1.8.0"]]
  :plugins [[lein-tar "3.2.0"]
            [jonase/kibit "0.1.5"]])

2. Run lein kibit to check your project
3. To check a single file, use lein kibit path/to/some/file.clj

What It Does Well

Possible Drawbacks

Despite these small issues, Kibit is a helpful tool for Clojure developers.

3. clj-kondo

Main Features

clj-kondo is a tool that checks Clojure code for errors and style issues. It can:

• Find mistakes in code structure
• Spot unused parts of code
• Suggest better ways to write code
• Work with common Clojure add-ons

How to Install and Set Up

You can add clj-kondo to your project in two ways:

1. Use a script (for Linux and MacOS)
2. Use ASDF plugin

Both methods are quick and easy to use.

What It Does Well

Possible Drawbacks

Even with these small issues, clj-kondo is a useful tool for Clojure coders. It helps them write better, easier-to-maintain code.

4. lein-bikeshed

Main Features

lein-bikeshed is a Leiningen plugin that checks Clojure code quality. It looks at:

• Line length
• Trailing whitespace
• Blank lines at file ends
• Redefined var roots
• Missing docstrings
• Argument names that clash with clojure.core functions

How to Install and Set Up

To use lein-bikeshed:

1. Add this to your ~/.lein/profiles.clj file:

{:user {:plugins [[lein-bikeshed "0.5.2"]]}}

2. Run lein bikeshed in your project folder.

What It Does Well

Possible Drawbacks

lein-bikeshed helps keep your Clojure code clean and consistent. It's a simple tool that can catch common formatting problems, but it may not find all code quality issues.

sbb-itb-bfaad5b

5. lein-check-namespace-decls

Main Features

lein-check-namespace-decls is a tool that checks namespace declarations in Clojure code. It looks for:

• Proper sorting of declarations
• Use of :require instead of :use
• Removal of unused namespaces

This tool helps keep code organized and easy to read.

How to Install and Set Up

To use lein-check-namespace-decls:

1. Add this to your project.clj file:

:plugins [[lein-check-namespace-decls "0.2.0"]]

2. Run lein check-namespace-decls in your project folder.

What It Does Well

Possible Drawbacks

lein-check-namespace-decls is a useful tool for keeping Clojure code organized. While it focuses only on namespace declarations, it can help make code easier to read and maintain.

6. lein-docstring-checker

lein-docstring-checker is a tool that checks if your Clojure code has good comments. It helps keep your code easy to understand.

Main Features

This tool looks for comments called docstrings on public vars. These comments explain what your code does. Having good comments makes it easier for others to use and fix your code.

How to Install and Set Up

To use lein-docstring-checker in your Leiningen project:

1. Add this to your project.clj file:

:plugins [[lein-docstring-checker "0.2.0"]]

2. Run lein docstring-checker in your project folder.

What It Does Well

Possible Issues

lein-docstring-checker is a simple tool that helps you write better comments in your Clojure code. While it only looks at one part of your code, it can make your project easier for others to use and understand.

7. yagni

yagni is a tool that finds unused code in Clojure projects. It helps keep code clean by spotting functions and variables that aren't being used.

Main Features

yagni looks for:

• Unused functions
• Unused variables
• Code that never runs

This tool is helpful for big projects where unused code can build up over time.

How to Install and Set Up

To use yagni in your Clojure project:

1. Add this to your project.clj file:

:dependencies [[yagni "0.1.0"]]

2. Run lein yagni in your project folder to check your code.

What It Does Well

Possible Problems

Some issues with yagni:

Even with these small issues, yagni is a good tool for finding unused code and making Clojure projects better.

Tool Comparison Table

When picking a tool to check your Clojure code, it's good to know what each one does, where it works, and if it costs money. Here's a simple table that shows this information for the 7 tools we talked about:

This table gives you a quick look at what each tool can do. It can help you choose the right one for your Clojure project.

Using These Tools in Your Workflow

Adding these tools to your daily work can help you write better Clojure code. One good way to do this is by using them in your Continuous Integration (CI) pipeline.

CI pipelines help check your code automatically. They can find problems early, which saves time later. Here's how you can set up a CI pipeline for your Clojure project:

1. Use Github Packages for storing your code parts
2. Use tools.build to put your project together

Here's a step-by-step guide:

1. Make a settings.xml file in your ~/.m2 folder. Put this in it:

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 https://maven.apache.org/xsd/settings-1.0.0.xsd">
  <servers>
    <server>
      <id>github</id>
      <username>GITHUB_USERNAME_HERE</username>
      <password>PERSONAL_ACCESS_TOKEN_HERE</password>
    </server>
  </servers>
</settings>

2. Set up your CI pipeline to use the code checking tools. For example, you could use Eastwood to look for problems.

3. After checking, the CI pipeline can put your code parts in Github Packages.

Using these tools in your CI pipeline helps keep your code clean. It also helps developers write better code because they get quick feedback.

Here's a table showing how these tools can fit into your work:

What Developers Say

Clojure developers want better tools to keep their code clean and easy to read. Here's what they're saying:

Needs and Challenges

Popular Tools and Practices

Developers like:

• Live linting with clj-kondo
• Editors that follow the Clojure Style guide

These tools help catch errors early and make code look neat.

Room for Improvement

Key Takeaways

1. Good tools help write better code
2. Developers want tools that work well with Clojure
3. There's still work to do to make Clojure tools better

Wrap-up

We've looked at 7 tools that help check Clojure code. Each tool has its own good points:

When picking a tool, think about what your project needs and what your team likes. Using these tools can help you:

• Find mistakes early
• Make code easier to read
• Save time when writing code

Related posts

• 6 Best Elixir Static Analysis Tools 2024
• Audit Your Codebase: Best Practices
• Best Online Learning Sites for Programming
• Software Craftsmanship: Principles vs. Tools