API

An application programming interface (API) is a connection between computers or between computer

programs. It is a type of software interface, offering a service to other pieces of software.[1] A document or
standard that describes how to build or use such a connection or interface is called an API specification. A
computer system that meets this standard is said to implement or expose an API. The term API may refer
either to the specification or to the implementation.

In contrast to a user interface, which connects a computer to a person, an application programming interface
connects computers or pieces of software to each other. It is not intended to be used directly by a person
(the end user) other than a computer programmer who is incorporating it into software. An API is often
made up of different parts which act as tools or services that are available to the programmer. A program or
a programmer that uses one of these parts is said to call that portion of the API. The calls that make up the
API are also known as subroutines, methods, requests, or endpoints. An API specification defines these
calls, meaning that it explains how to use or implement them.

One purpose of APIs is to hide the internal details of how a system works, exposing only those parts a
programmer will find useful and keeping them consistent even if the internal details later change. An API
may be custom-built for a particular pair of systems, or it may be a shared standard allowing interoperability
among many systems.

The term API is often used to refer to web APIs,[2] which allow communication between computers that
are joined by the internet. There are also APIs for programming languages, software libraries, computer
operating systems, and computer hardware. APIs originated in the 1940s, though the term did not emerge
until the 1960s and 70s.

Contents
Purpose
History of the term
1940s and 50s
1960s and 70s
1990s
2000s
Usage
Libraries and frameworks
Operating systems
Remote APIs
Web APIs
Design
Release policies
Public API implications
Documentation
Dispute over copyright protection for APIs
Examples
See also
References
Further reading
External links

Purpose
In building applications, an API (application programming interface) simplifies programming by abstracting
the underlying implementation and only exposing objects or actions the developer needs. While a graphical
interface for an email client might provide a user with a button that performs all the steps for fetching and
highlighting new emails, an API for file input/output might give the developer a function that copies a file
from one location to another without requiring that the developer understand the file system operations
occurring behind the scenes.[3]

History of the term

The term API initially described an interface only for end-user-
facing programs, known as application programs. This origin is
still reflected in the name "application programming interface."
Today, the term is broader, including also utility software and even
hardware interfaces.[5]

1940s and 50s

The idea of the API is much older than the term itself. British
computer scientists Maurice Wilkes and David Wheeler worked on
a modular software library in the 1940s for EDSAC, an early
computer. The subroutines in this library were stored on punched
paper tape organized in a filing cabinet. This cabinet also
contained what Wilkes and Wheeler called a "library catalog" of
notes about each subroutine and how to incorporate it into a
program. Today, such a catalog would be called an API (or an API
specification or API documentation) because it instructs a
programmer on how to use (or "call") each subroutine that the
A diagram from 1978 proposing the
programmer needs.[5]
expansion of the idea of the API to
become a general programming Wilkes and Wheeler's 1951 book The Preparation of Programs for
interface, beyond application
an Electronic Digital Computer contains the first published API
programs alone.[4]
specification. Joshua Bloch considers that Wilkes and Wheeler
"latently invented" the API, because it is more of a concept that is
discovered than invented.[5]

1960s and 70s

The term "application program interface" (without an
-ing suffix) is first recorded in a paper called Data
structures and techniques for remote computer
graphics presented at an AFIPS conference in
1968.[7][5] The authors of this paper use the term to
describe the interaction of an application—a graphics
program in this case—with the rest of the computer
system. A consistent application interface (consisting
of Fortran subroutine calls) was intended to free the
programmer from dealing with idiosyncrasies of the
graphics display device, and to provide hardware
independence if the computer or the display were Although the people who coined the term API were
replaced.[6] implementing software on a Univac 1108, the goal
of their API was to make hardware independent
The term was introduced to the field of databases by programs possible.[6]
C. J. Date[8] in a 1974 paper called The Relational
and Network Approaches: Comparison of the
Application Programming Interface.[9] An API became a part of the ANSI/SPARC framework for
database management systems. This framework treated the application programming interface separately
from other interfaces, such as the query interface. Database professionals in the 1970s observed these
different interfaces could be combined; a sufficiently rich application interface could support the other
interfaces as well.[4]

This observation led to APIs that supported all types of programming, not just application programming.

1990s

By 1990, the API was defined simply as "a set of services available to a programmer for performing certain
tasks" by technologist Carl Malamud.[10]

The idea of the API was expanded again with the dawn of remote procedure calls and web APIs. As
computer networks became common in the 1970s and 80s, programmers wanted to call libraries located not
only on their local computers, but on computers located elsewhere. These remote procedure calls were well
supported by the Java language in particular. In the 1990s, with the spread of the internet, standards like
CORBA, COM, and DCOM competed to become the most common way to expose API services.[11]

