The History of the C Language

The C programming language was devised in the early 1970s by Dennis M. Ritchie an employee

from Bell Labs (AT&T).

In the 1960s Ritchie worked, with several other employees of Bell Labs (AT&T), on a project called

Multics. The goal of the project was to develop an operating system for a large computer that could

be used by a thousand users. In 1969 AT&T (Bell Labs) withdrew from the project, because the

project could not produce an economically useful system. So the employees of Bell Labs (AT&T) had

to search for another project to work on (mainly Dennis M. Ritchie and Ken Thompson).

Ken Thompson began to work on the development of a new file system. He wrote, a version of the

new file system for the DEC PDP-7, in assembler. (The new file system was also used for the game

Space Travel). Soon they began to make improvements and add expansions. (They used there

knowledge from the Multics project to add improvements). After a while a complete system was

born. Brian W. Kernighan called the system UNIX, a sarcastic reference to Multics. The whole system

was still written in assembly code.

Besides assembler and Fortran, UNIX also had an interpreter for the programming language B. (

The B language is derived directly from Martin Richards BCPL). The language B was developed in

1969-70 by Ken Thompson. In the early days computer code was written in assembly code. To

perform a specific task, you had to write many pages of code. A high-level language like B made it

possible to write the same task in just a few lines of code. The language B was used for further

development of the UNIX system. Because of the high-level of the B language, code could be

produced much faster, then in assembly.

A drawback of the B language was that it did not know data-types. (Everything was expressed in

machine words). Another functionality that the B language did not provide was the use of

“structures”. The lag of these things formed the reason for Dennis M. Ritchie to develop the

programming language C. So in 1971-73 Dennis M. Ritchie turned the B language into the C

language, keeping most of the language B syntax while adding data-types and many other changes.

The C language had a powerful mix of high-level functionality and the detailed features required to

program an operating system. Therefore many of the UNIX components were eventually rewritten

in C (the Unix kernel itself was rewritten in 1973 on a DEC PDP-11).

The programming language C was written down, by Kernighan and Ritchie, in a now classic book
called “The C Programming Language, 1st edition”. (Kernighan has said that he had no part in the
 design of the C language: “It’s entirely Dennis Ritchie’s work”. But he is the author of the famous

“Hello, World” program and many other UNIX programs).

For years the book “The C Programming Language, 1 st edition” was the standard on the language

C. In 1983 a committee was formed by the American National Standards Institute (ANSI)

to develop a modern definition for the programming language C (ANSI X3J11). In 1988 they

delivered the final standard definition ANSI C. (The standard was based on the book from K&R

1st ed.).

The standard ANSI C made little changes on the original design of the C language. (They had to

make sure that old programs still worked with the new standard). Later on, the ANSI C standard

was adopted by the International Standards Organization (ISO). The correct term should there fore

be ISO C, but everybody still calls it ANSI C.

(To view a brief history of the C++ language;

href=””>click here).

C / C++ Hall of fame:

If you look at the pictures you will understand the UNIX credo : “No beard, no belly, no guru…”

https://www.codingunit.com/the-history-of-the-c-language
Early developments
Year C Standard[10]

1972 Birth

1978 K&R C

19(89/90) ANSI C and ISO C

1999 C99

2011 C11

The origin of C is closely tied to the development of the Unix operating system, originally
implemented in assembly language on a PDP-7 by Dennis Ritchie and Ken Thompson, incorporating
several ideas from colleagues. Eventually, they decided to port the operating system to a PDP-11.
The original PDP-11 version of Unix was developed in assembly language. The developers were
considering rewriting the system using the B language, Thompson's simplified version
of BCPL.[11] However B's inability to take advantage of some of the PDP-11's features,
notably byte addressability, led to C. The name of C was chosen simply as the next after B.[12]
The development of C started in 1972 on the PDP-11 Unix system[13] and first appeared in Version 2
Unix.[14] The language was not initially designed with portability in mind, but soon ran on different
platforms as well: a compiler for the Honeywell 6000 was written within the first year of C's history,
while an IBM System/370 port followed soon.[1][13]
Also in 1972, a large part of Unix was rewritten in C.[15] By 1973, with the addition of struct types,
the C language had become powerful enough that most of the Unix kernel was now in C.
Unix was one of the first operating system kernels implemented in a language other than assembly.
Earlier instances include the Multics system (which was written in PL/I) and Master Control
Program (MCP) for the Burroughs B5000(which was written in ALGOL) in 1961. In around 1977,
Ritchie and Stephen C. Johnson made further changes to the language to facilitate portability of the
Unix operating system. Johnson's Portable C Compiler served as the basis for several
implementations of C on new platforms.[13]

