Hubbry Logo
The C Programming LanguageThe C Programming LanguageMain
Open search
The C Programming Language
Community hub
The C Programming Language
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
The C Programming Language
The C Programming Language
The C Programming Language
View on Wikipedia
from Wikipedia

Key Information

This article is part of a series on the
C programming language
The logo of C programming language


































































































See also

The C Programming Language (sometimes termed K&R, after its authors' initials) is a computer programming book written by Brian Kernighan and Dennis Ritchie, the latter of whom originally designed and implemented the C programming language, as well as co-designed the Unix operating system with which development of the language was closely intertwined. The book was central to the development and popularization of C and is still widely read and used today[when?]. Because the book was co-authored by the original language designer, and because the first edition of the book served for many years as the de facto standard for the language, the book was regarded by many to be the authoritative reference on C.[1][2]

History

[edit]

C was created by Dennis Ritchie at Bell Labs in the early 1970s as an augmented version of Ken Thompson's B.[3] Another Bell Labs employee, Brian Kernighan, had written the first C tutorial,[4] and he persuaded Ritchie to coauthor a book on the language.[5] Kernighan would write most of the book's "expository" material, and Ritchie's reference manual became its appendices.

The first edition, published February 22, 1978, was the first widely available book on the C programming language. Its version of C is sometimes termed K&R C (after the book's authors), often to distinguish this early version from the later version of C standardized as ANSI C.[6]

In April 1988, the second edition of the book was published, updated to cover the changes to the language resulting from the then-new ANSI C standard, particularly with the inclusion of reference material on standard libraries. The second edition of the book (and as of 2024, the most recent) has since been translated into over 20 languages.[7] In 2012, an eBook version of the second edition was published in ePub, Mobi, and PDF formats.[8]

C was first standardized in 1989 (as ANSI X3.159-1989) and has since undergone several revisions. However, no new edition of The C Programming Language has been issued to cover the more recent standards.

Reception

[edit]

Byte magazine stated in August 1983, "[The C Programming Language] is the definitive work on the C language. Don't read any further until you have this book!"[1] Jerry Pournelle wrote in the magazine that year that the book "is still the standard ... a bit terse". He continued, "You can learn the C language without getting Kernighan and Ritchie, but that's doing it the hard way. You're also working too hard if you make it the only book on C that you buy."[9]

Influence

[edit]

The C Programming Language has often been cited as a model for technical writing, with reviewers describing it as having clear presentation and concise treatment. Examples generally consist of complete programs of the type one is likely to encounter in daily use of the language, with an emphasis on system programming. Its authors wrote,

We have tried to retain the brevity of the first edition. C is not a big language, and it is not well served by a big book. We have improved the exposition of critical features, such as pointers, that are central to C programming. We have refined the original examples, and have added new examples in several chapters. For instance, the treatment of complicated declarations is augmented by programs that convert declarations into words and vice versa. As before, all examples have been tested directly from the text, which is in machine-readable form.

— preface to the second edition[10]

"Hello, World!" program by Brian Kernighan (1978)

The book introduced the "Hello, World!" program, which prints only the text "hello, world" as an illustration of a minimal working C program. Since then, many texts have followed that convention for introducing a programming language.

Before the advent of ANSI C, the first edition of the text served as the de facto standard of the language for writers of C compilers. With the standardization of ANSI C, the authors more consciously wrote the second edition for programmers rather than compiler writers, writing,

Appendix A, the reference manual, is not the standard, but our attempt to convey the essentials of the standard in a smaller space. It is meant for easy comprehension by programmers, but not as a definition for compiler writers—that role properly belongs to the standard itself. Appendix B is a summary of the facilities of the standard library. It too is meant for reference by programmers, not implementers. Appendix C is a concise summary of the changes from the original version.

— preface to the second edition[10]

The influence of The C Programming Language on programmers, a generation of whom first worked with C in universities and industry, has led many to accept the authors' programming style and conventions as recommended practice, if not normative practice. For example, the coding and formatting style of the programs presented in both editions of the book is often referred to as "K&R style" and became the coding style used by convention in the source code for the Unix and Linux kernels.

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

The C Programming Language

View on Grokipedia
from Grokipedia
The C Programming Language is a foundational textbook on the C programming language, co-authored by Brian W. Kernighan and Dennis M. Ritchie and first published in 1978 by Prentice Hall. The book offers a concise tutorial introduction to programming in ANSI C, assuming some elementary prior knowledge, while also functioning as a comprehensive reference for the language's syntax, features, and best practices. Developed amid the language's evolution at Bell Labs for Unix system implementation, the first edition captured C's core design as a general-purpose, efficient tool for systems programming. The second edition, released in 1988, updated the content to align with the ANSI X3.159-1989 standard, incorporating formalized definitions of C's constructs and removing ambiguities from earlier implementations. Renowned for its clarity, brevity, and practical examples—including algorithms, data structures, and code snippets—this work has sold over two million copies and been translated into more than 20 languages, establishing it as the definitive guide that shaped generations of programmers and the widespread adoption of C.

Overview

Characteristics

The C programming language is a procedural and imperative programming paradigm that emphasizes structured programming through the use of functions, loops, and conditional statements to organize code into clear, modular blocks. This approach allows developers to express algorithms in a step-by-step manner, facilitating efficient problem-solving while maintaining readability and maintainability. A defining feature of C is its provision of low-level access to memory and hardware via pointers, which act as variables storing memory addresses and enable direct manipulation of data without built-in runtime bounds or type checks. This capability makes C particularly suited for systems programming, where fine-grained control over resources is essential, though it requires programmers to manage memory explicitly to avoid errors like buffer overflows. As a compiled language, C translates source code into efficient machine code through a compiler, resulting in executables that run with minimal overhead and superior performance compared to interpreted languages, which execute code line-by-line at runtime. C employs static typing, where variable types are determined and checked at compile time, but features weak type checking that permits implicit conversions and explicit casts between types, such as assigning an integer to a pointer. Developed at Bell Labs in the early 1970s specifically for implementing the Unix operating system, C has profoundly influenced low-level programming domains, including the development of operating system kernels like Unix and Linux, as well as embedded systems where resource constraints demand compact and performant code. Its portability across hardware platforms stems from this systems-oriented design, enabling the same codebase to be recompiled for diverse environments. The language's simplicity is exemplified by its canonical "Hello, World!" program, which demonstrates core elements like header inclusion, function definition, and output:

c

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

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

This concise structure highlights C's economy of expression, requiring only a few lines to produce executable output while introducing fundamental syntax.

Design Philosophy

The design of the C programming language embodies a philosophy centered on simplicity and minimalism, aiming to provide a compact set of features that enable efficient and portable systems programming without unnecessary complexity. This approach results in a language that is "not a big language," as described in its foundational documentation, prioritizing clarity and ease of implementation over expansive constructs. By limiting built-in safety mechanisms, such as automatic bounds checking or garbage collection, C adopts a "trust the programmer" ethos, placing responsibility on developers for memory management and type safety to avoid runtime overhead and bloat. This deliberate restraint fosters a lightweight compiler-translatable structure, suitable for resource-constrained environments like early Unix systems. A core goal of C's design is portability, allowing code to compile and run across diverse hardware architectures with minimal modifications. This principle evolved to support Unix implementations on platforms ranging from the PDP-11 to the VAX, emphasizing machine-independent abstractions while retaining low-level access. C strikes a balance between high-level abstractions, such as functions and structured control flow, and low-level operations like bitwise manipulation and pointer arithmetic, enabling programmers to express algorithms fluently without sacrificing performance. Explicit memory management via manual allocation and deallocation, rather than automated collection, underscores this balance, granting fine-grained control essential for systems-level efficiency. By design, C eschews object-oriented features, remaining a procedural language focused on direct hardware interaction and modularity through functions, which aligns with its origins in displacing assembly code. Dennis Ritchie described C as evolving from typeless predecessors like B to include structured types for greater power and efficiency, while being efficient enough to displace assembly language and sufficiently abstracted from machine details to achieve portability and describe algorithms across environments. This philosophy retains the core tenet that "programmers know what they are doing," promoting flexibility over enforced safeguards.

History

Origins and Development

The origins of the C programming language, as documented in The C Programming Language, trace back to its development at Bell Laboratories starting in 1972, where Dennis Ritchie created it as a successor to Ken Thompson's B language, developed in 1969–1970 for the PDP-7 computer as part of the early Unix project. Ritchie initially worked on the PDP-11 minicomputer, extending B by introducing explicit data types such as int and char, unifying arrays and pointers, and establishing a more structured type system to support the growing needs of Unix system programming. This evolution marked the formal naming of the language as C, reflecting its position as the next step after B in the lineage from BCPL. As co-author of the book, Ritchie drew on these developments to provide a tutorial and reference that captured C's design principles. C drew significant influences from earlier languages, particularly Martin Richards's BCPL for its typeless design, array-pointer semantics, and concise syntax, as well as ALGOL 68 for ideas on type composition and declaration syntax. Unlike its predecessors, early C emphasized portability and efficiency for systems programming, though initial implementations in 1972 lacked advanced features such as unions, which were added later in the development process between 1973 and 1980. By summer 1973, Ritchie and Thompson had rewritten the entire Unix kernel in C on the PDP-11, replacing much of the previous assembly code and demonstrating the language's viability for operating system implementation. Key milestones in C's early evolution included the introduction of structs in 1972 as part of the core type system, enabling intuitive memory mapping for complex data; this feature was absent in B but became central to C's structured programming capabilities. Around 1973, dynamic memory management functions like malloc and free were incorporated into the standard library to support more flexible allocation, with further refinements appearing by 1975 in the first formal reference manual. The first edition of The C Programming Language, published in 1978 by Prentice Hall and co-authored by Brian Kernighan and Ritchie, provided the language's first comprehensive description, standardizing the syntax and semantics of what became known as "K&R C" and serving as the definitive reference for early adopters.

Standardization Efforts

The standardization of C, which the book helped popularize and later aligned with, began in 1983 when the American National Standards Institute (ANSI) established the X3J11 technical committee to develop a formal standard, aiming to codify existing practices—including those outlined in the first edition of The C Programming Language—and promote portability across implementations. Chaired by Jim Brodie, the committee's efforts culminated in the publication of ANSI X3.159-1989, commonly known as ANSI C or C89, in December 1989. This standard introduced features such as function prototypes, the void type, and qualifiers like const and volatile to enhance type safety and expressiveness. The second edition of The C Programming Language, released in 1988, was updated to reflect the emerging ANSI standard (based on drafts approved that year), incorporating these formalized definitions and removing ambiguities from K&R C. In 1990, the International Organization for Standardization (ISO) adopted the ANSI standard unchanged as ISO/IEC 9899:1990, referred to as C90, under the Joint Technical Committee 1 (JTC1), Subcommittee 22 (SC22), Working Group 14 (WG14). The standardization process continued with major revisions by WG14. The C99 standard (ISO/IEC 9899:1999), published in November 1999, represented a significant evolution, adding support for inline functions to optimize performance by embedding code at call sites, complex number types via the _Complex keyword and <complex.h> header for numerical computations, variable-length arrays for runtime-sized allocations within blocks, and a _Bool type with <stdbool.h> for clearer logical expressions. These changes were motivated by the need to incorporate lessons from C++ and address limitations in numerical and flexible programming, while the committee, chaired by Rex Jaeschke, emphasized compatibility with existing code. A key rationale for C99 was improved internationalization, including universal character names for non-ASCII identifiers, enhanced multibyte and wide-character support through headers like <wchar.h> and <wctype.h>, and locale-specific formatting in <locale.h> to handle diverse cultural conventions such as decimal separators and date formats. Subsequent updates focused on concurrency, safety, and refinements. The C11 standard (ISO/IEC 9899:2011), published in 2011, introduced atomic operations via the _Atomic qualifier and <stdatomic.h> for lock-free thread-safe access to shared data, basic multithreading support with <threads.h>, and the _Generic keyword for type-generic expressions that select behavior based on argument types at compile time. These additions addressed the growing demand for concurrent programming in systems software without relying on platform-specific libraries. The C17 standard (ISO/IEC 9899:2017), released in June 2018, was primarily a maintenance release correcting defects and ambiguities from C11, with no new language features. The most recent revision, C23 (ISO/IEC 9899:2024), ratified in 2024 and published in October 2024, standardized attributes like [[nodiscard]] for compiler hints on unused return values, introduced bit-precise integer types in <stdbit.h> for portable low-level bit manipulation (e.g., count leading zeros), and added keywords such as bool, true, and false as built-ins rather than macros. Overall, WG14's efforts have balanced innovation with backward compatibility, ensuring C's evolution supports modern hardware and global software needs, a progression reflected in the enduring relevance of The C Programming Language as a foundational text.

Influence and Legacy

The book The C Programming Language has left an indelible mark on computer science education and the propagation of C, serving as the authoritative reference that introduced the language to millions. Its first edition in 1978 codified the K&R dialect, which became the de facto standard for C implementations until the ANSI standardization, while the 1988 second edition incorporated the ANSI C specification, helping to unify the language's syntax and semantics across platforms. Widely adopted in universities and professional training, the book—affectionately known as K&R—has trained generations of programmers, contributing directly to C's dominance in systems programming and its influence on subsequent technologies.

Impact on Other Languages

The C programming language, as elucidated in the book, has profoundly shaped the design of subsequent languages through direct extensions and indirect syntactic and conceptual borrowings. Direct derivatives include C++, developed by Bjarne Stroustrup at Bell Labs in 1983 as "C with Classes" and first released in 1985, which extends C with object-oriented features like classes, inheritance, and polymorphism while maintaining full backward compatibility with C code. Objective-C, introduced in 1984 by Brad Cox and Tom Love at Stepstone, builds on C by adding Smalltalk-style dynamic messaging and object-oriented capabilities, serving primarily as a superset for developing graphical user interfaces and later becoming central to Apple's Cocoa framework. Similarly, C#, unveiled by Microsoft in 2000, draws its syntactic foundation from the C family, incorporating C-like control structures and operators but adding managed memory, type safety, and .NET integration for modern application development. Indirectly, C's influence permeates the syntax and paradigms of many contemporary languages, particularly through its widespread adoption of curly braces for block delimitation and semicolons for statement termination. Java, designed in the mid-1990s by James Gosling at Sun Microsystems, adopts C's lexical structure and expression syntax to ensure familiarity for C programmers, while simplifying object models and eliminating low-level pointers to enhance portability across platforms. The Go programming language, created at Google in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson, intentionally mirrors C's procedural style and uses similar block structures and keywords to facilitate adoption by systems programmers, though it introduces garbage collection and concurrency primitives to address C's limitations. Rust, developed by Mozilla starting in 2006, inherits C's memory management concepts but innovates with an ownership and borrowing system to provide memory safety without a garbage collector, positioning itself as a safer alternative for systems programming. C's role in Unix development further extended its reach, as many core Unix tools written in C—such as utilities for file manipulation and process control—inspired the scripting paradigms of shells like the C shell (csh), introduced in 1978 by Bill Joy, which emulates C's syntax for control flow and variables to appeal to C-proficient developers. In embedded systems, C's efficiency influenced dialects like the one used in Arduino, which employs a simplified C++ subset since 2005, allowing direct hardware access while abstracting low-level details for prototyping interactive devices. These influences underscore C's enduring legacy as a foundational blueprint for both high-performance systems and accessible abstractions in later languages, amplified by the pedagogical impact of Kernighan and Ritchie's text.

Modern Relevance and Criticisms

Despite its age, C—as detailed in the book—continues to play a pivotal role in contemporary software development, particularly in domains requiring low-level control, high performance, and direct hardware interaction. It is extensively used in system programming for developing operating system kernels, such as the Linux kernel, which powers a significant portion of servers, embedded systems, and mobile devices worldwide, as well as drivers, compilers, and network protocols. In embedded development, C is employed in applications including smart home devices, drones, automotive electronics, medical devices, and industrial control systems, leveraging its efficiency for managing limited resources and enabling real-time operations. In scientific computing, C underpins critical libraries such as the GNU Scientific Library (GSL), enabling high-performance numerical computations in fields like physics and engineering. Similarly, C is utilized in high-performance software, including game engines, graphics rendering, high-frequency trading systems, and database internals. C also finds application in security and reverse engineering, where it is used for malware analysis, developing antivirus programs, and examining digital exploits. According to the TIOBE Programming Community Index, C ranked second among programming languages as of November 2025, underscoring its enduring popularity in professional and academic settings. C serves as a foundational language for learning others, such as C++, Rust, and Go, due to its influence on their syntax, control structures, and low-level concepts. Additionally, it is commonly employed in algorithm competitions for implementing efficient data structures and algorithms, aiding in competitive programming and interview preparation. In game development, C remains relevant for performance-intensive components, with frameworks like raylib providing a lightweight foundation for 2D and 3D games written directly in C, facilitating cross-platform portability without the overhead of higher-level abstractions. This usage highlights C's strength in embedded and real-time systems, where its minimal runtime and predictable behavior are unmatched, even as higher-level languages handle user interfaces and scripting. Criticisms of C center on its inherent vulnerabilities stemming from manual resource management and limited built-in safeguards. The lack of automatic bounds checking on arrays and pointers frequently results in buffer overflows, allowing attackers to overwrite memory and execute arbitrary code; a notorious example is the Heartbleed vulnerability (CVE-2014-0160) in OpenSSL, caused by a buffer over-read in its C implementation that exposed private keys and sensitive data across millions of servers. Manual memory allocation via functions like malloc and free often leads to leaks, dangling pointers, and use-after-free errors, contributing to instability in long-running applications. Security analyses reveal that memory safety issues in C account for approximately 70% of severe vulnerabilities reported by organizations like Microsoft and Google. Furthermore, until the C23 standard, C lacked a native module system, forcing developers to rely on header files and macros for code organization, which exacerbates maintenance challenges in large projects. Efforts to mitigate these shortcomings include extensions like Checked C, a Microsoft Research project that adds checked pointers and bounds-safe interfaces to existing C codebases, enabling gradual adoption of spatial safety without full rewrites. Meanwhile, modern alternatives such as Rust address C's safety gaps by enforcing memory safety through its borrow checker at compile time, offering comparable performance for systems programming while reducing common errors; this has led to increasing adoption in kernels and embedded software.

References

  1. https://www.pearson.com/en-us/subject-catalog/p/Kernighan-C-Programming-Language-2nd-Edition/P200000000368
  2. https://www.nokia.com/bell-labs/about/dennis-m-ritchie/chist.html
  3. https://www.amacad.org/person/brian-w-kernighan
  4. https://www.tutorialspoint.com/cprogramming/c_overview.htm
  5. https://www.ibm.com/docs/en/zos-basic-skills?topic=zos-compiled-versus-interpreted-languages
  6. https://www.cs.cornell.edu/courses/cs412/2007sp/lectures/lec13.pdf
  7. https://courses.cs.washington.edu/courses/cse341/13wi/lec18slides.pdf
  8. https://www.cs.emory.edu/~cheung/Courses/255/Syllabus/1-C-intro/Docs/C-book.pdf
  9. https://www.cimat.mx/ciencia_para_jovenes/bachillerato/libros/%5BKernighan-Ritchie%5DThe_C_Programming_Language.pdf
  10. https://www.bell-labs.com/usr/dmr/www/chist.html
  11. http://brent.hailpern.com/wp-content/uploads/2020/02/p671-ritchie.pdf
  12. https://blog.ansi.org/ansi/origin-ansi-c-iso-c/
  13. http://jclt.iecc.com/Jct11.pdf
  14. https://gcc.gnu.org/onlinedocs/gcc/Standards.html
  15. https://www.open-std.org/jtc1/sc22/wg14/www/standards
  16. https://www.open-std.org/jtc1/sc22/wg14/www/C99RationaleV5.10.pdf
  17. https://www.open-std.org/jtc1/sc22/wg14/www/charter
  18. https://en.cppreference.com/w/c/language/history
  19. https://www.open-std.org/jtc1/sc22/wg14/
  20. https://www.geeksforgeeks.org/c/history-and-application-of-c/
  21. https://www.stroustrup.com/bs_faq.html
  22. https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html
  23. https://dl.acm.org/doi/10.1145/3386332
  24. https://dotnet.microsoft.com/en-us/languages
  25. https://docs.oracle.com/javase/specs/jls/se16/jls16.pdf
  26. https://talks.golang.org/2012/splash.article
  27. https://doc.rust-lang.org/reference/influences.html
  28. https://www.oreilly.com/library/view/learning-the-bash/1565923472/ch01s03.html
  29. https://docs.arduino.cc/language-reference/
  30. https://techvidvan.com/tutorials/applications-of-c-language/
  31. https://www.codechef.com/blogs/real-world-uses-of-c-language
  32. https://flatironschool.com/blog/the-best-programming-languages-for-cybersecurity-in-2025/
  33. https://www.tiobe.com/tiobe-index/
  34. https://www.heartbleed.com/
  35. https://www.ibm.com/think/news/memory-safe-programming-languages-security-bugs
  36. https://www.nsa.gov/Press-Room/News-Highlights/Article/Article/3215760/nsa-releases-guidance-on-how-to-protect-against-software-memory-safety-issues/
  37. https://lemire.me/blog/2024/01/21/c23-a-slightly-better-c/
  38. https://www.microsoft.com/en-us/research/project/checked-c/
  39. https://www.microsoft.com/en-us/msrc/blog/2019/07/why-rust-for-safe-systems-programming
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.