2000s

Roy Fielding's dissertation Architectural Styles and the Design of Network-based Software Architectures at
UC Irvine in 2000 outlined Representational state transfer (REST) and described the idea of a "network-
based Application Programming Interface" that Fielding contrasted with traditional "library-based"
APIs.[12] XML and JSON web APIs saw widespread commercial adoption beginning in 2000 and
continuing as of 2021. The web API is now the most common meaning of the term API.[2]

The Semantic Web proposed by Tim Berners-Lee in 2001 included "semantic APIs" that recast the API as
an open, distributed data interface rather than a software behavior interface.[13] Proprietary interfaces and
agents became more widespread than open ones, but the idea of the API as a data interface took hold.
Because web APIs are widely used to exchange data of all kinds online, API has become a broad term
describing much of the communication on the internet.[11] When used in this way, the term API has overlap
in meaning with the term communication protocol.
Usage

Libraries and frameworks

The interface to a software library is one type of API. The API describes and prescribes the "expected
behavior" (a specification) while the library is an "actual implementation" of this set of rules.

A single API can have multiple implementations (or none, being abstract) in the form of different libraries
that share the same programming interface.

The separation of the API from its implementation can allow programs written in one language to use a
library written in another. For example, because Scala and Java compile to compatible bytecode, Scala
developers can take advantage of any Java API.[14]

API use can vary depending on the type of programming language involved. An API for a procedural
language such as Lua could consist primarily of basic routines to execute code, manipulate data or handle
errors while an API for an object-oriented language, such as Java, would provide a specification of classes
and its class methods.[15][16]

Language bindings are also APIs. By mapping the features and capabilities of one language to an interface
implemented in another language, a language binding allows a library or service written in one language to
be used when developing in another language.[17] Tools such as SWIG and F2PY, a Fortran-to-Python
interface generator, facilitate the creation of such interfaces.[18]

An API can also be related to a software framework: a framework can be based on several libraries
implementing several APIs, but unlike the normal use of an API, the access to the behavior built into the
framework is mediated by extending its content with new classes plugged into the framework itself.

Moreover, the overall program flow of control can be out of the control of the caller and in the framework's
hands by inversion of control or a similar mechanism.[19][20]

Operating systems

An API can specify the interface between an application and the operating system.[21] POSIX, for
example, specifies a set of common APIs that aim to enable an application written for a POSIX conformant
operating system to be compiled for another POSIX conformant operating system.

Linux and Berkeley Software Distribution are examples of operating systems that implement the POSIX
APIs.[22]

Microsoft has shown a strong commitment to a backward-compatible API, particularly within its Windows
API (Win32) library, so older applications may run on newer versions of Windows using an executable-
specific setting called "Compatibility Mode".[23]

An API differs from an application binary interface (ABI) in that an API is source code based while an
ABI is binary based. For instance, POSIX provides APIs while the Linux Standard Base provides an
ABI.[24][25]

Remote APIs
Remote APIs allow developers to manipulate remote resources through protocols, specific standards for
communication that allow different technologies to work together, regardless of language or platform. For
example, the Java Database Connectivity API allows developers to query many different types of databases
with the same set of functions, while the Java remote method invocation API uses the Java Remote Method
Protocol to allow invocation of functions that operate remotely, but appear local to the developer.[26][27]

Therefore, remote APIs are useful in maintaining the object abstraction in object-oriented programming; a
method call, executed locally on a proxy object, invokes the corresponding method on the remote object,
using the remoting protocol, and acquires the result to be used locally as a return value.

A modification of the proxy object will also result in a corresponding modification of the remote object.[28]

Web APIs

Web APIs are the defined interfaces through which interactions happen between an enterprise and
applications that use its assets, which also is a service-level agreement (SLA) to specify the functional
provider and expose the service path or URL for its API users. An API approach is an architectural
approach that revolves around providing a program interface to a set of services to different applications
serving different types of consumers.[29]

When used in the context of web development, an API is typically defined as a set of specifications, such
as Hypertext Transfer Protocol (HTTP) request messages, along with a definition of the structure of
response messages, usually in an Extensible Markup Language (XML) or JavaScript Object Notation
(JSON) format. An example might be a shipping company API that can be added to an eCommerce-
focused website to facilitate ordering shipping services and automatically include current shipping rates,
without the site developer having to enter the shipper's rate table into a web database. While "web API"
historically has been virtually synonymous with web service, the recent trend (so-called Web 2.0) has been
moving away from Simple Object Access Protocol (SOAP) based web services and service-oriented
architecture (SOA) towards more direct representational state transfer (REST) style web resources and
resource-oriented architecture (ROA).[30] Part of this trend is related to the Semantic Web movement
toward Resource Description Framework (RDF), a concept to promote web-based ontology engineering
technologies. Web APIs allow the combination of multiple APIs into new applications known as
mashups.[31] In the social media space, web APIs have allowed web communities to facilitate sharing
content and data between communities and applications. In this way, content that is created in one place
dynamically can be posted and updated to multiple locations on the web.[32] For example, Twitter's REST
API allows developers to access core Twitter data and the Search API provides methods for developers to
interact with Twitter Search and trends data.[33]