K&R C
The cover of the book, The C Programming Language, first edition by Brian Kernighan and Dennis Ritchie

In 1978, Brian Kernighan and Dennis Ritchie published the first edition of The C Programming
Language.[1] This book, known to C programmers as "K&R", served for many years as an
informal specification of the language. The version of C that it describes is commonly referred to
as K&R C. The second edition of the book[16] covers the later ANSI C standard, described below.
K&R introduced several language features:

 Standard I/O library

 long int data type
 unsigned int data type
 Compound assignment operators of the form =op (such as =- ) were changed to the
form op= (that is, -= ) to remove the semantic ambiguity created by constructs such as i=-10 ,
which had been interpreted as i =- 10 (decrement i by 10) instead of the possibly
intended i = -10 (let i be -10).
Even after the publication of the 1989 ANSI standard, for many years K&R C was still considered the
"lowest common denominator" to which C programmers restricted themselves when maximum
portability was desired, since many older compilers were still in use, and because carefully written
K&R C code can be legal Standard C as well.
In early versions of C, only functions that return types other than int must be declared if used
before the function definition; functions used without prior declaration were presumed to return
type int .
For example:

long some_function();
/* int */ other_function();

/* int */ calling_function()
{
long test1;
register /* int */ test2;

test1 = some_function();
if (test1 > 0)
test2 = 0;
else
test2 = other_function();
return test2;
}

The int type specifiers which are commented out could be omitted in K&R C, but are required in
later standards.
Since K&R function declarations did not include any information about function arguments, function
parameter type checks were not performed, although some compilers would issue a warning
message if a local function was called with the wrong number of arguments, or if multiple calls to an
external function used different numbers or types of arguments. Separate tools such as
Unix's lint utility were developed that (among other things) could check for consistency of function
use across multiple source files.
In the years following the publication of K&R C, several features were added to the language,
supported by compilers from AT&T (in particular PCC[17]) and some other vendors. These included:

 void functions (i.e., functions with no return value)

 functions returning struct or union types (rather than pointers)
 assignment for struct data types
 enumerated types
The large number of extensions and lack of agreement on a standard library, together with the
language popularity and the fact that not even the Unix compilers precisely implemented the K&R
specification, led to the necessity of standardization.

ANSI C and ISO C

