Home » How Lengthy Ought to a Class Be — When Clear Code Isn’t Actually Clear | by Matt Chmielewski | Sep, 2023

How Lengthy Ought to a Class Be — When Clear Code Isn’t Actually Clear | by Matt Chmielewski | Sep, 2023

by Icecream
0 comment

How guidelines for clear code can typically undermine its precise high quality

Image generated by Midjourney

Not way back, I used to be searching for a brand new job, meticulously sifting by way of a sea of job adverts, every designed to catch the attention and encourage candidates to ship off their CVs.

In this huge array of guarantees, one posting stood out. It wasn’t simply the same old jargon — it resonated. This firm wasn’t merely trying to find a developer; they needed an actual craftsman. “We worth clear code,” they acknowledged.

For a short second, I used to be genuinely happy.

But, as all the time, there was a catch, slipped into the following paragraph: “Every class we create is capped at 100 strains.”

For the file, my major language is PHP, and the job posting was for a PHP Web Developer place.

The factor with assessing class size is that it’s very tough.

Every programming language has its personal quirks and idiosyncrasies. There are loosely typed and strongly typed languages. Some help multithreading, whereas others are single-threaded. The record goes on.

Then there are the conventions.

It’s been practically a decade since I touched Java, but when I recall appropriately, the same old factor is to position the opening bracket on the finish of a line. In PHP, nevertheless, the conference is to present that bracket its personal line.

Here’s a easy instance:

public class Calculator {
public double add(double number1, double number2) {
return number1 + number2;
class Calculator
public operate add(float $number1, float $number2): float
return $number1 + $number2;

At first look, these snippets are nearly an identical in performance. But, if one adheres to every language’s coding requirements, the PHP model will inherently be longer than its Java counterpart. And this doesn’t even account for extra strains, resembling imports, feedback, and intentional white house — all of which contribute to class size.

Some would possibly say that class size shouldn’t consider these extras; others reckon that if it’s within the file, it’s a part of the tally.

So, what occurs while you tie a developer’s arms with a stringent rule of not more than 100 strains of code per file? Let’s discover the doable outcomes.

Defining a operate in PHP, by customary, requires not less than 4 strains — one for the operate header, two for opening and shutting brackets, and not less than one for a press release within the physique.

If the variety of strains is restricted, the temptation to avoid wasting a couple of by writing overly complicated capabilities could come up.

When you’re constrained by a line rely, you would possibly end up devising some questionable methods to avoid wasting house. My favourite? Overly complicated one-liners.

Here’s a snippet from my integration library. It’s a part of a category accountable for constructing and managing addresses to distant assets:

class Address implements AddressContract, Stringable

* Checks if the gathering accommodates parameters with
* the given names and validates them. This technique
* accepts an arbitrary variety of arguments, every of
* which needs to be a string representing a parameter
* title.
* @param string ...$names The names of the parameters
* to test for.
* @return bool Returns true if all parameters are
* discovered, false in any other case.
public operate hasValid(string ...$names): bool
foreach ($names as $title) {
if (!isset($this->parameters[$name]) || !$this->parameters[$name]->isValid()) {
return false;
return true;


To offer you some context, the Address in my system permits parameters resembling {id} in https://instance.com/articles/{id}. This code particularly checks if an occasion of Address accommodates legitimate parameters.

There’s a considerably explanatory PHPDoc (it’s a piece in progress, by the way in which), and the code is straightforward to comply with. Loop by way of the offered names and test if every exists and is legitimate. If not, then return false. Unless the if assertion asserts true, you’ll get true.

Now, to avoid wasting house, I might write this code as an alternative:

class Address implements AddressContract, Stringable

public operate hasValid(string ...$names): bool
return array_reduce($names, fn($carry, $title) => { return $carry && isset($this->parameters[$name]) && $this->parameters[$name]->isValid(); }, true);


Five strains of code saved.

Obsessing over the size of a category is solely counterproductive.

Instead of channeling their vitality into delivering high-quality functionalities, builders rely strains and devise methods to suit throughout the confines.

While one would possibly argue that this line-counting course of could possibly be automated, it’s a double-edged sword. Automation might inadvertently promote unhealthy practices as builders would possibly try to outwit the system.

Even if the system is designed to implement greatest practices, it’s a cat-and-mouse recreation; builders will repeatedly devise new methods to bypass the principles to avoid wasting time.

Let’s not overlook that such automation should both be triggered by some means or be part of the CI/CD pipeline.

Either method, there can be no instantaneous suggestions on class size, making the software program growth course of for much longer than it needs to be.

A rat king is a group of rats whose tails are intertwined and sure collectively.

Forcing courses to be damaged down can typically lead you to unintentionally craft what I prefer to name a rat king: a tangled mess of tiny courses that may’t dwell with out one another.

This is probably going probably the most prevalent situation and calls for important consideration.

With one complete class, customers must know solely about that class. However, should you fragment that into many smaller, tightly coupled courses, customers should pay attention to all of them.

This is advantageous as a result of each part will be changed. This is legitimate, nevertheless it’s solely helpful if there’s a real requirement for such replacements.

John Ousterhout highlights this when discussing outdated Java I/O dealing with. In essence, to proficiently learn serialized objects from a file, you needed to instantiate three nested objects. Yet, you hardly ever engaged with the primary two instantly.

// You hardly ever work together with these two objects,
// besides when injecting them into the following one.
FileInputStream fileStream = new FileInputStream(fileName);
BufferedInputStream bufferedStream = new BufferedInputStream(fileStream);

// You really work together with this one.
ObjectInputStream objectStream = new ObjectInputStream(bufferedStream);

This drawback usually comes from going overboard with the Single Responsibility Principle. Trying to interrupt an enormous class right into a bunch of smaller ones can create courses that aren’t that helpful.

Setting a strict restrict on class size can push this sort of design much more.

Counting the strains in a category shouldn’t be solely tough to trace exactly, nevertheless it additionally doesn’t essentially replicate the standard of the code.

Surely, a excessive line rely can function a code scent — a touch that perhaps the code wants refactoring. However, choices to refactor based mostly on this alone needs to be made with warning.

Take Laravel’s Model class for example. It spans over 2.4k strains of code, supplemented by a couple of intently associated traits. While this might sound intensive at first look, it’s deliberately designed this fashion. It ensures that builders can lengthen the bottom mannequin class, and voilà, their default mannequin springs to life effortlessly.

When crafting code, the first consideration needs to be its usability, not size. Be positive to take advantage of frequent use instances as easy as doable.

You may also like

Leave a Comment