Meaning of Leaky Abstraction?

What is abstraction?

• Abstraction is a way of simplifying the world.
• It means you don't have to worry about what is actually happening under the hood.

Example: Flying a 737/747 is "abstracted" away

• Planes are complicated systems: it involves: jet engines, oxygen systems, electrical systems, landing gear systems etc.
• ...but the pilot doesn't have to worry about it... all of that is "abstracted away". The only thing a pilot needs to focus on is yoke (i.e. steering wheel of the plane).
• He pushes the yoke left to go left, and right to go right etc.

....that is in an ideal world. In reality, flying a plane is much more complicated. Because many details ARE NOT "abstracted away".

Leaky Abstractions in 737 Example

Pilots in reality have to worry about a LOT of things: wind speed, thrust, angles of attack, fuel, altitude, weather problems, angles of descent. Computers can help the pilot in these tasks, but not everything is automated / simplified......not everything is "abstracted away".

e.g. If the pilot pulls up too hard on the column - the plane will obey, but then the plane might stall, and that's really bad.

In other words, it is not enough for the pilot to simply control the steering wheel without knowing anything else.........nooooo.......the pilot must know about the underlying risks and limitations of the plane before the pilot flies one.......the pilot must know how the plane works, and how the plane flies; the pilot must know implementation details..... that pulling up too hard will lead to a stall, or that landing too steeply will destroy the plane etc.

Those things are not abstracted away. A lot of things are abstracted, but not everything. The abstraction is "leaky".

Leaky Abstractions in Code

......it's the same thing in your code. If you don't know the underlying implementation details, then you're gonna have problems.

ORMs abstract a lot of the hassle in dealing with database queries, but if you've ever done something like:

User.all.each do |user|
   puts user.name # let's print each user's name
end

Then you will realise that's a nice way to kill your app. You need to know that calling User.allwith 25 million users is going to spike your memory usage, and is going to cause problems. You need to know some underlying details. The abstraction is leaky.

The fact that at some point, which will guided by your scale and execution, you will be needed to get familiar with the implementation details of your abstraction framework in order to understand why it behave that way it behave.

For example, consider this SQL query:

SELECT id, first_name, last_name, age, subject FROM student_details;

And its alternative:

SELECT * FROM student_details;

Now, they do look like a logically equivalent solutions, but the performance of the first one is better due the individual column names specification.

It's a trivial example but eventually it comes back to Joel Spolsky quote:

All non-trivial abstractions, to some degree, are leaky.

At some point, when you will reach a certain scale in your operation, you will want to optimize the way your DB (SQL) works. To do it, you will need to know the way relational databases works. It was abstracted to you in the beginning, but it's leaky. You need to learn it at some point.

Leaky abstraction is all about encapsulating state. very simple example of leaky abstraction:

$currentTime = new DateTime();

$bankAccount1->setLastRefresh($currentTime);
$bankAccount2->setLastRefresh($currentTime);
$currentTime->setTimestamp($aTimestamp);

class BankAccount {
    // ...

    public function setLastRefresh(DateTimeImmutable $lastRefresh)
    {
        $this->lastRefresh = $lastRefresh;
    } }

and the right way(not leaky abstraction):

class BankAccount
{
    // ...

    public function setLastRefresh(DateTime $lastRefresh)
    {
        $this->lastRefresh = clone $lastRefresh;
    }
}

more description here.