Main article: ANSI C
During the late 1970s and 1980s, versions of C were implemented for a wide variety of mainframe
computers, minicomputers, and microcomputers, including the IBM PC, as its popularity began to
increase significantly.
In 1983, the American National Standards Institute (ANSI) formed a committee, X3J11, to establish
a standard specification of C. X3J11 based the C standard on the Unix implementation; however, the
non-portable portion of the Unix C library was handed off to the IEEEworking group 1003 to become
the basis for the 1988 POSIX standard. In 1989, the C standard was ratified as ANSI X3.159-1989
"Programming Language C". This version of the language is often referred to as ANSI C, Standard
C, or sometimes C89.
In 1990, the ANSI C standard (with formatting changes) was adopted by the International
Organization for Standardization (ISO) as ISO/IEC 9899:1990, which is sometimes called C90.
Therefore, the terms "C89" and "C90" refer to the same programming language.
ANSI, like other national standards bodies, no longer develops the C standard independently, but
defers to the international C standard, maintained by the working group ISO/IEC JTC1/SC22/WG14.
National adoption of an update to the international standard typically occurs within a year of ISO
publication.
One of the aims of the C standardization process was to produce a superset of K&R C, incorporating
many of the subsequently introduced unofficial features. The standards committee also included
several additional features such as function prototypes (borrowed from C++), void pointers,
support for international character sets and locales, and preprocessor enhancements. Although
the syntax for parameter declarations was augmented to include the style used in C++, the K&R
interface continued to be permitted, for compatibility with existing source code.
C89 is supported by current C compilers, and most C code being written today is based on it. Any
program written only in Standard C and without any hardware-dependent assumptions will run
correctly on any platform with a conforming C implementation, within its resource limits. Without
such precautions, programs may compile only on a certain platform or with a particular compiler,
due, for example, to the use of non-standard libraries, such as GUI libraries, or to a reliance on
compiler- or platform-specific attributes such as the exact size of data types and byte endianness.
In cases where code must be compilable by either standard-conforming or K&R C-based compilers,
the __STDC__ macro can be used to split the code into Standard and K&R sections to prevent the
use on a K&R C-based compiler of features available only in Standard C.
After the ANSI/ISO standardization process, the C language specification remained relatively static
for several years. In 1995, Normative Amendment 1 to the 1990 C standard (ISO/IEC
9899/AMD1:1995, known informally as C95) was published, to correct some details and to add more
extensive support for international character sets.[18]

C99
Main article: C99
The C standard was further revised in the late 1990s, leading to the publication of ISO/IEC
9899:1999 in 1999, which is commonly referred to as "C99". It has since been amended three times
by Technical Corrigenda.[19]
C99 introduced several new features, including inline functions, several new data
types (including long long int and a complex type to represent complex numbers), variable-
length arrays and flexible array members, improved support for IEEE 754 floating point, support
for variadic macros (macros of variable arity), and support for one-line comments beginning with // ,
as in BCPL or C++. Many of these had already been implemented as extensions in several C
compilers.
C99 is for the most part backward compatible with C90, but is stricter in some ways; in particular, a
declaration that lacks a type specifier no longer has int implicitly assumed. A standard
macro __STDC_VERSION__ is defined with value 199901L to indicate that C99 support is
available. GCC, Solaris Studio, and other C compilers now support many or all of the new features
of C99. The C compiler in Microsoft Visual C++, however, implements the C89 standard and those
parts of C99 that are required for compatibility with C++11.[20]

C11
Main article: C11 (C standard revision)
In 2007, work began on another revision of the C standard, informally called "C1X" until its official
publication on 2011-12-08. The C standards committee adopted guidelines to limit the adoption of
new features that had not been tested by existing implementations.
The C11 standard adds numerous new features to C and the library, including type generic macros,
anonymous structures, improved Unicode support, atomic operations, multi-threading, and bounds-
checked functions. It also makes some portions of the existing C99 library optional, and improves
compatibility with C++. The standard macro __STDC_VERSION__ is defined as 201112L to indicate
that C11 support is available.

