Editing Programming language (section)

===Type system===
{{Main|Data type|Type system|Type safety}}

A [[data type]] is a set of allowable values and operations that can be performed on these values.{{sfn|Sebesta|2012|p=244}} Each programming language's [[type system]] defines which data types exist, the type of an [[Expression (mathematics)|expression]], and how [[type equivalence]] and [[type compatibility]] function in the language.{{sfn|Sebesta|2012|p=245}}

According to [[type theory]], a language is fully typed if the specification of every operation defines types of data to which the operation is applicable.<ref name="typing">{{cite web|url=http://www.acooke.org/comp-lang.html|author=Andrew Cooke|title=Introduction To Computer Languages|access-date=13 July 2012|url-status=live|archive-url=https://web.archive.org/web/20120815140215/http://www.acooke.org/comp-lang.html|archive-date=15 August 2012}}</ref> In contrast, an untyped language, such as most [[assembly language]]s, allows any operation to be performed on any data, generally sequences of bits of various lengths.<ref name="typing"/> In practice, while few languages are fully typed, most offer a degree of typing.<ref name="typing"/> 

Because different types (such as [[integer]]s and [[floating point|floats]]) represent values differently, unexpected results will occur if one type is used when another is expected. [[Type checking]] will flag this error, usually at [[compile time]] (runtime type checking is more costly).{{sfn|Sebesta|2012|pp=15, 408–409}} With [[Strongly-typed programming language|strong typing]], [[type error]]s can always be detected unless variables are explicitly [[type conversion|cast]] to a different type. [[Weak typing]] occurs when languages allow implicit casting—for example, to enable operations between variables of different types without the programmer making an explicit type conversion. The more cases in which this [[type coercion]] is allowed, the fewer type errors can be detected.{{sfn|Sebesta|2012|pp=303–304}}  
====Commonly supported types====
{{See also|Primitive data type}}
Early programming languages often supported only built-in, numeric types such as the [[integer]] (signed and unsigned) and [[floating point]] (to support operations on [[real number]]s that are not integers). Most programming languages support multiple sizes of floats (often called [[Single-precision floating-point format|float]] and [[Double-precision floating-point format|double]]) and integers depending on the size and precision required by the programmer. Storing an integer in a type that is too small to represent it leads to [[integer overflow]]. The most common way of representing negative numbers with signed types is [[twos complement]], although [[ones complement]] is also used.{{sfn|Sebesta|2012|pp=246–247}} Other common types include [[Boolean data type|Boolean]]—which is either true or false—and [[Character (computing) |character]]—traditionally one [[byte]], sufficient to represent all [[ASCII]] characters.{{sfn|Sebesta|2012|p=249}} 

[[array (data type)|Arrays]] are a data type whose elements, in many languages, must consist of a single type of fixed length. Other languages define arrays as references to data stored elsewhere and support elements of varying types.{{sfn|Sebesta|2012|p=260}} Depending on the programming language, sequences of multiple characters, called [[string (computing)|strings]], may be supported as arrays of characters or their own [[primitive type]].{{sfn|Sebesta|2012|p=250}} Strings may be of fixed or variable length, which enables greater flexibility at the cost of increased storage space and more complexity.{{sfn|Sebesta|2012|p=254}} Other data types that may be supported include [[list (computing)|lists]],{{sfn|Sebesta|2012|pp=281–282}} [[associative arrays|associative (unordered) arrays]] accessed via keys,{{sfn|Sebesta|2012|pp=272–273}} [[record (computer science)|record]]s in which data is mapped to names in an ordered structure,{{sfn|Sebesta|2012|pp=276–277}} and [[tuple]]s—similar to records but without names for data fields.{{sfn|Sebesta|2012|p=280}} [[Pointer (computer programming)|Pointer]]s store memory addresses, typically referencing locations on the [[Heap (programming)|heap]] where other data is stored.{{sfn|Sebesta|2012|pp=289–290}}

The simplest [[user-defined type]] is an [[Ordinal data type|ordinal type]], often called an [[enumeration]], whose values can be mapped onto the set of positive integers.{{sfn|Sebesta|2012|p=255}} Since the mid-1980s, most programming languages also support [[abstract data types]], in which the representation of the data and operations are [[information hiding|hidden from the user]], who can only access an [[Interface (computing)|interface]].{{sfn|Sebesta|2012|pp=244–245}} The benefits of [[data abstraction]] can include increased reliability, reduced complexity, less potential for [[name collision]], and allowing the underlying [[data structure]] to be changed without the client needing to alter its code.{{sfn|Sebesta|2012|p=477}}

====Static and dynamic typing====
In [[static typing]], all expressions have their types determined before a program executes, typically at compile-time.<ref name="typing"/> Most widely used, statically typed programming languages require the types of variables to be specified explicitly. In some languages, types are implicit; one form of this is when the compiler can [[type inference|infer]] types based on context. The downside of [[implicit typing]] is the potential for errors to go undetected.{{sfn|Sebesta|2012|p=211}} Complete type inference has traditionally been associated with functional languages such as [[Haskell]] and [[ML (programming language)|ML]].<ref>{{Cite conference |last=Leivant |first=Daniel |date=1983 |title=Polymorphic type inference |conference=ACM SIGACT-SIGPLAN symposium on Principles of programming languages |language=en |location=Austin, Texas |publisher=ACM Press |pages=88–98 |doi=10.1145/567067.567077 |isbn=978-0-89791-090-3|doi-access=free }}</ref> 

With dynamic typing, the type is not attached to the variable but only the value encoded in it. A single variable can be reused for a value of a different type. Although this provides more flexibility to the programmer, it is at the cost of lower reliability and less ability for the programming language to check for errors.{{sfn|Sebesta|2012|pp=212–213}} Some languages allow variables of a [[union type]] to which any type of value can be assigned, in an exception to their usual static typing rules.{{sfn|Sebesta|2012|pp=284–285}}