Who Invented C Language?

In this tutorial we will talk about who invented C language and the detailed history about when C language was invented and about different versions of C language. We will also discuss the journey of Dennis M. Ritchie became the father of C language. Let’s discuss the whole journey about how and who invented C language.

Who Is the Father Of C Language?

Dennis M. Ritchie, an American computer scientist, is the father of C language who created it at Bell Laboratories in the early 1970s (formerly AT&T Bell Laboratories). When compared to the mainframe computers of the era, minicomputers like the DEC PDP 7 had relatively limited memory, hence C was created as a minimalist language to be used in operating system development. The language was created between 1969 to 1973, at the same time when the UNIX operating system was being developed. It was built upon CPL (Combined Programming Language), which had previously been condensed into the B programming language—a simplified computer programming language—created in 1969–1970 by Ken Thompson, an American computer scientist and Ritchie’s colleague. Ritchie later created C by rewriting and restoring CPL features, and he later constructed the UNIX operating system in the new language.

Let’s Discuss the journey of the different version C language and how C was developed by Dennis M. Ritchie.

Early Developments

The creation of the Unix operating system, which Dennis Ritchie and Ken Thompson first constructed in assembly language on a PDP-7 while absorbing suggestions from coworkers, is strongly linked to the history of C. The operating system was eventually selected to be ported to a PDP-11. Assembly language was also used in the development of the initial PDP-11 Unix system.


Thompson wished to create utilities for the new platform in a programming language. He initially attempted to create a Fortran compiler but soon gave up. He instead produced a condensed form of the freshly released BCPL systems programming language. As there was no formal explanation of BCPL at the time, Thompson changed the syntax to be less verbose and more like SMALGOL, a streamlined version of ALGOL. The outcome was what Thompson referred to as B. He described B as having "BCPL semantics with a lot of SMALGOL syntax". B has a bootstrapping compiler to make it easier to port to new computers, just like BCPL. However, because of its slowness and inability to utilize PDP-11 capabilities like byte addressability, few utilities were finally built in B.

New B and first C release

Ritchie started enhancing B in 1971 in order to make use of the PDP-11’s more potent features. A character type was an important addition. This was his New B. As Thompson began to utilize NB to create the Unix kernel, his needs influenced the development of the language. The NB language gained more complex types up to 1972, including arrays of int and char. There were also introduced pointers, the capacity to construct pointers to other kinds, arrays of all types, and types that might be returned from functions. Expressions contained pointers to arrays. The language was renamed to C, and a new compiler was created.

Version 2 Unix, often known as Research Unix, includes the C compiler and a few tools created with it.

Structures and the Unix kernel re-write

The Unix kernel was largely reimplemented in C at Version 4 Unix, which was released in November 1973. At this point, the C language included powerful additions like struct types.