Embedded C
Main article: Embedded C
Historically, embedded C programming requires nonstandard extensions to the C language in order
to support exotic features such as fixed-point arithmetic, multiple distinct memory banks, and basic
I/O operations.
In 2008, the C Standards Committee published a technical report extending the C language[21] to
address these issues by providing a common standard for all implementations to adhere to. It
includes a number of features not available in normal C, such as fixed-point arithmetic, named
address spaces, and basic I/O hardware addressing.
Syntax
Main article: C syntax
C has a formal grammar specified by the C standard.[22] Line endings are generally not significant in
C; however, line boundaries do have significance during the preprocessing phase. Comments may
appear either between the delimiters /* and */ , or (since C99) following // until the end of the
line. Comments delimited by /* and */ do not nest, and these sequences of characters are not
interpreted as comment delimiters if they appear inside string or character literals.[23]
C source files contain declarations and function definitions. Function definitions, in turn, contain
declarations and statements. Declarations either define new types using keywords such
as struct , union , and enum , or assign types to and perhaps reserve storage for new variables,
usually by writing the type followed by the variable name. Keywords such as char and int specify
built-in types. Sections of code are enclosed in braces ( { and } , sometimes called "curly brackets")
to limit the scope of declarations and to act as a single statement for control structures.
As an imperative language, C uses statements to specify actions. The most common statement is
an expression statement, consisting of an expression to be evaluated, followed by a semicolon; as a
side effect of the evaluation, functions may be called and variables may be assigned new values. To
modify the normal sequential execution of statements, C provides several control-flow statements
identified by reserved keywords. Structured programming is supported by if (- else ) conditional
execution and by do - while , while , and for iterative execution (looping). The for statement
has separate initialization, testing, and reinitialization expressions, any or all of which can be
omitted. break and continue can be used to leave the innermost enclosing loop statement or skip
to its reinitialization. There is also a non-structured goto statement which branches directly to the
designated label within the function. switch selects a case to be executed based on the value of
an integer expression.
Expressions can use a variety of built-in operators and may contain function calls. The order in
which arguments to functions and operands to most operators are evaluated is unspecified. The
evaluations may even be interleaved. However, all side effects (including storage to variables) will
occur before the next "sequence point"; sequence points include the end of each expression
statement, and the entry to and return from each function call. Sequence points also occur during
evaluation of expressions containing certain operators ( && , || , ?: and the comma operator). This
permits a high degree of object code optimization by the compiler, but requires C programmers to
take more care to obtain reliable results than is needed for other programming languages.
Kernighan and Ritchie say in the Introduction of The C Programming Language: "C, like any other
language, has its blemishes. Some of the operators have the wrong precedence; some parts of the
syntax could be better."[24] The C standard did not attempt to correct many of these blemishes,
because of the impact of such changes on already existing software.

Character set
The basic C source character set includes the following characters:

 Lowercase and uppercase letters of ISO Basic Latin Alphabet: a – z A – Z

 Decimal digits: 0 – 9
 Graphic characters: ! " # % & ' ( ) * + , - . / : ; < = > ? [ \ ] ^ _ { | } ~
 Whitespace characters: space, horizontal tab, vertical tab, form feed, newline
Newline indicates the end of a text line; it need not correspond to an actual single character,
although for convenience C treats it as one.
Additional multi-byte encoded characters may be used in string literals, but they are not
entirely portable. The latest C standard (C11) allows multi-national Unicode characters to be
embedded portably within C source text by using \uXXXX or \UXXXXXXXX encoding (where
the X denotes a hexadecimal character), although this feature is not yet widely implemented.
The basic C execution character set contains the same characters, along with representations
for alert, backspace, and carriage return. Run-time support for extended character sets has
increased with each revision of the C standard.

Reserved words
C89 has 32 reserved words, also known as keywords, which are the words that cannot be used for
any purposes other than those for which they are predefined:
auto double i
break else l
case enum r
char extern r
const float s
continue for s
default goto s
do if s

C99 reserved five more words:

_Bool _Imaginary r
_Complex inline

C11 reserved seven more words:[25]

_Alignas _Atomic _
_Alignof _Generic _

Most of the recently reserved words begin with an underscore followed by a capital letter, because
identifiers of that form were previously reserved by the C standard for use only by implementations.
Since existing program source code should not have been using these identifiers, it would not be
affected when C implementations started supporting these extensions to the programming language.
Some standard headers do define more convenient synonyms for underscored identifiers. The
language previously included a reserved word called entry , but this was seldom implemented, and
has now been removed as a reserved word.[26]

Operators
Main article: Operators in C and C++

C supports a rich set of operators, which are symbols used within an expression to specify the
manipulations to be performed while evaluating that expression. C has operators for:

 arithmetic: + , - , * , / , %
 assignment: =
 augmented assignment: += , -= , *= , /= , %= , &= , |= , ^= , <<= , >>=
 bitwise logic: ~ , & , | , ^
 bitwise shifts: << , >>
 boolean logic: ! , && , ||
 conditional evaluation: ? :
 equality testing: == , !=
 calling functions: ( )
 increment and decrement: ++ , --
 member selection: . , ->
 object size: sizeof
 order relations: < , <= , > , >=
 reference and dereference: & , * , [ ]
 sequencing: ,
 subexpression grouping: ( )
 type conversion: (typename)
