Basic abstraction techniques: What code reviewers need to know

While having a large amount of code doesn't necessarily mean the code is complex, there certainly is such a thing as too much code in the wrong place. Progamming code can also be unnecessarily complex and hard to follow. As a matter of fact, these two problems often occur together, and it's something you need to be on the lookout for as a code reviewer.

What's usually lacking in those parts of code where you find yourself on the verge of throwing in the towel because you just can't understand what is going on is what we call abstraction. When sections of code get too cumbersome and hard to follow, that's when you need to employ an abstraction technique. Let's look at how to spot overly complex code and then simplify it.

The power of abstraction

Two of the main paradigms of computer programming are imperative and declarative. To put it simply, imperative programming means telling the compiler how to do things, line by line. Declarative programming, on the other hand, abstracts away the details of how things are done, in favor of a high-level description of what needs to be done.

The reason declarative programming is deemed by many to be a superior way to write code is that it's often a lot easier to read someone else's declarative code than something written imperatively. When you read and work on declarative code, you don't need to bother with implementation details. You can, instead, focus on the general business logic and only look at the specific implementation of something if you need to.

Too much code?

For code to be easier to read and understand, its business logic should be as obvious as possible. And for that to happen, there needs to be as few "implementation details" floating around as possible.

As an example, look at the following procedural/imperative piece of code:

let userId = "2"
let address = "20 Gortnatra St., Kerrykeel, County Donegal, Ireland"
let supergeocoder = new SuperGeocoder()
let geocoder = supergeocoder({provider: "google-maps"})
let geocoderResult = geocoder.geocode(address)
let gpsCoords = geocoderResult.latitude + ',' + geocoderResult.longitude
let mysql = new MySql();
let connection = mysql.createConnection({
  host : 'localhost',
  user : 'me',
  password : 'secret',
  database : 'my_db'
});
connection.connect();
connection.query('UPDATE users SET address = ?, gps = ? WHERE id = ?', [address, gpsCoords, userId], function (error, results, fields) {
  if (error) throw error;
  // ...
});
connection.end();

It wouldn't be surprising if it took even an experienced developer several moments to understand what that piece of code is trying to achieve. This is how we could attempt to make it declarative:

let userId = "2"
let address = "20 Gortnatra St., County Donegal, Ireland"
let User = new User(userId)
let Geolocation = new Geolocation()
User.saveAddressCoordinates( Geolocation.coordinatesFromAddress(address) )

The main thing that we've done here is remove all the implementation details, such as the database and the geolocation library. We've also gotten rid of some database-specific language, such as the SQL query and the database connection data.

Now anyone can read that segment of code and have a pretty clear idea of what its business logic is. The code is clearly trying to save the user's GPS coordinates by calculating them from a real address.

When reviewing someone else's code, look for places where implementation details are hindering a clear understanding of the business logic. Suggest practical ways to abstract away the what, leaving only the how exposed. The easiest way to do that is typically by replacing that piece of implementation code with a small function or object, as shown in the above example.

Decompose conditional

Another place where you can find too much code in the wrong place is within if conditions. When reading an if condition it should, again, be immediately obvious to any reader what that condition is trying to accomplish.

Look at the following segment of code:

if (
    (
        Person.age > 65
        && Person.gender == Person.GENDER_FEMALE
        || Person.age > 67
        && Person.gender == Person.GENDER_MALE
    ) &&
    Job.employeeDetails(Person).employedSince >= 1980
) {
    // some code here
}

This huge condition should be replaced by a simple function such as this:

if (isEligibleForRetirement(Person, Job)) {
    // some code here
}

isEligibleForRetirement simply contains all of the conditions we’ve just looked at, but it's much easier to read, understand, and test. This technique is called decompose conditional.

Once again, what you're looking for here is a way to understand the business logic clearly and as early as possible while in the process of reading the code.

In the first condition, even after reading it all, you probably still wouldn't know what that if is trying to do, which is to scan through people who are eligible for retirement. A comment might have been necessary for you to fully understand it.

In the second condition, it's immediately clear what the business logic is. Unless you care about the specific requirements for a person to be eligible for retirement, you can happily keep reading the rest of the code.

Consolidate conditional expression

Something else to be on the lookout for is when a number of conditions return the same result.

Here’s what it would look like:

Keep learning

• Take a deep dive into the state of quality with TechBeacon's Guide. Plus: Download the free World Quality Report 2022-23.

• Put performance engineering into practice with these top 10 performance engineering techniques that work.

• Find to tools you need with TechBeacon's Buyer's Guide for Selecting Software Test Automation Tools.

• Discover best practices for reducing software defects with TechBeacon's Guide. 

• Take your testing career to the next level. TechBeacon's Careers Topic Center provides expert advice to prepare you for your next move.