Design
The design of an API has significant impact on its usage.[3] The principle of information hiding describes
the role of programming interfaces as enabling modular programming by hiding the implementation details
of the modules so that users of modules need not understand the complexities inside the modules.[34] Thus,
the design of an API attempts to provide only the tools a user would expect.[3] The design of programming
interfaces represents an important part of software architecture, the organization of a complex piece of
software.[35]

Release policies
APIs are one of the more common ways technology companies integrate. Those that provide and use APIs
are considered as being members of a business ecosystem.[36]

The main policies for releasing an API are:[37]

Private: The API is for internal company use only.

Partner: Only specific business partners can use the API. For example, vehicle for hire
companies such as Uber and Lyft allow approved third-party developers to directly order
rides from within their apps. This allows the companies to exercise quality control by
curating which apps have access to the API, and provides them with an additional revenue
stream.[38]
Public: The API is available for use by the public. For example, Microsoft makes the
Windows API public, and Apple releases its API Cocoa, so that software can be written for
their platforms. Not all public APIs are generally accessible by everybody. For example,
Internet service providers like Cloudflare or Voxility, use RESTful APIs to allow customers
and resellers access to their infrastructure information, DDoS stats, network performance or
dashboard controls.[39] Access to such APIs is granted either by “API tokens”, or customer
status validations.[40]

Public API implications

An important factor when an API becomes public is its "interface stability". Changes to the API—for
example adding new parameters to a function call—could break compatibility with the clients that depend
on that API.[41]

When parts of a publicly presented API are subject to change and thus not stable, such parts of a particular
API should be documented explicitly as "unstable". For example, in the Google Guava library, the parts
that are considered unstable, and that might change soon, are marked with the Java annotation @Beta.[42]

A public API can sometimes declare parts of itself as deprecated or rescinded. This usually means that part
of the API should be considered a candidate for being removed, or modified in a backward incompatible
way. Therefore, these changes allow developers to transition away from parts of the API that will be
removed or not supported in the future.[43]

Client code may contain innovative or opportunistic usages that were not intended by the API designers. In
other words, for a library with a significant user base, when an element becomes part of the public API, it
may be used in diverse ways.[44] On February 19, 2020, Akamai published their annual “State of the
Internet” report, showcasing the growing trend of cybercriminals targeting public API platforms at financial
services worldwide. From December 2017 through November 2019, Akamai witnessed 85.42 billion
credential violation attacks. About 20%, or 16.55 billion, were against hostnames defined as API endpoints.
Of these, 473.5 million have targeted financial services sector organizations.[45]

Documentation
API documentation describes what services an API offers and how to use those services, aiming to cover
everything a client would need to know for practical purposes.

Documentation is crucial for the development and maintenance of applications using the API.[46] API
documentation is traditionally found in documentation files but can also be found in social media such as
blogs, forums, and Q&A websites.[47]
Traditional documentation files are often presented via a documentation system, such as Javadoc or Pydoc,
that has a consistent appearance and structure. However, the types of content included in the documentation
differs from API to API.[48]

In the interest of clarity, API documentation may include a description of classes and methods in the API as
well as "typical usage scenarios, code snippets, design rationales, performance discussions, and contracts",
but implementation details of the API services themselves are usually omitted.

Restrictions and limitations on how the API can be used are also covered by the documentation. For
instance, documentation for an API function could note that its parameters cannot be null, that the function
itself is not thread safe.[49] Because API documentation tends to be comprehensive, it is a challenge for
writers to keep the documentation updated and for users to read it carefully, potentially yielding bugs.[41]

API documentation can be enriched with metadata information like Java annotations. This metadata can be
used by the compiler, tools, and by the run-time environment to implement custom behaviors or custom
handling.[50]

It is possible to generate API documentation in a data-driven manner. By observing many programs that use
a given API, it is possible to infer the typical usages, as well the required contracts and directives.[51] Then,
templates can be used to generate natural language from the mined data.

Dispute over copyright protection for APIs

