Abstraction
- In Turkish
- Soyutlama
- Pronunciation
- ab-STRAK-shun
In short
Abstraction is hiding the complicated details of how something works behind a simpler interface, so code can use it by knowing only what it does.
What is abstraction in programming?
Every layer of software is an abstraction over the one below. A function sendEmail(to, subject) hides SMTP connections and retries; a file system hides disk sectors; a programming language hides machine instructions. Callers work with the simple idea and rely on it behaving as promised, which lets people build large systems without holding every detail in their heads.
In object-oriented programming, abstraction is one of the four classic principles, alongside encapsulation, inheritance and polymorphism. Interfaces and abstract classes describe what a type can do without saying how: a PaymentProvider interface with a charge() method can be implemented by a card processor or a test fake, and the rest of the code doesn't need to know which one it got.
Good abstractions have clear names, small surfaces and few surprises. Bad ones either hide too little, forcing callers to know the details anyway, or hide too much, making it impossible to handle an important case. Removing duplication too early often creates the second kind, a wrong abstraction that is harder to change than the repeated code was.
A common misconception is that abstraction and encapsulation are the same. Abstraction is about the design, exposing only the essential idea; encapsulation is the mechanism of keeping internal state private. Also, every abstraction leaks sometimes: a network call hidden behind a simple function can still be slow or fail, as Joel Spolsky's 2002 law of leaky abstractions describes.
Key takeaways
- Abstraction hides how something works behind what it does.
- Software is built from layers of abstraction, from hardware up.
- Interfaces and abstract classes are the main OOP tools for it.
- Good abstractions are small and predictable; wrong ones are costly.
- Abstractions leak: hidden details such as slowness can still show through.
Example
interface PaymentProvider {
charge(amountCents: number, customerId: string): Promise<string>;
}
class CardProcessor implements PaymentProvider {
async charge(amountCents: number, customerId: string) {
// HTTP calls, retries and error codes live here, hidden from callers
return "txn_123";
}
}
// Checkout depends on the abstraction, not on the details
async function checkout(provider: PaymentProvider, total: number, customer: string) {
const transactionId = await provider.charge(total, customer);
return { ok: true, transactionId };
}Readers ask
What is the difference between abstraction and encapsulation?
Abstraction decides what to show: a simple interface that captures the essential idea. Encapsulation is how the rest is kept hidden: private fields and methods that outside code can't touch.
What is an abstract class?
A class that can't be instantiated directly and may leave some methods unimplemented. Subclasses fill in the details. Unlike an interface, it can also contain shared code and fields.
What is a leaky abstraction?
An abstraction whose hidden details still affect the people using it. For example, an ORM hides SQL, but slow queries still force developers to understand the SQL it generates.
See also
- EncapsulationProgramming Fundamentals, p. 17Encapsulation is the practice of bundling data with the methods that use it and hiding internal details, so outside code works only through a public interface.
- InterfaceProgramming Fundamentals, p. 29An interface is a named set of method and property signatures that a type promises to provide, without saying how those members are implemented.
- PolymorphismProgramming Fundamentals, p. 45Polymorphism is the ability of code to work with values of different types through one shared interface, with each type supplying its own behavior.
- InheritanceProgramming Fundamentals, p. 28Inheritance is an object-oriented programming feature that lets a new class reuse, extend, and override the fields and methods of an existing class.
- OOPProgramming Fundamentals, p. 40OOP, or object-oriented programming, is a way of structuring code around objects that bundle related data together with the functions that act on that data.
- Separation of ConcernsSoftware Architecture, p. 37Separation of concerns is a design principle that divides a program into distinct parts, each responsible for one clearly defined aspect of its behavior.
Spotted a mistake or something missing on this page?Suggest an edit