User Tools

Site Tools


principles:law_of_leaky_abstractions

Law Of Leaky Abstractions

Variants and Alternative Names

Context

Principle Statement

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

A solution is bad if a) the leakiness of abstractions is ignored (bad usage of an abstraction) or b) the benefits of the abstraction cannot justify the disadvantages created by its leakiness (bad abstraction) or c) the abstraction is more leaky as necessary (bad abstraction)

Description

Rationale

Strategies

  • Make the abstraction less leaky. There might be a way to reduce the leakiness of the abstraction.
  • Find a better abstraction. There might be a better abstraction which is less leaky.
  • Remove the abstraction. If the abstraction is so leaky that the leakiness creates more problems than the abstraction solves, it is better not to have it.

Caveats

The law of leaky abstractions by no means says that abstractions are generally a bad thing. Abstractions are extremely helpful and software development without abstractions is virtually impossible. So abstractions are good and developers should strive for creating good abstractions. But abstractions are never perfect and this has to be kept in mind.

See also section contrary principles.

Origin

Evidence

Relations to Other Principles

Generalizations

Specializations

Contrary Principles

Complementary Principles

Principle Collections

Examples

Example 1: String Classes In C++

In C++ string literals such as “test” are of type char* which means pointer to a character. There is some range in the memory where a sequence of characters is stored and there is a pointer pointing to the first character. These strings are unhandy to use so there are string classes in C++ which abstract from these low-level strings which are simply a heritage of the C programming language C++ is built upon. These string classes are much more convenient to use and create the illusion of a built-in string type.

#include <iostream>
 
int main()
{
	std::string s = "Hello";
	s = s + " World";
	std::cout << s << std::endl;
}

In this code it looks like there was a native string type in C++. This is the abstraction. But the abstraction is leaky. The following code does not work:

#include <iostream>
 
int main()
{
	std::string s;
	s = "Hello " + "World";
	std::cout << s << std::endl;
}

So it would be better if C++ had a real native string type.

(this example is taken from 2)

Description Status

Further Reading

Discussion

Discuss this wiki article and the principle on the corresponding talk page.

principles/law_of_leaky_abstractions.txt · Last modified: 2020-12-10 07:44 by 95.216.172.175