In 2010, Oracle Corporation sued Google for having distributed a new implementation of Java embedded
in the Android operating system.[52] Google had not acquired any permission to reproduce the Java API,
although permission had been given to the similar OpenJDK project. Judge William Alsup ruled in the
Oracle v. Google case that APIs cannot be copyrighted in the U.S and that a victory for Oracle would have
widely expanded copyright protection to a "functional set of symbols" and allowed the copyrighting of
simple software commands:

To accept Oracle's claim would be to allow anyone to copyright one version of code to carry
out a system of commands and thereby bar all others from writing its different versions to carry
out all or part of the same commands.[53][54]

Alsup's ruling was overturned in 2014 on appeal to the Court of Appeals for the Federal Circuit, though the
question of whether such use of APIs constitutes fair use was left unresolved. [55][56]

In 2016, following a two-week trial, a jury determined that Google's reimplementation of the Java API
constituted fair use, but Oracle vowed to appeal the decision.[57] Oracle won on its appeal, with the Court
of Appeals for the Federal Circuit ruling that Google's use of the APIs did not qualify for fair use.[58] In
2019, Google appealed to the Supreme Court of the United States over both the copyrightability and fair
use rulings, and the Supreme Court granted review.[59] Due to the COVID-19 pandemic, the oral hearings
in the case were delayed until October 2020.[60]

The case was decided by the Supreme Court in Google's favor.[61]

Examples
ASPI for SCSI device interfacing
Cocoa and Carbon for the Macintosh
 DirectX for Microsoft Windows
EHLLAPI
Java APIs
ODBC for Microsoft Windows
OpenAL cross-platform sound API
OpenCL cross-platform API for general-purpose computing for CPUs & GPUs
OpenGL cross-platform graphics API
OpenMP API that supports multi-platform shared memory multiprocessing programming in
C, C++, and Fortran on many architectures, including Unix and Microsoft Windows
platforms.
Server Application Programming Interface (SAPI)
Simple DirectMedia Layer (SDL)

See also
API testing
API writer
Augmented web
Calling convention
Common Object Request Broker Architecture (CORBA)
Comparison of application virtual machines
Document Object Model (DOM)
Double-chance function
Foreign function interface
Front and back ends
Interface (computing)
Interface control document
List of 3D graphics APIs
Microservices
Name mangling
Open API
Open Service Interface Definitions
Parsing
Plugin
RAML (software)
Software development kit (SDK)
Web API
Web content vendor
XPCOM

