Table of Contents for Programming Languages: a survey

C

Because it is so well-known and well-liked, C gets its own chapter.

Perhaps the most successful language ever.

"Think of C as sort of a plain-spoken grandfather who grew up trapping beavers and served in several wars but can still do 50 pullups."

Some people consider it as a thin portable layer over assembly. However this view is disputed (e.g. https://news.ycombinator.com/item?id=6415240 ). One clear difference between C and assembly is that C is in the structured programming paradigm, and does not provide 'GOTO' (it does provide a facility called 'longjmp' but this is limited to jumps into functions for which there is still a valid stack frame; in addition some commentators assert that longjmp is often not implemented correctly in various C implementations (todo cite)).

One thing that C provides that assembly language often does not is a choice of conventions for string and multidimensional array representation.

Attributes:

• Low-level

Pros:

• Portable. Some commentators speculate that, of early low-level languages, C is relatively easy to write a compiler for; therefore it has been ported almost everywhere: http://www.dreamsongs.com/RiseOfWorseIsBetter.html

Cons:

• Preprocessor macros can make interop hard (cite https://news.ycombinator.com/item?id=6273739 )

Tutorials:

• http://blog.regehr.org/archives/1393
• http://www.chiark.greenend.org.uk/~sgtatham/cdescent/ (partial tutorial)
• http://learnxinyminutes.com/docs/c/
• http://charliethe.ninja/slideshow/introtoc.html
  • correction: https://news.ycombinator.com/item?id=9636463
• visualizer: http://dev.pointers.io/#filename=test4.c
• C FAQ
• http://en.cppreference.com/w/c
• C for Python programmers. Unfinished; has not gotten to structs or pointers yet.
• http://beej.us/guide/bgc/
• http://home.netcom.com/%7Etjensen/ptr/pointers.htm
• http://ieng9.ucsd.edu/~cs30x/rt_lt.rule.html
• https://github.com/EbookFoundation/free-programming-books/blob/master/free-programming-books.md#c
• http://crasseux.com/books/ctutorial/
• http://cslibrary.stanford.edu/101/EssentialC.pdf
• https://modernc.gforge.inria.fr/
• https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628
• https://www.chiark.greenend.org.uk/~sgtatham/cdescent/
  • discussion: https://www.chiark.greenend.org.uk/~sgtatham/cdescent/
• https://en.wikipedia.org/wiki/Setjmp.h
• https://craftofcoding.wordpress.com/2022/06/30/arrays-are-not-pointers/
  • https://lobste.rs/s/5bdhrf/arrays_are_not_pointers
• https://learn-c.org/

Best practices and recommended libraries etc:

• https://www.securecoding.cert.org/confluence/display/c/SEI+CERT+C+Coding+Standard
• gcc -fanalyzer: https://developers.redhat.com/blog/2020/03/26/static-analysis-in-gcc-10#diagnostic_paths
  • discussion (also discusses D's ownership system): https://news.ycombinator.com/item?id=22711391
• "For strings in C nothing beats SDS by antirez" [1]
• https://tmewett.com/c-tips/
  • https://lobste.rs/s/h5qjlp/everything_i_wish_i_knew_when_learning_c
• https://people.kernel.org/kees/bounded-flexible-arrays-in-c
• (not a widespread "best practice", just one guy's style, but interesting:) https://nullprogram.com/blog/2023/10/08/
  • discussion: https://lobste.rs/s/o5wcea/my_personal_c_coding_style_as_late_2023

Respected exemplar code:

• Redis -- [2] [3] [4] [5] [6] [7] [8] [9]
• SQLite [10] [11] [12] [13] [14] but see [15] and [16]
• tarsnap [17] [18] (see also [19]) [20]
• Lua; see this guide to which parts to read first: http://www.reddit.com/comments/63hth/ask_reddit_which_oss_codebases_out_there_are_so/c02pxbp [21] [22] [23] [24]
  • and then maybe LuaJIT? [25] [26] [27] but see https://news.ycombinator.com/item?id=7602745
• Linux kernel [28] [29] [30] [31] [32] [33] [34]
• DJB's stuff eg qmail [35] [36] [37] [38]
• Plan 9 [39] [40] [41] [42] [43] [44]
• Nginx -- [45] [46] [47] [48]
• Git -- [49]
• GNOME GLib, GTK+ -- [50] (but see [51])
• OpenBSD? [52] [53] [54]
• FreeBSD? [55] [56]
• Niels Provos' code [57]
• Varnish [58]
• Tcl, except for the regexp files [59] [60]
• PostgreSQL? [61] [62] [63] [64] [65]
• Quake I or Quake II [66] (see also https://news.ycombinator.com/item?id=7602375 ) (but see https://www.reddit.com/r/programming/comments/26dyh/ask_reddit_whats_the_most_beautiful_piece_of/c26qad )
• https://viewsourcecode.org/snaptoken/
• https://news.ycombinator.com/item?id=24373524
• https://lobste.rs/s/sp606q/what_are_your_favorite_codebases_study

Books:

• The C Programming Language, written by Ritchie and Brian Kernighan (K&R) ("make sure you get the one with "ANSI" stamped on the cover...otherwise you'll learn archaic C")
• http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf
  • https://news.ycombinator.com/item?id=9018247
• http://c.learncodethehardway.org/book/
• Expert C Programming
• C: a reference manual
• The Standard C library
• https://news.ycombinator.com/item?id=22519876
• https://modernc.gforge.inria.fr/

Standards (drafts):

• C89/C90: http://port70.net/~nsz/c/c89/c89-draft.html
• C99 (N1256): http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf
• C11 (N1570): http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
• C17/C18 (N2176): https://web.archive.org/web/20181230041359if_/http://www.ope...
• https://stackoverflow.com/a/83763/3033
  • (thanks to Susam for these links [67] )

People: Dennis Ritchie

Popularity:

• Popular and beloved

Features:

• escape continuations (via setjmp/longjmp) [68]

Size:

• Compilers:
  • https://github.com/rui314/8cc (~9K LOC as of Feb 2015: no optimization, targets only x86-64) "intended to support all C11 language features while keeping the code as small and simple as possible."
  • PCC (Portable C Compiler) ~18000 LOC [69]
  • LCC ~20000 LOC [70]
  • TCC (Tiny C Compiler) ~30000-45000 LOC [71] [72] https://github.com/TinyCC/tinycc
• https://github.com/DoctorWkt/fbcc

Libraries:

• https://begriffs.com/posts/2019-01-19-inside-c-standard-lib.html

Misc:

• https://github.com/green7ea/cpp-compilation/blob/master/README.md
• https://www.bfilipek.com/2019/03/darker-cpp.html?m=1

Variants of C/variant implementations that are simpler, with small compilers:

• http://bellard.org/otcc/ (compiler fits in 2048 bytes of C source excluding the ';', '{', '}' and space characters; see also http://bellard.org/tcc/, a regular C compiler (tcc is ~45kloc [73]))
• https://github.com/rswier/c4 (~500 LOC; is still self-hosting; no structs; C in four functions)
  • https://github.com/rswier/c4/blob/master/c4.c
  • "It's written in a very limited dialect of C --- most notably, it doesn't use structs --- because it compiles itself. The expression parser in particular would be clearer with structs rather than array offsets. But once you realize that's why it's so gnarly in places, it's straightforward to mentally translate. It's a very simple design: a simple lexer with a "pull" API (next()) feeds a precedence-climbing expression parser that spits out bytecode for a simple stack machine. If you grok expr(), you grok the whole thing." -- https://news.ycombinator.com/item?id=9642831
  • the author also made an OS: https://github.com/rswier/swieros
  • see also https://github.com/rswier/swieros/blob/master/root/bin/c.c
• http://en.wikipedia.org/wiki/Small-C (~3000 LOC [74])
  • "an integer/character subset of the C language" -- "A Small-C Compiler" book, preface, [75]