Pitfalls of static code analysis: class, function, or method length rules

Kirill Artamonov — Mon, 23 Nov 2020 13:50:54 +0000

Lack of code quality is a re-occurring problem in many software projects, teams, and organizations. Static code analysis with a set of simple rules seems like a good solution to the problem.

There are some pitfalls of static code analysis, and I wanted to share my thoughts about one of the rules: class, function, or method length restrictions.

The rule

Whenever there's a lengthy fragment of code, there's a problem with it. Most certainly it violates the single-responsibility principle, it is hard to understand and troublesome to update.

A rule that enforces a hard limit of X lines per code block is a seemingly simple and effective solution. However, it introduces behavior that I would call mechanical refactoring.

Mechanical vs. insightful

Mechanical refactorings are happening when something external is enforcing it: e.g., when a certain number of lines is reached and the commit or merge is blocked. They are happening not when talking to domain experts, or when there are new insights arising from working with the code, or when new abstractions are being discovered. To contrast the two types of refactoring, I'd call the latter insightful refactorings.

Mechanical refactorings require the answer here and now, insightful ones can grow and ripen in people's heads for days or even weeks. The quality of a mechanical refactoring is thus often less than of an insightful one. A quick low-quality mechanical refactoring today might also obstruct the view or make an insightful refactoring harder next time.

What to do?

If you think there's a problem with the software quality of your product, I'd advise focusing on the people, not on the tools like ones for static code analysis.

Get your team members excited about clean code, give them time and space to think about the code and the domain, give them time and space to practice writing cleaner code, to experiment with it.

That's it, happy coding!

Regex: finding repetitions

Kirill Artamonov — Mon, 23 Nov 2020 13:09:00 +0000

Finding repeating characters in a string - whether it's a Run-length encoding exercise on exercism.io, a task during a technical interview, or even a production feature like validating created users passwords - is easily implemented using a simple regular expression.

The regex feature that we'll need is called "backreference". While the examples below are in JavaScript, this feature is defined as part of the POSIX standard, so it supported in various other languages.

Let's get started:

const repetitions = input => input.match(/(.)\1+/g)

Let's test it out:

console.log(repetitions('bookkeeper')) 
// expected output: Array ["oo", "kk", "ee"]
console.log(repetitions('длинношеее'))
// expected output: Array ["нн", "еее"]

That's it. Happy coding and regexing!

DEV Community: Kirill Artamonov

Pitfalls of static code analysis: class, function, or method length rules

The rule

Mechanical vs. insightful

What to do?

Regex: finding repetitions