A research reference for aspiring programming-language developers.
- Active Server Pages/ASP.NET
- ActiveX
- Ada and variant:
- Agda
- AIMMS (Advanced Interactive Multidimensional Modeling System)
- ALGOL, its revisions (not enumerated here for brevity,) and minor derivatives (more significant derivatives and successors reside on their own lines in this document and may not have their lineage laid out explicitly, as ALGOL spawned quite a lot of languages:)
- Amiga E and descendants
- AngelScript
- API Elements
- APL
- AppleScript
- Zephyr ASDL (Abstract Syntax Description Language)
- AspectJ
- Assembly language and machine code
- ATS (Applied Type System)
- AWK
- B
- Babelsberg
- BASIC and dialects and derivatives:
- Microsoft Small Basic
- Microsoft Visual Basic and derivatives and cousin:
- LotusScript
- Microsoft Visual Basic for Applications
- Visual Basic .NET, Visual Basic's quasi-successor.
- ProvideX
- Xojo
- Batch files
bc- BCPL
- Bertrand
- BitC
- C and variant dialect:
- SA-C (Notable only for how it added an alternate multi-dimensional array design to C, not for the features it removed from that language to be, in the minds of its creators, more useful for embedded hardware.)
- C++ and related libraries:
- The C++ Standard Library
- The C++ Standard Template Library
- Published and progressing/upcoming ISO C++ Technical Specifcations:
- ISO/IEC TS 18822:2015: C++ File System Technical Specification
- ISO/IEC TS 19570:2015: C++ Extensions for Parallelism
- ISO/IEC TS 19841:2015: Technical Specification for C++ Extensions for Transactional Memory
- ISO/IEC TS 19568:2015: C++ Extensions for Library Fundamentals
- ISO/IEC TS 19217:2015: C++ Extensions for Concepts
- ISO/IEC TS 19571:2016: C++ Extensions for Concurrency
- ISO/IEC TS 19568:2017: C++ Extensions for Library Funcatmentals, Version 2
- ISO/IEC DTS 21425:xxxx: C++ Extensions for Ranges
- ISO/IEC DTS 19216:xxxx: C++ Extensions for Networking
- ISO/IEC DTS 22277:xxxx: Technical Specification for C++ Extensions for Coroutines
- ISO/IEC DTS 22277:xxxx: Extensions to C++ for Modules
- Reflection TS (Not yet assigned an ISO/IEC document number, as it is still in the early development and drafting stages.)
- Numerics TS (Not yet assigned an ISO/IEC document number, as it is still in the early development and drafting stages.)
- ISO/IEC DTS 19571:xxxx: Concurrency TS 2 (Still in the early development stages.)
- ISO/IEC DTS 19570:xxxx: Technical Specification for C++ Extensions for Parallelism Version 2 (Still in the early development and drafting stages.)
- ISO/IEC DTS 19841:xxxx: Transactional Memory TS 2 (Still in the early development stages.)
- Graphics TS (Still in the early development and drafting stages. Contentious/controversial.)
- Boost
- Qt
- C♯ and extensions:
- Carbide
- Ceylon
- CFML (ColdFusion Markup Language)
- Chapel
- The CHECKS Pattern Language of Information Integrity by Ward Cunningham
- Choc
- Cilk
- Claire
- Clarion
- Clipper and related software:
- Clojure
- CLU
- CMS Pipelines
- CoffeeScript
- Adobe Coldfusion
- Common Intermediate Language
- CompCert
- Microsoft's Component Object Model
- Converge
- Coq
- Apple's Core Foundation
- COSWEL, a. k. a. 'POP-1,' and descendants:
- CUDA
- Curl (Not to be confused with cURL)
- Cyclone
- D
- Dart
- DataFlex
- dBase and derivatives:
- Delphi
- Dylan
- E
- ECMAScript and ancestors and derivatives:
- ActionScript
- JavaScript
- JScript and derivative:
- QtScript
- EGL
- Eiffel
- Elm
- Encore
- Epigram
- Erlang and derivatives:
- Escher
- Esterel
- Euclid
- Euler
- Eve
- F
- F♯
- F*
- Factor
- Falcon
- Fantom
- Filetab
- FL
- Forsythe (As far as I'm aware, this theoretical programming language has no existing implementation, but was described and laid out in John C. Reynolds's papers titled 'Design of the Programming Language Forsythe' and 'Preliminary Design of the Programming Language Forsythe'.)
- Forth
- Fortran and derivatives:
- FP
- Fril
- F-Script
- GAUSS
- GEDANKEN
- Genie
- Go
- Gödel
- Groovy
- Hack
- Hartmann pipelines
- Haskell and descendants/derivatives:
- Haxe
- High Level Assembly
- Hollywood (Maaaaaaay-be…?)
- Hope
- Hume
- HyperTalk (as used in HyperCard and derivative:
- Idris
- IMP
- Io
- Ioke
- IPL
- Isabelle
- ISWIM
- Ivy
- J
- J♯
- J++
- Jai (Mostly undocumented; see this YouTube playlist and this GitHub repository for what few notes there are as of this writing.)
- Java and related technologies:
- JOSS and relatives:
- Joule
- Joy
- Julia
- K and derivative:
- Kaleidoscope
- Kotlin
- L (second bulleted item on that link's target web page; see also here)
- LabVIEW
- Language Integrated Query
- The Language Server Protocol
- Lasso
- Leaf
- Leda
- Limbo
- Lingo
- Lisp programming language family members, cousins, and derivatives, along with related libraries and technologies:
- Common Lisp and related facility:
- Emacs Lisp
- Hop
- MDL
- newLISP
- PicoLisp
- Scheme and derivatives/dialects:
- Lithe
- LiveCode
- LiveScript
- LLVM (Obvious possible infrastructure to start bootstrapping the creation of a working compiler for a new programming language.)
- Logo and variant:
- Logtalk
- LPC (Lars Pensjö C)
- Lua
- Lucid
- Lustre
- Magik
- Magma
make- The Maude system
- Maple
- MapReduce
- Mary
- Mathcad
- Wolfram Mathematica
- MATLAB and related software:
- Maxima and Macsyma
- MEL (Maya Embedded Language)
- Mercury
- Mesa
- Message Passing Interface
- Midori
- MIG (Mach Interface Generator)
- MIMIC
- Mirah
- Miranda
- ML and derivatives:
- Caml and derivative implementations:
- Standard ML
- MLIR (Multi-Level Intermediate Representation) (Compiler infrastructure project.)
- Model 204 (Maybe…? Notable for its database scheme, anyway, which is also listed in the section on 'Programming Concepts and Methodologies' below.)
- Modelica
- Modula and successors:
- Mouse
- Moxy
- MUMPS and a related language:
- Myrddin
- Napier88
- Neko
- Nemerle
- nesC
- NESL
- NetLogo
- NEWP
- Newspeak
- NewtonScript
- NGL
- Nial
- Nice
- Nim
- NPL
- Nu
- NumPy
- o:XML
- Oak
- Oberon
- Microsoft's Object Linking and Embedding
- Objective-C and related language and library:
- Objective-J
- Obliq
- occam and derivative version:
- Oil language (See also the Oil shell, or
osh.) - OMeta
- OmniMark
- Onyx
- Opa
- OpenACC
- OpenCL
- OpenGL and variants/derivatives and related technologies:
- OpenMP
- OptimJ
- Orc
- Orwell
- Oxygene
- Oz
- ParaSail
- Pascal and derivatives:
- Object Pascal family of language derivatives
- UCSD Pascal
- Pawn
- Perl and related library and language derivative:
- Perl Data Language
- Perl 6 and one of its implementation's implementation details:
- PHP
- Pico
- Pig Latin
- Pike
- Pizza
- PL/Ⅰ and derivative subset:
- PLANC (Notable for its reversed-direction assignment operator,
=:.) - PLEXIL (Notable for how it makes program statement and expression types, as well as program execution state, rather explicit.)
- Plus (Notable at least for its pointer declaration syntax even though it does not use any symbolic notation for its pointer types as is more common nowadays.)
- PowerHouse (Notable only for the brevity of some programs written in it.)
- Processing and related language:
- Prolog and various dialects and derivatives:
- B-Prolog
- CHIP and a derivative/descendant of it:
- Ciao
- ECLiPSe
- GNU Prolog
- SWI-Prolog
- Visual Prolog
- XSB
- PROMELA
- Pure
- Pyret
- Python and related technologies, as well as variants:
- QML
- Rebol and derivative/descendant:
- Refal
- REXX and derivatives/descendents:
- Ring
- Rlab
- ROOP
- RPG and successor:
- RPL
- RTL/2
- Ruby
- Rust
- S and modern derivative implementations:
- S2
- S-Lang
- SAIL (Notable only for some of the projects developed in it.)
- SALSA (Notable for its message-passing syntax, perhaps…?)
- SAM76
- Sather
- Sawzall
- Scala
- Scratch and derivative:
- Script.NET
sed- Seed7
- SequenceL
- SETL (Notable for its use in the creation of the NYU Ada/ED translator, the first validated Ada implementation, as well as its incorporation of ideas from set theory and first-order predicate logic.)
- SiMPLE (Notable for its 'Drag & Drop' mode of delivering code to the language's interpreter presciently reminiscent of how macOS Dock icons can open files that are dragged on top of them.)
- Shell and text-editor scripting languages such as those used in:
- Bourne shell and derivatives, including:
- C shell (
csh) and derivatives: - Korn shell (
ksh) - Microsoft Windows PowerShell
rcand derivative:- TECO
- Honeywell Information Systems's TEX (Text Executive) text-processing language
- Oil shell (
osh) (See also the Oil language.) - Other examples of a Unix shell, if any.
- Vim script
- Z shell (
zsh)
- SIGNAL
- The Simple DirectMedia Layer
- SIMSCRIPT (Notable for its influence on Simula.)
- Simula
- SISAL
- SLIP
- SMALL (Notable for its explicit design for use on embedded systems close to hardware, perhaps…?)
- Smalltalk and derivative dialects and implementations:
- SMX
- SNOBOL and alternatives/derivatives:
- Snowball
- Solidity (Notable for its use in writing 'smart contracts', the concept of which may be related to 'design by contract' as listed under the later section on 'Programming Concepts and Methodologies'…?)
- Spin
- SQL and extensions:
- SQR
- Squirrel
- SR and derivative:
- S/SL
- Stata
- Subtext
- SugarJ and a language extension provided by same software suite for another language:
- SugarHaskell (Similarly extends Haskell.)
- Apple Swift
- Swift
- Tangle
- Tart
- Tcl and extensions:
- Tea
- Telescript
- Terra
- TeX and associated software packages, including, but not limited to (see CTAN, the Comprehensive TeX Archive Network (Wikipedia article here) (Really only relevant in the context of 'literate programming;' see the referecnes to packages implementing this in TeX below and the relevant link in the section on 'Programming Concepts and Methodologies' later on:)
- TIE (Tensilica Instruction Extension)
- Timber
- TLA+
- Tom
- TOM
- Toi
- TRAC and a recipient of influence therefrom:
- Transaction Application Language (Notable for how it combines ALGOL- and Pascal-like syntax with C-like semantics.)
- TTCN
- Turing
- TUTOR
- TXL
- Ubercode
- Umple
- Uniface
- UNITY
- UnrealScript
- Vala
- Viper
- Visual DialogScript
- Visual FoxPro
- Visual Objects
- vvvv (Not to be confused with the video game VVVVVV)
- WebAssembly
- WebDNA
- WebGL
- Web IDL
- WebQL
- Whiley
- Winbatch
- Wolfram Language
- Wren
- Wyvern
- X10
- XC
- XL
- XML and related technologies:
- Xtend
- Yahoo! Query Language (YQL)
- Yoix
- Yorick
- Z notation
- Zeno
- Zig
- ZPL
-
Abstract syntax trees and related ideas:
-
The abstraction principle and a generalization of it:
- The 'Don't Repeat Yourself' (DRY) principle
-
Concurrent programming and variant:
-
Data type(s) and its/their various manifestations:
- Primitive data types (also called 'fundamental data types' in some cases,) including, but possibly not limited to:
-
A Boolean data type (See also 'bits' below, as this data type can use one of these as its backing storage, though implementations of said data type specific to certain ISAs using, depending on that ISA's data endianness), the least or most significant bit of a byte, leaving that byte's other bits as spatial overhead in the form of unused padding bits, exist and are common in at least some programming language implementations.)
-
Numeric types, including:
-
Arithmetic types — that is types supporting arithmetic operations (and often the modulo operation related to modular arithmetic as a common extension, as well, at least for most arithmetic types, a common exception being floating-point numeric types:)
-
Quasi- and fully integral data types such as:
- Bits
- Nybbles (Not commonly implemented as a primitive or fundamental data type, if at all, in programming languages, but extractable using bit shifting and masking.)
- Bytes, which, in the context of most, if not all, modern computer ISAs, are synonymous with:
- Machine words1
- Natural numbers of varying precision and range:
- Common precisions and ranges include those imposed by the constraints of:
• 16-bit (2-byte) storage- 32-bit (4-byte) storage
- 64-bit (8-byte) storage
- Larger storage extents; common examples of these are:
- 128-bit (16-byte) storage
- Flexibly sized storage suitable for use with arbitrary-precision integers; not always implemented as a fundamental type, but made available (typically as a library abstraction) all the same.
- Smaller storage extents; not commonly implemented, if at all.
- Common precisions and ranges include those imposed by the constraints of:
- Integers of, similarly to natural numbers, varying precision, ranges, and, additionally, signedness:
- Common precisions and ranges include those imposed by the constraints of:
• 16-bit (2-byte) storage- 32-bit (4-byte) storage
- 64-bit (8-byte) storage
- Larger storage extents; common examples of these are:
- 128-bit (16-byte) storage
- Flexibly sized storage suitable for use with arbitrary-precision integers; not always implemented as a fundamental type, but made available (typically as a library abstraction) all the same.
- Smaller storage extents; not commonly implemented, if at all.
- Signedness) may manifest itself in a data type by making it either of the following possibilities:
- Unsigned; able to store only values greater than or equal to 0 (zero) within the precision of the integral type in question
- Signed; able to represent negative numbers in addition to those representable as unsigned integral values within the precision of the backing data type by a shift in the range of values it can store
- Common precisions and ranges include those imposed by the constraints of:
-
Rational numbers of, similarly to integers, varying precision, range, and signedness, often used as approximate representations of real numbers, such as:
- Arbitrary fractions with numerators and denominators of, similarly to integers, varying precision, range, and signedness:
- Common precisions and ranges include those imposed by the constraints of:
- 16-bit (2-byte) storage
- 32-bit (4-byte) storage
- 64-bit (8-byte) storage
- Larger storage extents; common examples of these are:
- 128-bit (16-byte) storage
- Flexibly sized storage suitable for use with arbitrary-precision integers; not always implemented as a fundamental type, but made available (typically as a library abstraction) all the same.
- Smaller storage extents; not commonly implemented, if at all.
- Signedness may manifest itself in a data type by making it either of the following possibilities:
- Unsigned; able to store only values greater than or equal to 0 (zero) within the precision of the integral type in question
- Signed; able to represent negative numbers in addition to those representable as unsigned integral values within the precision of the backing data type by a shift in the range of values it can store
- Common precisions and ranges include those imposed by the constraints of:
- Fixed-point numbers of, similarly to natural numbers, integers, and other rational numbers, varying precision, range, and signedness
- Floating-point numbers of, similarly to natural numbers, integers, and other rational numbers such as fixed-point numbers, varying precision, range, and signedness:
- Common precisions and ranges include:
- Half precision, consuming 16 bits, or 2 bytes, of backing storage
- Single precision, consuming 32 bits, or 4 bytes, of backing storage
- Double precision, consuming 64 bits, or 8 bytes, of backing storage
- Extended-precision formats, including, but not limited to:
- The x86 extended-precision format, consuming 80 bits, or 8.1875 bytes, of backing storage
- Quadruple precision, consuming 128 bits, or 16 bytes, of backing storage
- Octuple precision, consuming 256 bits, or 32 bytes, of backing storage
- As also explained earlier, signedness may manifest itself in a data type by making it either of the following possibilities:
- Unsigned; able to store only values greater than or equal to 0 (zero) within the precision of the floating-point data type in question
- Signed; able to represent negative numbers in addition to those representable as unsigned floating-point values within the precision of the backing data type by a shift in the range of values it can store
- Common precisions and ranges include:
These days, most general-purpose computers store floating-point numbers inside their containing data types using the format specified as a standard by IEEE 754, which specifies both binary and decimal variants of the various precisions specified above (x86's extended-precision floating-point format being IEEE 754–compatible, of course.)
- Arbitrary fractions with numerators and denominators of, similarly to integers, varying precision, range, and signedness:
-
-
Imaginary numbers of, similarly to natural numbers, integers, and rational numbers, varying precision, range, and signedness
-
Complex numbers of, similarly to natural numbers, integers, and rational numbers, varying precision, ranges, and signedness:
- Common precisions and ranges include the same ones as those supported by floating-point numbers, as those types are in relatively common use for storing complex numbers' real and imaginary parts.
- Again, as also explained earlier, signedness may manifest itself in a data type by making it either of the following possibilities:
- Unsigned; able to store only values greater than or equal to 0 (zero) within the precision of the type backing the complex number type in question
- Signed; able to represent negative numbers in addition to those representable as unsigned complex numeric values within the precision of the backing data type by a shift in the range of values it can store
(Note that complex numbers are not classified as typical arithemtic types here since their elementary operations consist both of member-wise arithmetic on their real and imaginary parts and of more complicated operations involving both their real and their imaginary parts at the same time.)
-
-
(Note that any of the types of numbers mentioned under this bullet point can be encoded in various bases, including, but not limited to: binary (base-2; octal (base-8;) decimal (base-10; for human production and consumption, among other purposes;) and hexadecimal.)
- Characters in various encodings, some (at least relatively) common examples of which include, but are not limited to:
- ASCII (American Standard Code for Information Interchange)
- ISO/IEC 8859
- EBCDIC (Extended Binary Coded Decimal Interchange Code) (No longer common. Mostly used today only on IBM hardware for backwards-compatibility purposes, apparently.)
- Various legacy character encodings and code pages, examples of which include:
- Mac OS Roman (A relic of the classic Mac OS)
- The Microsoft Windows code pages
- Shift JIS (Shift Japanese Industrial Standards)
- ISO/IEC 2022
- Multiple variants of and character sets used as part of Unicode:
- UTF-8 (Unicode Transformation Format — 8-bit)
- UTF-16 (Unicode Transformation Format — 16-bit)
- UTF-32 (Unicode Transformation Format — 32-bit)
- Variant encodings of the UCS (Universal Coded Character Set):
- UCS-2 (Universal Coded Character Set — 2-byte)
- UCS-4 (Universal Coded Character Set — 4-byte)
Usually represented internally as an integer index into an encoding table.
-
References and kinds of them:
-
Functions/subroutines and various different kinds of them, such as:
-
Types which may be either primitive/fundamental or composite:
- Associative arrays
- Continuations
- Coroutines
- First-class functions
- Closures and similar constructs:
- Callbacks
- Blocks (Not to be confused with blocks as a unit for structuring code.)
- Delegates
- Function objects
- Inline agents
- Lists
- Some types of numbers, namely:
- Tuples
-
- Arrays
- Enumerations
- Lists
- Metaobjects
- Objects
- Records
- Sets
- Strings and other text types (composed of contiguous sequences of characters)
- Tuples
- Unions and a kind of them:
- Tagged unions (See also 'variant types'.)
-
-
Algebraic data types and examples of them:
-
Associative arrays (Also known as:
- Dictionaries
- Hash tables
- Maps)
-
Container types
-
Intersection types (No good language-agnostic description of this kind of data type seems to exist just from a few, somewhat cursory Google searches, but there is documentation for this concept within the context of various languages. Here's what has been easily located so far in that respect, namely documentation on using intersection types in:
Also related to intersection types are refinement types.
- Union types
- Linear types
- Opaque types
- Option types
- Recursive types
- Refinement types
- Queues and various types thereof, including, but not limited to:
- Semaphores
- Sets
- Smart pointers
- Stacks
- Streams
- Trees
- Variant types
-
-
Utility types:
- Error types, including, but not limited to:
- Exception types
- Calendaring types
- Types for keeping track of time and durations
- Error types, including, but not limited to:
-
Other types:
- 'Top' type
- 'Bottom' type
- Unit types and a similar concept, that of the:
See also 'type systems'2.
- Primitive data types (also called 'fundamental data types' in some cases,) including, but possibly not limited to:
-
Declarative programming and related concepts:
- Constraint programming
- Dataflow programming and sub-types:
- Reactive programming and one of its sub-forms:
- Functional programming
- Logic programming
-
Dynamic programming (as in dynamic programming languages)
-
Feature-oriented programming (More of an organizational concern for software developers in general, but tangentially related to programming language design since one could presume that a good programming language would allow it.)
-
Formal systems, examples of which include:
- Hoare logic and an extension of it:
-
Free-form languages, including:
- [']Begin[…]End['] languages (As opposed to 'curly-brace' languages and ['off-side rule'(#off-side_rule) languages.) (Only in solving the problem that 'curly-brace' programming languages sometimes have in that their users can sometimes lose track of what block a closing delimiter ends as an optional annotation on that delimiter, methinks.)
- 'Curly-brace' languages (As opposed to 'Begin…End' languages and 'off-side rule' languages.)
-
Imperative programming and sub-disciplines:
-
Interactive-mode languages (See also:
-
Language-oriented programming and possibly-relevant sub-types:
- Domain-specific language generation and use
- Grammar-oriented programming and a possible example of it:
- Construction of programming-language dialects
- Intentional programming
- Natural-language programming
-
Learnable programming (See the blog post by the same name in the following section.)
-
Liskov substitutability (See also 'subtyping'.)
-
Memory management and related topics:
- Manual memory management (Note that this is quite low-level and can easily lead to programmer/programming error(s,) thus resulting in code that is not memory-safe.)
- Memory safety
- Resource acquisition is initialization (RAII)
- Reference counting — that is, when used outside of an implementation of garbage collection (see below for the bullet point on that.)
- Garbage collection and various strategies for implementing it:
- Tracing
- Reference counting (As noted above, this is also used outside of garbage collection.)
- Escape analysis (This may also be used to detect opportunities and/or targets for optimization.)
-
Metaprogramming and examples of it:
- Automatic programming and sub-discipline:
- Homoiconicity
- Reflective programming (involving the use of reflection and a related idea:
- Template metaprogramming and a use case and a related methodology:
- The use of macros
-
Name binding (Forms of this include:
- Early/static binding (This appears to be considered the most common form of name binding.) (A variant of this is:
- Late, or 'dynamic', binding)
-
Non-structured programming and a (possible…?) example of it:
-
Object-oriented programming and styles of it:
-
Off-side rule languages (As opposed to 'Begin…End' languages and 'curly-brace' languages.)
-
Parallel computing and one methodology used to implement it:
-
Polymorphism and related topics:
- Static polymorphism (See also 'template metaprogramming'
- 'Ad hoc' polymorphism and some forms of it:
- Function overloading
- Use of type classes
- Parametric polymorphism (See also 'generic programming'.)
- Subtyping (See also 'Liskov substitutability'.)
- Concepts derived from the interaction between parametric polymorphism and subtyping:
- (Co- and contra)variance
- Bounded quantification in type theory/-ies
- Related ideas and implementation considerations:
- Function/method dispatch techniques:
- See also 'name binding.'
-
Structured programming, including, but not limited to (some examples of this in this list also stand on their own and are thus assigned appropriate positions within its first level of bullets accordingly:)
- Block-oriented programming
- By separation of concerns
- The use of:
-
Tacit programming, or 'point-free style,' and an example of it:
- Concatenative programming languages (Reminiscent of chained function application in some instances.)
-
Types of user interfaces for interaction with a programming language and utilities written in it, including, but most definitely not limited to:
- Command-line interfaces (CLIs) (obviously useful more for development tasks; it is to some extent likely that a CLI for something is implemented as developer infrastructure whether or not it ends up having a different kind of user interface.)
- Graphical user interfaces (GUIs)
- Text-based user interfaces (TUIs)
- Touch user interfaces
-
Type systems, examples of them, use cases of them, methods for applying them, and related topics:
- Static typing
- Dynamic typing
- Strong and weak typing (Preferrably the former, but inferred if possible, unless hidden by type-erasure in a retrievable manner.)
- Manifest typing
- Type inference
- Nominal typing
- Structural typing
- Optional typing (As desribed in the preceding link's target Wikipedia article section, "The requirement that types do not affect the semantics of the language is difficult to fulfill." This is, as such, probably not that desirable to use unless one could find a way to correct or work around this.)
- Duck typing (Also mentioned in a section of the Wikipedia article linked to by this bullet item's parent.)
- Dependent typing (Also mentioned in a section of the Wikipedia article linked to by this bullet item's parent.)
- Linear typing (Also mentioned in a section of the Wikipedia article linked to by this bullet item's parent.)
- Uniqueness typing
- Intersection typing (See also 'intersection types' under 'data types'.)
- Union typing
- Induction typing
- Existential typing
- Gradual typing
- Unified type systems (Most assuredly not a good idea, as they go against and/or somewhat heavily discourage the use of the idea of a concept in generic programming
- Type construction
- Type erasure
- Kinds of entities subject to a type system
See also 'data type(s) and its/their various manifestations'2.
- Growing a Language by Guy L. Steele, Jr.
- 'C Is Not a Low-level Language' (ACM Queue volume 16, issue 2) by David Chisnall
- 'Little things that matter in language design' by Neil Brown, LWN.net
- 'Learnable Programming' by Bret Victor
- 'Up and Down the Ladder of Abstraction' by Bret Victor
- 'Not Everything is an Expression' by Michael Arntzenius
- 'Aphorisms on programming language design' by Michael Arntzenius
- 'Beware of the Turing Tar-Pit' by Reginald 'Raganwald' Braithwaite
N. b.: Most notes in this document are included inline in parentheses at the end of the bullet-point/-item lines to which they apply.
1The bullet items suffixed with a reference to this endnote are most relevant in the context of assembly language(s) and machine code.
2Some child bullet items appear under both the parent bullet point on data types and the parent bullet item on type systems.
- Correct the fact that one of the programming languages in this document is included herein because it was the earliest one to have a 128-bit (possibly extended?) floating-point data type mapped to the underlying IBM System/370 hardware, but I can't, for the life of me, remember which one so as to add a corresponding inline note to it in parentheses at the end of its bullet-point/-item line.)
- Add references to programming-language evolution and purpose manifestos suitable for drawing inspiration from (possibly for improving the documentation behind the rationale for this programming language's conception…?)
- Add more references to useful examples of code libraries written in other programming languages that might serve as good inspiration for core, standard, and/or common-use libraries that should get created for this one.