Origin of the term

Although devices combining telephony and computing were conceptualized as early as 1973 and were offered for sale beginning in 1994, the term "smartphone" did not appear until 1997, when Ericsson described its GS 88 "Penelope" concept as a "Smart Phone".[4][5][6][7][8] The distinction between smartphones and feature phones can be vague, and there is no official definition for what constitutes the difference between them. One of the most significant differences is that the advanced application programming interfaces (APIs) on smartphones for running third-party applications[9] can allow those applications to have better integration with the phone's OS and hardware than is typical with feature phones. In comparison, feature phones more commonly run on proprietary firmware, with third-party software support through platforms such as Java ME or BREW.[1] An additional complication in distinguishing between smartphones and feature phones is that over time the capabilities of new models of feature phones can increase to exceed those of phones that had been promoted as smartphones in the past. Some manufacturers use the term "superphone" for their high end phones with unusually large screens and other expensive features.[10][11] Other commentators prefer "phablet" in recognition of their convergence with low-end tablet computers. An application programming interface (API) is a protocol intended to be used as an interface by software components to communicate with each other. An API may include specifications for routines, data structures, object classes, and variables. An API specification can take many forms, including an International Standard such as POSIX, vendor documentation such as the Microsoft Windows API, the libraries of a programming language, e.g. Standard Template Library in C++ or Java API. An API differs from an application binary interface (ABI) in that an API is source code based while an ABI is a binary interface. For instance POSIX is an API, while the Linux Standard Base is an ABI. In object-oriented languages, an API usually includes a description of a set of class definitions, with a set of behaviors associated with tho

e classes. This abstract concept is associated with the real functionality exposed, or made available, by the classes that are implemented in terms of class methods (or more generally by all its public components hence all public methods, but also possibly including any internal entity made public, like fields, constants, nested objects, enums, etc.). The API in this case can be conceived as the totality of all the methods publicly exposed by the classes (usually called the class interface). This means that the API prescribes the methods by which one interacts with/handles the objects derived from the class definitions. More generally, one can see the API as the collection of all the kinds of objects one can derive from the class definitions, and their associated possible behaviors. Again: the use is mediated by the public methods, but in this interpretation, the methods are seen as a technical detail of how the behavior is implemented. For instance: a class representing a Stack can simply expose publicly two methods push() (to add a new item to the stack), and pop() (to extract the last item, ideally placed on top of the stack). In this case the API can be interpreted as the two methods pop() and push(), or, more generally, as the idea that one can use an item of type Stack that implements the behavior of a stack: a pile exposing its top to add/remove elements. The second interpretation appears more appropriate in the spirit of object orientation. This concept can be carried to the point where a class interface in an API has no methods at all, but only behaviors associated with it. For instance, the Java language and Lisp (programming language) API include the interface Serializable, which is a marker interface that requires that each class that implements it should behave in a serialized fashion. This does not require to have any public method, but rather requires that any class that implements it to have a representation that can be saved (serialized) at any time (this is typically true for any class containing simple data and no link to external resources, like an open connection to a file, a remote system, or an external device).