References
1. Reddy, Martin (2011). API Design for C++ (https://www.google.com/books/edition/API_Desig
n_for_C++/IY29LylT85wC). Elsevier Science. p. 1. ISBN 9780123850041.
 2. Lane, Kin (October 10, 2019). "Intro to APIs: History of APIs" (https://blog.postman.com/intro-
to-apis-history-of-apis/). Postman. Retrieved September 18, 2020. "When you hear the
acronym “API” or its expanded version “Application Programming Interface,” it is almost
always in reference to our modern approach, in that we use HTTP to provide access to
machine readable data in a JSON or XML format, often simply referred to as “web APIs.”
APIs have been around almost as long as computing, but modern web APIs began taking
shape in the early 2000s."
3. Clarke, Steven (2004). "Measuring API Usability" (http://www.drdobbs.com/windows/measur
ing-api-usability/184405654). Dr. Dobb's. Retrieved 29 July 2016.
4. Database architectures – a feasibility workshop (https://hdl.handle.net/2027/mdp.390150775
87742?urlappend=%3Bseq=53) (Report). Washington, DC: U.S. Department of Commerce,
National Bureau of Standards. April 1981. pp. 45–47. hdl:2027/mdp.39015077587742 (http
s://hdl.handle.net/2027%2Fmdp.39015077587742?urlappend=%3Bseq=53).
LCCN 81600004 (https://lccn.loc.gov/81600004). NBS special publication 500-76. Retrieved
September 18, 2020.
5. Bloch, Joshua (August 8, 2018). A Brief, Opinionated History of the API (https://www.infoq.co
m/presentations/history-api/) (Speech). QCon. San Francisco: InfoQ. Retrieved
September 18, 2020.
6. Cotton, Ira W.; Greatorex, Frank S. (December 1968). "Data structures and techniques for
remote computer graphics" (https://www.computer.org/csdl/pds/api/csdl/proceedings/downlo
ad-article/12OmNyRPgFZ/pdf). AFIPS '68: Proceedings of the December 9–11, 1968, Fall
Joint Computer Conference. AFIPS 1968 Fall Joint Computer Conference. I. San Francisco,
California: Association for Computing Machinery. pp. 533–544.
doi:10.1145/1476589.1476661 (https://doi.org/10.1145%2F1476589.1476661). ISBN 978-
1450378994. OCLC 1175621908 (https://www.worldcat.org/oclc/1175621908).
7. "application program interface" (https://oed.com/search?searchType=dictionary&q=applicati
on+program+interface). Oxford English Dictionary (Online ed.). Oxford University
Press. (Subscription or participating institution membership (https://www.oed.com/public/login/loggingi
n#withyourlibrary) required.)
8. Date, C. J. (2019). E. F. Codd and Relational Theory: A Detailed Review and Analysis of
Codd's Major Database Writings (https://books.google.com/books?id=2Sy4DwAAQBAJ&pg
=PA135). p. 135. ISBN 978-1684705276.
9. Date, C. J.; Codd, E. F. (January 1975). "The relational and network approaches:
Comparison of the application programming interfaces" (https://dl.acm.org/doi/pdf/10.1145/8
00297.811532?casa_token=vfa99FzazH0AAAAA:ass9HpPmh9jFqaWiAKUzRKWFA_is_d
nvb2_S4--nB8ieNC4LpToEhLHLgfjQrTWuImWFOkty2oCX). In Randall Rustin (ed.).
Proceedings of 1974 ACM-SIGMOD Workshop on Data Description, Access and Control.
SIGMOD Workshop 1974. 2. Ann Arbor, Michigan: Association for Computing Machinery.
pp. 83–113. doi:10.1145/800297.811532 (https://doi.org/10.1145%2F800297.811532).
ISBN 978-1450374187. OCLC 1175623233 (https://www.worldcat.org/oclc/1175623233).
10. Carl, Malamud (1990). Analyzing Novell Networks (https://babel.hathitrust.org/cgi/pt?id=md
p.39015018454903&seq=314). Van Nostrand Reinhold. p. 294. ISBN 978-0442003647.
11. Jin, Brenda; Sahni, Saurabh; Shevat, Amir (2018). Designing Web APIs (https://www.googl
e.com/books/edition/Designing_Web_APIs/Dg1rDwAAQBAJ). O'Reilly Media.
ISBN 9781492026877.
12. Fielding, Roy (2000). Architectural Styles and the Design of Network-based Software
Architectures (https://www.ics.uci.edu/~fielding/pubs/dissertation/top.htm) (PhD). Retrieved
September 18, 2020.
13. Dotsika, Fefie (August 2010). "Semantic APIs: Scaling up towards the Semantic Web".
International Journal of Information Management. 30 (4): 335–342.
doi:10.1016/j.ijinfomgt.2009.12.003 (https://doi.org/10.1016%2Fj.ijinfomgt.2009.12.003).
14. Odersky, Martin; Spoon, Lex; Venners, Bill (10 December 2008). "Combining Scala and
Java" (http://www.artima.com/pins1ed/combining-scala-and-java.html). www.artima.com.
Retrieved 29 July 2016.
15. de Figueiredo, Luiz Henrique; Ierusalimschy, Roberto; Filho, Waldemar Celes (1994). "The
design and implementation of a language for extending applications" (https://www.researchg
ate.net/publication/2778436). TeCGraf Grupo de Tecnologia Em Computacao Grafica: 273–
284. CiteSeerX 10.1.1.47.5194 (https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4
7.5194). S2CID 59833827 (https://api.semanticscholar.org/CorpusID:59833827). Retrieved
29 July 2016.
16. Sintes, Tony (13 July 2001). "Just what is the Java API anyway?" (https://www.infoworld.co
m/article/2077392/just-what-is-the-java-api-anyway.html). JavaWorld. Retrieved 2020-07-18.
17. Emery, David. "Standards, APIs, Interfaces and Bindings" (https://web.archive.org/web/2015
0116081559/http://www.acm.org/tsc/apis.html). Acm.org. Archived from the original (http://w
ww.acm.org/tsc/apis.html) on 2015-01-16. Retrieved 2016-08-08.
18. "F2PY.org" (http://www.f2py.org/). F2PY.org. Retrieved 2011-12-18.
19. Fowler, Martin. "Inversion Of Control" (http://martinfowler.com/bliki/InversionOfControl.html).
20. Fayad, Mohamed. "Object-Oriented Application Frameworks" (http://www.dre.vanderbilt.edu/
~schmidt/CACM-frameworks.html).
21. Lewine, Donald A. (1991). POSIX Programmer's Guide (http://shop.oreilly.com/product/9780
937175736.do). O'Reilly & Associates, Inc. p. 1. ISBN 9780937175736. Retrieved 2 August
2016.
22. West, Joel; Dedrick, Jason (2001). "Open source standardization: the rise of Linux in the
network era" (http://www.joelwest.org/Papers/WestDedrick2001b.pdf) (PDF). Knowledge,
Technology & Policy. 14 (2): 88–112. Retrieved 2 August 2016.
23. Microsoft (October 2001). "Support for Windows XP" (https://web.archive.org/web/20090926
235439/http://www.microsoft.com/windowsxp/using/helpandsupport/learnmore/appcompat.m
spx). Microsoft. p. 4. Archived from the original (http://www.microsoft.com/windowsxp/using/h
elpandsupport/learnmore/appcompat.mspx) on 2009-09-26.
24. "LSB Introduction" (http://www.linuxfoundation.org/collaborate/workgroups/lsb/lsb-introductio
n). Linux Foundation. 21 June 2012. Retrieved 2015-03-27.
25. Stoughton, Nick (April 2005). "Update on Standards" (https://db.usenix.org/publications/logi
n/2005-04/openpdfs/standards2004.pdf) (PDF). USENIX. Retrieved 2009-06-04.
26. Bierhoff, Kevin (23 April 2009). "API Protocol Compliance in Object-Oriented Software" (http
s://www.cs.cmu.edu/~kbierhof/thesis/bierhoff-thesis.pdf) (PDF). CMU Institute for Software
Research. Retrieved 29 July 2016.
27. Wilson, M. Jeff (10 November 2000). "Get smart with proxies and RMI" (https://www.infoworl
d.com/article/2076234/get-smart-with-proxies-and-rmi.html). JavaWorld. Retrieved
2020-07-18.
28. Henning, Michi; Vinoski, Steve (1999). Advanced CORBA Programming with C++ (https://ar
chive.org/details/advancedcorbapro00henn). Addison-Wesley. ISBN 978-0201379273.
Retrieved 16 June 2015.
29. "API-fication" (http://www.hcltech.com/sites/default/files/apis_for_dsi.pdf) (PDF download).
www.hcltech.com. August 2014.
30. Benslimane, Djamal; Schahram Dustdar; Amit Sheth (2008). "Services Mashups: The New
Generation of Web Applications" (https://web.archive.org/web/20110928211221/http://dsonli
ne.computer.org/portal/site/dsonline/menuitem.9ed3d9924aeb0dcd82ccc6716bbe36ec/inde
x.jsp?
&pName=dso_level1&path=dsonline%2F2008%2F09&file=w5gei.xml&xsl=article.xsl).
IEEE Internet Computing, vol. 12, no. 5. Institute of Electrical and Electronics Engineers.
pp. 13–15. Archived from the original (http://dsonline.computer.org/portal/site/dsonline/menui
tem.9ed3d9924aeb0dcd82ccc6716bbe36ec/index.jsp?&pName=dso_level1&path=dsonlin
e/2008/09&file=w5gei.xml&xsl=article.xsl) on 2011-09-28. Retrieved 2019-10-01.
31. Niccolai, James (2008-04-23), "So What Is an Enterprise Mashup, Anyway?" (https://www.pc
world.com/article/145039/so_what_is_an_enterprise_mashup_anyway.html), PC World
32. Parr, Ben (21 May 2009). "The Evolution of the Social Media API" (http://mashable.com/200
9/05/21/social-media-api/). Mashable. Retrieved 26 July 2016.
33. "GET trends/place" (https://developer.twitter.com/en/docs/trends/trends-for-location/api-refer
ence/get-trends-place). developer.twitter.com. Retrieved 2020-04-30.
34. Parnas, D.L. (1972). "On the Criteria To Be Used in Decomposing Systems into Modules" (ht
tps://www.win.tue.nl/~wstomv/edu/2ip30/references/criteria_for_modularization.pdf) (PDF).
Communications of the ACM. 15 (12): 1053–1058. doi:10.1145/361598.361623 (https://doi.o
rg/10.1145%2F361598.361623). S2CID 53856438 (https://api.semanticscholar.org/CorpusI
D:53856438).
35. Garlan, David; Shaw, Mary (January 1994). "An Introduction to Software Architecture" (http
s://www.cs.cmu.edu/afs/cs/project/able/ftp/intro_softarch/intro_softarch.pdf) (PDF). Advances
in Software Engineering and Knowledge Engineering. 1. Retrieved 8 August 2016.
36. de Ternay, Guerric (Oct 10, 2015). "Business Ecosystem: Creating an Economic Moat" (htt
p://boostcompanies.com/business-ecosystem). BoostCompanies. Retrieved 2016-02-01.
37. Boyd, Mark (2014-02-21). "Private, Partner or Public: Which API Strategy Is Best for
Business?" (http://www.programmableweb.com/news/private-partner-or-public-which-api-str
ategy-best-business/2014/02/21). ProgrammableWeb. Retrieved 2 August 2016.
38. Weissbrot, Alison (7 July 2016). "Car Service APIs Are Everywhere, But What's In It For
Partner Apps?" (https://www.adexchanger.com/mobile/car-service-apis-everywhere-whats-p
artner-apps/). AdExchanger.
39. "Cloudflare API v4 Documentation" (https://api.cloudflare.com/). cloudflare. 25 February
2020. Retrieved 27 February 2020.
40. Liew, Zell (17 January 2018). "Car Service APIs Are Everywhere, But What's In It For
Partner Apps" (https://www.smashingmagazine.com/2018/01/understanding-using-rest-api/).
Smashing Magazine. Retrieved 27 February 2020.
41. Shi, Lin; Zhong, Hao; Xie, Tao; Li, Mingshu (2011). An Empirical Study on Evolution of API
Documentation (https://www.researchgate.net/publication/225147411). International
Conference on Fundamental Approaches to Software Engineering. Lecture Notes in
Computer Science. 6603. pp. 416–431. doi:10.1007/978-3-642-19811-3_29 (https://doi.org/1
0.1007%2F978-3-642-19811-3_29). ISBN 978-3-642-19810-6. Retrieved 22 July 2016.
42. "guava-libraries – Guava: Google Core Libraries for Java 1.6+ – Google Project Hosting" (htt
ps://code.google.com/p/guava-libraries/). 2014-02-04. Retrieved 2014-02-11.
43. Oracle. "How and When to Deprecate APIs" (http://docs.oracle.com/javase/7/docs/technote
s/guides/javadoc/deprecation/deprecation.html). Java SE Documentation. Retrieved
2 August 2016.
44. Mendez, Diego; Baudry, Benoit; Monperrus, Martin (2013). "Empirical evidence of large-
scale diversity in API usage of object-oriented software" (https://hal.archives-ouvertes.fr/hal-
00844753/document). 2013 IEEE 13th International Working Conference on Source Code
Analysis and Manipulation (SCAM). pp. 43–52. arXiv:1307.4062 (https://arxiv.org/abs/1307.4
062). doi:10.1109/SCAM.2013.6648183 (https://doi.org/10.1109%2FSCAM.2013.6648183).
ISBN 978-1-4673-5739-5. S2CID 6890739 (https://api.semanticscholar.org/CorpusID:68907
39).
45. Takanashi, Dean (19 February 2020). "Akamai: Cybercriminals are attacking APIs at
financial services firms" (https://venturebeat.com/2020/02/19/akamai-cybercriminals-are-atta
cking-apis-at-financial-services-firms/). Venture Beat. Retrieved 27 February 2020.
46. Dekel, Uri; Herbsleb, James D. (May 2009). "Improving API Documentation Usability with
Knowledge Pushing". Institute for Software Research, School of Computer Science.
CiteSeerX 10.1.1.446.4214 (https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.446.
4214).
47. Parnin, Chris; Treude, Cristoph (May 2011). "Measuring API Documentation on the Web" (htt
ps://www.xmedo.com/measuring-api-documentation-web/). Web2SE: 25–30.
doi:10.1145/1984701.1984706 (https://doi.org/10.1145%2F1984701.1984706).
ISBN 9781450305952. S2CID 17751901 (https://api.semanticscholar.org/CorpusID:177519
01). Retrieved 22 July 2016.
48. Maalej, Waleed; Robillard, Martin P. (April 2012). "Patterns of Knowledge in API Reference
Documentation" (https://mobis.informatik.uni-hamburg.de/wp-content/uploads/2013/03/TSE-
2012-04-0081.R2_Maalej.pdf) (PDF). IEEE Transactions on Software Engineering.
Retrieved 22 July 2016.
49. Monperrus, Martin; Eichberg, Michael; Tekes, Elif; Mezini, Mira (3 December 2011). "What
should developers be aware of? An empirical study on the directives of API documentation".
Empirical Software Engineering. 17 (6): 703–737. arXiv:1205.6363 (https://arxiv.org/abs/120
5.6363). doi:10.1007/s10664-011-9186-4 (https://doi.org/10.1007%2Fs10664-011-9186-4).
S2CID 8174618 (https://api.semanticscholar.org/CorpusID:8174618).
50. "Annotations" (https://web.archive.org/web/20110925021948/http://download.oracle.com/jav
ase/1,5.0/docs/guide/language/annotations.html). Sun Microsystems. Archived from the
original (http://download.oracle.com/javase/1,5.0/docs/guide/language/annotations.html) on
2011-09-25. Retrieved 2011-09-30..
51. Bruch, Marcel; Mezini, Mira; Monperrus, Martin (2010). "Mining subclassing directives to
improve framework reuse". 2010 7th IEEE Working Conference on Mining Software
Repositories (MSR 2010). pp. 141–150. CiteSeerX 10.1.1.434.15 (https://citeseerx.ist.psu.ed
u/viewdoc/summary?doi=10.1.1.434.15). doi:10.1109/msr.2010.5463347 (https://doi.org/10.1
109%2Fmsr.2010.5463347). ISBN 978-1-4244-6802-7. S2CID 1026918 (https://api.semanti
cscholar.org/CorpusID:1026918).
52. "Oracle and the End of Programming As We Know It" (http://www.drdobbs.com/jvm/2329012
27). DrDobbs. 2012-05-01. Retrieved 2012-05-09.
53. "APIs Can't be Copyrighted Says Judge in Oracle Case" (http://www.tgdaily.com/business-a
nd-law-features/63756-apis-cant-be-copyrighted-says-judge-in-oracle-case). TGDaily. 2012-
06-01. Retrieved 2012-12-06.
54. "Oracle America, Inc. vs. Google Inc" (https://www.wired.com/wiredenterprise/wp-content/upl
oads/2012/05/Judge-Alsup-Ruling-on-Copyrightability-of-APIs.pdf) (PDF). Wired. 2012-05-
31. Retrieved 2013-09-22.
55. "Oracle Am., Inc. v. Google Inc., No. 13-1021, Fed. Cir. 2014" (https://law.justia.com/cases/fe
deral/appellate-courts/cafc/13-1021/13-1021-2014-05-09.html).
56. Rosenblatt, Seth (May 9, 2014). "Court sides with Oracle over Android in Java patent
appeal" (https://www.cnet.com/news/court-sides-with-oracle-over-android-in-java-patent-app
eal/). CNET. Retrieved 2014-05-10.
57. "Google beats Oracle – Android makes "fair use" of Java APIs" (https://arstechnica.com/tech
-policy/2016/05/google-wins-trial-against-oracle-as-jury-finds-android-is-fair-use/). Ars
Technica. 2016-05-26. Retrieved 2016-07-28.
58. Decker, Susan (March 27, 2018). "Oracle Wins Revival of Billion-Dollar Case Against
Google" (https://www.bloomberg.com/news/articles/2018-03-27/oracle-wins-revival-of-billion
-dollar-case-against-google). Bloomberg Businessweek. Retrieved March 27, 2018.
59. Lee, Timothy (January 25, 2019). "Google asks Supreme Court to overrule disastrous ruling
on API copyrights" (https://arstechnica.com/tech-policy/2019/01/google-asks-supreme-court-
to-overrule-disastrous-ruling-on-api-copyrights/). Ars Technica. Retrieved February 8, 2019.
60. vkimber (2020-09-28). "Google LLC v. Oracle America, Inc" (https://www.law.cornell.edu/sup
ct/cert/18-956). LII / Legal Information Institute. Retrieved 2021-03-06.
61. "Supreme Court of the United States, No. 18–956, GOOGLE LLC, PETITIONER v. ORACLE
AMERICA, INC" (https://www.supremecourt.gov/opinions/20pdf/18-956_d18f.pdf) (PDF).
April 5, 2021.

Further reading
Taina Bucher (16 November 2013). "Objects of Intense Feeling: The Case of the Twitter API"
(http://computationalculture.net/article/objects-of-intense-feeling-the-case-of-the-twitter-api).
Computational Culture (3). ISSN 2047-2390 (https://www.worldcat.org/issn/2047-2390).
Argues that "APIs are far from neutral tools" and form a key part of contemporary
programming, understood as a fundamental part of culture.
What is an API? (https://www.supremecourt.gov/opinions/20pdf/18-956_d18f.pdf) – in the
U.S. Supreme Court opinion, Google v. Oracle 2021, pp. 3–7 – "For each task, there is
computer code; API (also known as Application Program Interface) is the method for calling
that 'computer code' (instruction – like a recipe – rather than cooking instruction, this is
machine instruction) to be carry out"
Maury, Innovation and Change (http://ondrejka.net/history/2014/02/28/maury.html) – Cory
Ondrejka \ February 28, 2014 \ " ...proposed a public API to let computers talk to each other".
(Textise (https://www.textise.net/showText.aspx?strURL=http://ondrejka.net/history/2014/02/2
8/maury.html) URL)

External links
Forrester : IT industry : API Case : Google v. Oracle (https://go.forrester.com/what-it-means/e
p218-google-oracle-api-case/) – May 20, 2021 – content format: Audio with text – length
26:41

Retrieved from "https://en.wikipedia.org/w/index.php?title=API&oldid=1052122990"

This page was last edited on 27 October 2021, at 14:34 (UTC).

Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may apply. By using
this site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia
Foundation, Inc., a non-profit organization.