C uses the operator = (used in mathematics to express equality) to indicate assignment, following
the precedent of Fortran and PL/I, but unlike ALGOL and its derivatives. C uses the operator == to
test for equality. The similarity between these two operators (assignment and equality) may result in
the accidental use of one in place of the other, and in many cases, the mistake does not produce an
error message (although some compilers produce warnings). For example, the conditional
expression if(a==b+1) might mistakenly be written as if(a=b+1) , which will be evaluated as
true if a is not zero after the assignment.[27]
The C operator precedence is not always intuitive. For example, the operator == binds more tightly
than (is executed prior to) the operators & (bitwise AND) and | (bitwise OR) in expressions such
as x & 1 == 0 , which must be written as (x & 1) == 0 if that is the coder's intent.[28]

"Hello, world" example

The "hello, world" example, which appeared in the first edition of K&R, has become the model for an
introductory program in most programming textbooks, regardless of programming language. The
program prints "hello, world" to the standard output, which is usually a terminal or screen display.
The original version was:[29]

main()
{
printf("hello, world\n");
}

A standard-conforming "hello, world" program is:[a]

#include <stdio.h>
int main(void)
{
printf("hello, world\n");
}

The first line of the program contains a preprocessing directive, indicated by #include . This
causes the compiler to replace that line with the entire text of the stdio.h standard header, which
contains declarations for standard input and output functions such as printf . The angle brackets
surrounding stdio.h indicate that stdio.h is located using a search strategy that prefers headers
provided with the compiler to other headers having the same name, as opposed to double quotes
which typically include local or project-specific header files.
The next line indicates that a function named main is being defined. The main function serves a
special purpose in C programs; the run-time environment calls the main function to begin program
execution. The type specifier int indicates that the value that is returned to the invoker (in this case
the run-time environment) as a result of evaluating the main function, is an integer. The
keyword void as a parameter list indicates that this function takes no arguments.[b]
The opening curly brace indicates the beginning of the definition of the main function.
The next line calls (diverts execution to) a function named printf , which in this case is supplied
from a system library. In this call, the printf function is passed (provided with) a single argument,
the address of the first character in the string literal "hello, world\n" . The string literal is an
unnamed array with elements of type char , set up automatically by the compiler with a final 0-
valued character to mark the end of the array ( printf needs to know this). The \n is an escape
sequence that C translates to a newlinecharacter, which on output signifies the end of the current
line. The return value of the printf function is of type int , but it is silently discarded since it is not
used. (A more careful program might test the return value to determine whether or not
the printf function succeeded.) The semicolon ; terminates the statement.
The closing curly brace indicates the end of the code for the main function. According to the C99
specification and newer, the main function, unlike any other function, will implicitly return a value
of 0 upon reaching the } that terminates the function. (Formerly an explicit return 0; statement
was required.) This is interpreted by the run-time system as an exit code indicating successful
execution.[30]
https://en.wikipedia.org/wiki/C_(programming_language)
A Brief History of C
C is a general-purpose language which has been closely associated with the UNIX operating
system for which it was developed - since the system and most of the programs that run it are
written in C.

Many of the important ideas of C stem from the language BCPL, developed by Martin Richards.
The influence of BCPL on C proceeded indirectly through the language B, which was written by
Ken Thompson in 1970 at Bell Labs, for the first UNIX system on a DEC PDP-7. BCPL and B are
"type less" languages whereas C provides a variety of data types.

In 1972 Dennis Ritchie at Bell Labs writes C and in 1978 the publication of The C Programming
Language by Kernighan & Ritchie caused a revolution in the computing world.

In 1983, the American National Standards Institute (ANSI) established a committee to provide a
modern, comprehensive definition of C. The resulting definition, the ANSI standard, or "ANSI C",
was completed late 1988.

A Rough Guide to Programming Languages is available on-line for those of you that are
interested.

https://www.le.ac.uk/users/rjm1/cotter/page_06.htm