At Alan Snyder’s urging and in acknowledgment of the value of the file-inclusion mechanisms present in BCPL and PL/I, the preprocessor was first released around 1973. Only included files and straightforward string replacements (#include and #define of parameterless macros) were offered in the original version. Soon after that, it was expanded to include macros with arguments and conditional compilation, primarily by Mike Lesk and then John Reiser.

One of the earliest operating system kernels created outside of assembly was Unix. The Multics system, which was created in PL/I, and the Master Control Program (MCP), which was written in ALGOL for the Burroughs B5000 in 1961, are earlier examples. Ritchie and Stephen C. Johnson added more language modifications to aid in the portability of the Unix operating system about 1977. Several C implementations for new platforms were built using Johnson’s Portable C Compiler.


The C Programming Language was first released in 1978 by Brian Kernighan and Dennis Ritchie. For many years, this book, known to C programmers as K&R, functioned as an informal specification of the language. It discusses a version of C that is usually referred to as "K&R C." This is also known as C78 because it was released in 1978. The subsequent ANSI C standard, which is detailed below, is covered in the second edition of the book.

K&R introduced several language features:

  • Standard I/O library
  • long int data type
  • unsigned int data type

In order to eliminate the semantic ambiguity caused by constructs like i=-10, which had been interpreted as i =- 10 (decrement i by 10) instead of the potentially intended i = -10 (let i be 10), compound assignment operators of the type =op (such as =-) were altered to the form op= (that is, -=). Since many older compilers were still in use and since carefully written K&R C code can be legal Standard C as well, K&R C was for a long time still regarded as the "lowest common denominator" to which C programmers restricted themselves when maximum portability was desired. This was true even after the 1989 ANSI standard’s publication.


Versions of C were implemented for numerous mainframe computers, minicomputers, and microcomputers, including the IBM PC, in the late 1970s and early 1980s when its popularity started to rapidly rise.

The American National Standards Institute (ANSI) established the X3J11 committee in 1983 to create a standard C specification. The non-portable section of the Unix C library was given to the IEEE working group 1003 to serve as the foundation for the 1988 POSIX standard, although X3J11 based the C standard on the Unix implementation. The "Programming Language C" standard, ANSI X3.159-1989, was approved in 1989. Common names for this version of the language include ANSI C, Standard C, and occasionally C89.

The International Organization for Standardization (ISO) approved the ANSI C standard in 1990 as ISO/IEC 9899:1990, sometimes known as C90, with formatting modifications. Since they both relate to the same programming language, "C89" and "C90" are interchangeable.

The international C standard is maintained by the working group ISO/IEC JTC1/SC22/WG14, and ANSI, like other national standards bodies, no longer develops the C standard independently. Within a year of ISO publication, a national adoption of an update to the international standard is normal.

A superset of K&R C that included many of the later-introduced unauthorized features was one of the objectives of the C standardization process. The standards committee also added a number of other features, including preprocessing improvements, void pointers, support for international character sets and locales, function prototypes (which were taken from C++), and function prototypes. Although the C++ style was added to the syntax for parameter declarations, the K&R interface was still allowed to maintain compatibility with existing source code.


The C standard underwent more revisions in the late 1990s, and as a result, ISO/IEC 9899:1999—also known as "C99"—was published in 1999. Technical Corrigenda has since made three changes to it.
Inline functions, new data types (such as long long int and a complex type to represent complex numbers), variable-length arrays, flexible array members, improved IEEE 754 floating point support, support for variadic macros (macros of variable arity), and support for one-line comments starting with //, as in BCPL or C++, are just a few of the new features that C99 introduced. Numerous C compilers have already added many of them as extensions.


Another rewrite of the C standard, code-named "C1X" until its official publication as ISO/IEC 9899:2011 on December 8, 2011, was started in 2007. To prevent the introduction of new features that had not been put to the test by current implementations, the C standards committee created guidelines.

Numerous new features, such as type generic macros, anonymous structures, enhanced Unicode support, atomic operations, multi-threading, and bounds-checked functions, are added to C and the library in the C11 standard. It also improves interoperability with C++ and makes several components of the current C99 library optional. The 201112L definition of the standard macro STDC VERSION signifies the presence of C11 support.


The most recent standard for the C programming language is C17, which was released in June 2018 as ISO/IEC 9899:2018. It simply makes technical adjustments and clarifications to C11’s flaws; it does not provide any new linguistic features. The definition of the default macro STDC VERSION is 201710L.


The following (after C17) major modification to the C language standard is known informally as C2x. It would be known as C23 and is anticipated to be voted on in 2023.

Embedded C

The C language has traditionally needed nonstandard extensions to implement exotic features like fixed-point arithmetic, many separate memory banks, and fundamental I/O operations.

The C Standards Committee released a technical report in 2008 that extended the C language to address these problems by establishing a uniform standard that all implementations must follow. It offers a number of features not found in standard C, including named address spaces, fixed-point arithmetic, and fundamental I/O hardware addressing.

Through this article, I have given all the details about c language and about who developed C language. This article has every single detail about how the C language was developed by Dennis Ritchie.

Leave a Reply

Your email address will not be published. Required fields are marked *