What is a linter and why your team should use it?
Tags: codereview
Published: 2019-06-21 17:40:19

---
title: What is a linter and why your team should use it?
published: true
tags: Code Review
canonical_url: https://sourcelevel.io/what-is-a-linter-and-why-your-team-should-use-it
---

More and more teams have adopted the usage of linters and other static tools in their development process. Some integrated them in the IDE of their preference, others automated by running them as an additional step in their CI. Also, there are those who run both ways.

## What ‘s a linter, then?

According to Wikipedia, [linter](https://en.wikipedia.org/wiki/Lint_%28software%29)

> is a tool that analyzes source code to flag programming errors, bugs, stylistic errors, and suspicious constructs.

The first linter was written by Stephen C. Johnson in 1978 while working in the Unix operating system at Bell Labs. After that, many other linters have been written for different purposes and languages, not only C.

First linters used to check the source code and find potential optimizations for compilers. But, over the years, many other checks and analysis would be included in the process of _linting:_

The usage of linters has also helped many developers to write better code for not compiled programming languages. As there is not compiling time errors, finding typos, syntax errors, uses of undeclared variables, calls to undefined or deprecated functions, for instance, helping developers to fix it faster and reduce bugs prior to execution.

## Linters have evolved

Linters have evolved. They started with those simple checks, but nowadays they are getting more and more sophisticated. They perform Static Analysis, enforce configuration flags, check for compliance with a given style-guide or security rule, and a lot more.

Let’s explore some of these checks and how they can be useful for you.

### Static Analysis

Static Analysis means that automated software will run through your code source without executing it. It statically checks for potential bugs, memory leaks, and any other check that may be useful.

If you’re a Python developer, you may already know [Radon](https://radon.readthedocs.io/en/latest/). It can count the source lines of code (SLOC), comment lines, a blank line, and other raw metrics, but also, it can calculate a [“Maintainability Index”](https://radon.readthedocs.io/en/latest/intro.html#maintainability-index), which may be very important in some projects.

That’s just an example. There are plenty of other linters that perform Static Analysis checks.

### Code standardizing

![](https://imgs.xkcd.com/comics/third_way.png)

From [https://xkcd.com/1285/](https://xkcd.com/1285/)

Standardizing your code is a great way to move the conversation to a more productive level. Having a guideline and running linters against the codebase will avoid _aesthetical_ changes in your pull request, like replacing all tabs for spaces, indenting a variable assignment or even line breaks after a given number of characters.

Maximizing meaningful changes will take your discussion to topics that really matter, like architectural decisions, security issues, or potential bugs.

By the way, security issues and potential bugs also can be avoided by linters!

### Security Issues

If you’re into Rails, you have probably heard about [Brakeman](https://brakemanscanner.org/). It’s a Static Analysis Security Tool. It’s very handy to find potential security issues. For instance, it runs checks looking for SQL Injections when using ActiveRecord `#find_or_create_by` and friends. It also adds checks for XSS, config options and much more.

Ruby is not the only language with this kind of engine. Ebert supports [more than 40 engines](https://docs.ebertapp.io/engines/) for different languages. Brakeman included.

### Potential bugs

JavaScript has [some tricks](https://javascriptwtf.com/). One of the most famous is the difference between `==` and `===`. It’s a good practice, and it avoids a lot of debugging time, to always use `===`. If you enable, for instance, ESLint to [check for that](https://eslint.org/docs/rules/eqeqeq), it can tell you what part of your code is using `==` and even replace it for you.

### Performance improvements

Every experienced developer knows not only the importance of performing software but a lot of tricks that improve it. The problem is: what about newcomers? How can you pass this knowledge forward? Even senior programmers can miss a technique or two. So, why not let an automation software do it for you?

Did you know that in CSS the [universal selector (\*) may slow down a page loading time?](https://github.com/CSSLint/csslint/wiki/Disallow-universal-selector) Or that [unqualified attribute selectors have the same performance characteristics as the universal selector](https://github.com/CSSLint/csslint/wiki/Disallow-unqualified-attribute-selectors)? Avoiding them is good practice.

Many linters include performance check. They can add different kinds of performance improvements for experienced and newcomers developers. [CSSLint](https://github.com/CSSLint/csslint) is just an example.

### And many other aspects

To infinity and beyond! There are lots and lots of linters for different programming languages, configuration files, and even for software integrations. Any check that matters and can be automated may turn into a linter.

If you work in a very specific scenario you may have to write your own, but that’s not too likely. Checks for HTML Accessibility features, Internalization potential errors, grammar errors, and many others are already there, open-sourced, waiting for you to download, configure and start using.

## Benefits of linting

According to [Ferit T.](https://hackernoon.com/how-linting-and-eslint-improve-code-quality-fa83d2469efe), linting improves readability, removes silly errors before execution and code review. But, as mentioned, linting may do more complex jobs, like detecting code smells or performing static analysis of your codebase.

But, in practice, what are the advantages of linting?

### It improves code review discussion level

If your Pull Request has no typos, nor unused variables, and is compliant with the style guide, the conversation tends to be **focused in the architecture point of view**. That’s it. Pull Request is a great place to point **performance issues** , **securities vulnerabilities** or suggesting **better abstractions.** You don’t need to get in that single or double quotes or tab _vs_ spaces discussion.

This is a productivity gain for sure.

### Makes code look like written by a single person

To the medium and long term having a solid code base that looks like written by the same person is good. Maintainability and evolution are easier because everyone tends to understand what’s written faster and clearer. It prevents bugs, makes the job more joyful for developers and accelerates the time to market of new features.

### Gives visibility of your codebase health

Is your code healthy? You won’t know until you measure it. A good way of doing so is to adding a step in your CI/CD pipeline to measure the evolution of your code health status. Better than that, you can take actions as soon as possible when you see its health to decay. Such actions may imply on creating technical debt cards in your board or even raise the issue during your agile retrospective or architecture committee meeting.

### Spreads awareness and ownership over code quality

Experienced developers can look into a couple of files and tell how easy is a software to change. They probably know where to look: are variables names descriptives? how many lines does a method take? Is there any superclass?

Well, not every employee will have this kind of look over the code. Especially newcomers. Having a linter to tell developers where code smells are is a good way to spread this knowledge and make the team responsible for the changes.

## Conclusion

Linters will help you get more productive and save you time and money. They will drive your team to better decisions (those oriented by data) and share ownership over the quality.

SourceLevel allows you to configure almost 30 different linters to automatically run for each pull request opened by your team. It also provides you a nice dashboard with charts showing the results throughout your product’s lifecycle.

Interested? Check all [supported linters](https://docs.ebertapp.io/engines/) and give it a [try for 14 days](https://ebertapp.io/pricing)!

The post [What is a linter and why your team should use it?](https://sourcelevel.io/what-is-a-linter-and-why-your-team-should-use-it) appeared first on [SourceLevel](https://sourcelevel.io).