Development of C

                                      Development of C 

 

qualifiers

standardization process did not change the character of the language. In particular, the C standard

did not attempt to specify formally the language semantics, and so there can be dispute over fine

points; nevertheless, it successfully accounted for changes in usage since the original description,

and is sufficiently precise to base implementations on it.

Thus the core C language escaped nearly unscathed from the standardization process, and

the Standard emerged more as a better, careful codification than a new invention. More important

changes took place in the language’s surroundings: the preprocessor and the library. The preprocessor

performs macro substitution, using conventions distinct from the rest of the language. Its

interaction with the compiler had never been welldescribed,

and X3J11 attempted to remedy the

situation. The result is noticeably better than the explanation in the first edition of K&R; besides

being more comprehensive, it provides operations, like token concatenation, previously available

only by accidents of implementation.

X3J11 correctly believed that a full and careful description of a standard C library was as

important as its work on the language itself. The C language itself does not provide for inputoutput

or any other interaction with the outside world, and thus depends on a set of standard procedures.

At the time of publication of K&R, C was thought of mainly as the system programming

language of Unix; although we provided examples of library routines intended to be readily

transportable to other operating systems, underlying support from Unix was implicitly understood.

Thus, the X3J11 committee spent much of its time designing and documenting a set of

library routines required to be available in all conforming implementations.

By the rules of the standards process, the current activity of the X3J11 committee is confined

to issuing interpretations on the existing standard. However, an informal group originally

convened by Rex Jaeschke as NCEG (Numerical C Extensions Group) has been officially

accepted as subgroup X3J11.1, and they continue to consider extensions to C. As the name

implies, many of these possible extensions are intended to make the language more suitable for

numerical use: for example, multidimensional

arrays whose bounds are dynamically determined,

incorporation of facilities for dealing with IEEE arithmetic, and making the language more effective

on machines with vector or other advanced architectural features. Not all the possible extensions

are specifically numerical; they include a notation for structure literals.

const and volatile, and slightly different type promotion rules. Nevertheless, the

Successors

C and even B have several direct descendants, though they do not rival Pascal in generating

progeny. One side branch developed early. When Steve Johnson visited the University of Waterloo

on sabbatical in 1972, he brought B with him. It became popular on the Honeywell machines

there, and later spawned Eh and Zed (the Canadian answers to ‘what follows B?’). When Johnson

returned to Bell Labs in 1973, he was disconcerted to find that the language whose seeds he

brought to Canada had evolved back home; even his own

by Alan Snyder.

More recent descendants of C proper include Concurrent C [Gehani 89], Objective C [Cox

86], C* [Thinking 90], and especially C++ [Stroustrup 86]. The language is also widely used as

an intermediate representation (essentially, as a portable assembly language) for a wide variety of

compilers, both for direct descendents like C++, and independent languages like Modula 3 [Nelson

91] and Eiffel [Meyer 88].

yacc program had been rewritten in C,

Critique

Two ideas are most characteristic of C among languages of its class: the relationship

between arrays and pointers, and the way in which declaration syntax mimics expression syntax.

They are also among its most frequently criticized features, and often serve as stumbling blocks

to the beginner. In both cases, historical accidents or mistakes have exacerbated their difficulty.

The most important of these has been the tolerance of C compilers to errors in type. As should be

clear from the history above, C evolved from typeless languages. It did not suddenly appear to its

earliest users and developers as an entirely new language with its own rules; instead we