Abstraction principle (computer programming): Difference between revisions

Revision as of 08:07, 22 November 2018

Latest revision as of 21:28, 29 October 2023

(12 intermediate revisions by 9 users not shown)

Line 1:

In [[software engineering]] and [[programming language theory]], the '''abstraction principle''' (or the '''principle of abstraction''') is a basic [[dictum]] that aims to reduce duplication of information in a program (usually with emphasis on [[code duplication]]) whenever practical by making use of [[abstraction (computer science)|abstraction]]s provided by the programming language or [[software libraries]] .<ref>{{CitationCite book |last=Mishra |first=Jibitesh |url=https://books.google.com/books?id=YnGz2ghKF-gC&q=%22principle+of+abstraction%22+%22software+engineering%22 |title=Software Engineering needed|date=June2011 2018|publisher=Pearson Education India |isbn=978-81-317-5869-4 |language=en}}.</ref> The principle is sometimes stated as a recommendation to the programmer, but sometimes stated as a requirement of the programming language, assuming it is self-understood why abstractions are desirable to use. The origins of the principle are uncertain; it has been reinvented a number of times, sometimes under a different name, with slight variations.

When read as recommendationrecommendations to the programmer, the abstraction principle can be generalized as the "[[don't repeat yourself]]" (DRY) principle, which recommends avoiding the duplication of information in general, and also avoiding the duplication of human effort involved in the software development process.

== The principle ==

Line 11:

== History and variations ==

Under this very name, theThe abstraction principle appearsis intomentioned ain long list ofseveral books. HereSome weof give a necessarily incomplete listthese, together with the formulation if it is succinct:, are listed below.

* Alfred John Cole, Ronald Morrison (1982) ''An introduction to programming with S-algol'': "[Abstraction] when applied to language design is to define all the semantically meaningful syntactic categories in the language and allow an abstraction over them".<ref>Alfred John Cole, Ronald Morrison, ''An introduction to programming with S-algol'', CUP Archive, 1982, {{ISBN|0-521-25001-3}}, p. 150</ref>

Line 17:

* Jon Pearce (1998) ''Programming and Meta-Programming in Scheme'': "Structure and function should be independent".<ref>Jon Pearce, ''Programming and meta-programming in scheme'', Birkhäuser, 1998, {{ISBN|0-387-98320-1}}, p. 40</ref>

The principle plays a central role in [[Design pattern (computer science)|design patterns]] in [[object-oriented programming]], although most writings on that topic do not give a name to the principle. The [[Design Patterns (book)|influentialDesign Patterns book]] by the Gang of Four]], states: "The focus here is ''[[Encapsulation (object-oriented programming)|encapsulating]] the concept that varies'', a theme of many design patterns." This statement has been rephrased by other authors as "Find what varies and encapsulate it."<ref>Alan Shalloway, James Trott, ''Design patterns explained: a new perspective on object-oriented design'', Addison-Wesley, 2002, {{ISBN|0-201-71594-5}}, p. 115</ref><!-- these guys can't even phrase something this simple coherently; no wonder they have herd of cargo-cult programmers following them -->

In this century, the principle has been reinvented in [[extreme programming]] under the slogan "Once and Only Once". The definition of this principle was rather succinct in its first appearance: "no duplicate code".<ref>Kent Beck, ''Extreme programming explained: embrace change'', 2nd edition, Addison-Wesley, 2000, {{ISBN|0-201-61641-6}}, p. 61</ref> It has later been elaborated as applicable to other issues in software development: "Automate every process that's worth automating. If you find yourself performing a task many times, script it."<ref>Chromatic, ''Extreme programming pocket guide'', O'Reilly, 2003, {{ISBN|0-596-00485-0}}</ref>

Line 24:

The abstraction principle is often stated in the context of some mechanism intended to facilitate abstraction. The basic mechanism of control abstraction is a function or [[subroutine]]. Data abstractions include various forms of [[type polymorphism]]. More elaborate mechanisms that may combine data and control abstractions include: [[abstract data type]]s, including [[Class (computer science)|classes]], [[Polymorphism_(computer_science)#Polytypism|polytypism]] etc. The quest for richer abstractions that allow less duplication in complex scenarios is one of the driving forces in programming language research and design.

Inexperienced programmers may be tempted to introduce too much abstraction in their program&mdash;abstraction that won't be used more than once. {{Citation needed|date=March 2013}} A complementary principle that emphasizeemphasizes this issue is "[[You Ain't Gonna Need It]]" and, more generally, the [[KISS principle]].

Since code is usually subject to revisions, following the abstraction principle may entail [[refactoring]] of code.{{Citation needed|date=August 2022}} The effort of rewriting a piece of code generically needs to be amortized against the estimated future benefits of an abstraction. A rule of thumb governing this was devised by [[Martin Fowler (software engineer)|Martin Fowler]], and popularized as [[Rule of three (programming)|the rule of three]]. It states that if a piece of code is copied more than twice, i.e. it would end up having three or more copies, then it needs to be abstracted out.

== Generalizations ==

"[[Don't repeat yourself]]", or the "DRY principle", is a generalization developed in the context of [[multi-tier architecture]]s, where related code is by necessity duplicated to some extent across tiers, usually in different languages. In practical terms, the recommendation here is to rely on automated tools, like [[Automatic programming|code generatorgenerators]]s and [[data transformation]]s to avoid repetition.{{Citation Needed|date=November 2018}}

== Hardware programming interfaces ==