C – Sujets divers

Plusieurs prétendent que quiconque ne sait pas programmer en C, au moins lorsque le besoin s'en fait sentir, ne sait pas vraiment programmer du tout.

Cette position, bien qu'un peu dogmatique, n'est pas totalement fausse : C demande que l'on comprenne quelque peu la machine sous-jacente, et offre une gamme réduite de mécanismes polyvalents (dont les pointeurs, qui sont un peu une abstraction de la mémoire vive) permettant de réaliser des programmes rapides, compacts, mais aussi risqués pour qui ne programme pas avec une discipline de fer.

Bien que j'aie beaucoup utilisé C dans ma carrière (surtout avant de commencer à enseigner), je travaille beaucoup moins avec ce langage aujourd'hui, ce qui explique qu'il y ait moins de ressources dans cette section que dans celle portant sur C++ par exemple.

Les documents suivants sont à votre disposition. Sachez toutefois que chacun présume que vous savez déjà programmer en C, et vise à faciliter votre approfondissement d'un sujet en particulier.

Pour une page portant spécifiquement sur le préprocesseur, voir : preprocesseur.html
Pour une page portant sur ce qu'on en commun C et C++, voir : commun_c_cplusplus.html
Pour une page portant sur les fonctions Lippincott, voir : fonctions_lippincott.html

Considérations d'ordre général

Un Wiki sur ce langage : http://en.wikipedia.org/wiki/C_programming_language
Excellente référence pour C et C++ : http://en.cppreference.com/w/Main_Page
Autres références en ligne :
- http://en.cppreference.com/w/c
- http://www.cprogramming.com/
La grammaire de C :
- http://farm1.static.flickr.com/81/281055530_30418f49b3_o.jpg
- texte de 2011 par Eli Bendersky sur la grammaire sensible au contexte de ce langage : http://eli.thegreenplace.net/2011/05/02/the-context-sensitivity-of-c%E2%80%99s-grammar-revisited/
Un Cheat Sheet proposé par Ashlyn Black en 2015 : http://www.cheatography.com/ashlyn-black/cheat-sheets/c-language/
Introduction au langage C, avec plusieurs exemples : http://www.geekboots.com/c/intro
Les dix commandements du programmeur C : http://www.lysator.liu.se/c/ten-commandments.html
Un gros (1616 pages!) PDF sur le standard C99 : http://homepage.ntlworld.com/dmjones/cbook1_0a.pdf
Un livre complet en-ligne sur le langage : http://www.phy.duke.edu/~rgb/General/c_book/c_book/index.html
Une autre, plus concis : http://cslibrary.stanford.edu/101/EssentialC.pdf
Une référence sur la bibliothèque standard du langage C : http://www.acm.uiuc.edu/webmonkeys/book/c_guide/
Un manuel sur la pratique de C, le C Craft : http://crypto.stanford.edu/~blynn/c/index.html
Un livre en ligne, Modern C, par Jens Gustedt en 2016 : https://gustedt.wordpress.com/2016/11/25/modern-c-is-now-feature-complete/
Réponses aux exercices du livre The C Programming Language de Brian W. Kernighan et Dennis M. Ritchie :
- http://users.powernet.co.uk/eton/kandr2/
- c'est vrai qu'il est bon, ce livre : http://reprog.wordpress.com/2010/04/06/programming-books-part-4-the-c-programming-language/
Questions pièges sur C (et un petit peu sur C++) :
- http://www.slideshare.net/olvemaudal/deep-c
- http://www.cs.berkeley.edu/~necula/cil/cil016.html
- connaissez-vous vraiment C? Un petit quiz par Dmitri Gribenko en 2015 : http://kukuruku.co/hub/programming/i-do-not-know-c
- qui a dit que C est un langage simple? http://www.eecs.berkeley.edu/~necula/cil/cil016.html
Apprendre C à l'aide du débogueur gdb :
- texte d'Alan O'Donnell en 2012 : https://www.hackerschool.com/blog/5-learning-c-with-gdb
- texte de David Albert en 2012 : https://www.hackerschool.com/blog/7-understanding-c-by-learning-assembly
Apprendre C à partir du code source de projets à code ouvert, un texte de 2014 : http://www.codergears.com/Blog/?p=163
Apprendre C, une introduction s'adressant au programmeur de haut niveau (exemples comparatifs en Ruby) : http://charliethe.ninja/slideshow/introtoc.html#1
Réapprendre C en 2013, un texte de Patrick Reagan : http://viget.com/extend/why-i-chose-to-learn-c
La « descente » dans C, par Simon Tatham en 2013; une explication sommaire de ce langage destinée aux gens qui n'ont d'expérience qu'avec des langages plus récents : http://www.chiark.greenend.org.uk/~sgtatham/cdescent/
Quinn Rohlf, en 2014, recommande d'apprendre C avant d'apprendre la programmation au sens large : http://qrohlf.com/posts/learn-to-code-then-learn-cs/
Considérations de saine programmation avec C, par Ben Trask : https://github.com/btrask/stronglink/blob/master/SUBSTANCE.md

À propos de la standardisation du langage

À propos du plus récent standard de C, soit C17 :
- version presque finale : http://www.open-std.org/jtc1/sc22/wg14/www/abq/c17_updated_proposed_fdis.pdf
La version précédente (et plus connue) de C est C11. À ce sujet :
- http://en.wikipedia.org/wiki/C11_%28C_standard_revision%29
- survol de C11 proposé par Thomas Plum, en 2012 : http://drdobbs.com/cpp/232800444
- http://www.drdobbs.com/cpp/232901670

survol proposé par Danny Kalev en 2012 : http://blog.smartbear.com/software-quality/bid/173187/C11-A-New-C-Standard-Aiming-at-Safer-Programming

Le standard C99 (un PDF de 552 pages) : http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf
Documentation officielle sur la standardisation du langage C :
Comment procède la standardisation du langage C : http://www.ibm.com/developerworks/library/pa-spec3.html
Difficile d'obtenir d'une entreprise un meilleur support pour C99, du moins de l'avis de Joshua Haberman en 2012 : http://blog.reverberate.org/2012/03/02/microsoft-please-support-at-least-a-tiny-bit-of-c99/

Idées et opinions

Les « vrais hommes » programment en C, apparemment : http://www.embedded.com/columns/barrcode/218600142?printable=true
Dans la même veine, du moins pour ce qui est du titre, un anti « Apprendre C en 14 jours », nommé Learn C The Hard Way : http://learncodethehardway.org/
Selon David Griffiths, en 2012, il demeure sain d'apprendre à programmer en C : http://radar.oreilly.com/2012/06/why-learn-c.html
Remarques de Rob Pike sur la programmation (en fait, sur la programmatique) en C : http://www.lysator.liu.se/c/pikestyle.html
Questions programmatiques : http://www.oualline.com/style/index.html
Le langage C serait en danger, et il en serait de même pour les autres langages de haut niveau : http://jakob.engbloms.se/archives/1131?owa_from=feed&owa_sid=
Euh... (voir la liste des auteurs...) http://www.bobhobbs.com/files/kr_lovecraft.html
Comment être plus rapide que C? Une réflexion de Andreas Zwinkau en 2012 : http://beza1e1.tuxen.de/articles/faster_than_C.html
À propos du plaisir de programmer en C, par Anders Pearson en 2012 : http://thraxil.org/users/anders/posts/2011/04/17/A-Boggling-Return-to-C/
Pourquoi programme-t-on encore (et toujours?) en C?
- texte de 2012 : http://mortoray.com/2012/06/11/whats-to-love-about-c/
- position d'Andrew Binstock en 2012 : http://www.drdobbs.com/cpp/why-code-in-c-anymore/240149452
- texte d'Anthony J Bonkoski en 2013 : http://jabsoft.io/2013/08/29/why-c-still-matters-in-2013-a-simple-example/
- texte de 2015 par Wil Shipley, qui relate l'histoire d'un programmeur qui n'aurait jamais appris à programmer en C (attention, il y a une chute amusante vers la fin) : https://medium.com/@wilshipley/the-absolutely-true-story-of-a-real-programmer-who-never-learned-c-210e43a1498b
En 2012, un texte rappelant que C, au fond, c'est pas si mal que ça : http://blog.808inorganic.com/2012/06/how-do-i-get-c-namespaces-how-do-i-get.html
Dans ce texte de 2012, Yossi Kreinin propose d'utiliser C en tant que langage intermédiaire pour certaines tâches : http://www.yosefk.com/blog/c-as-an-intermediate-language.html
En 2013, Damien Katz décrit ce qu'il qualifie d'« efficacité déraisonnable » de C : http://damienkatz.net/2013/01/the_unreasonable_effectiveness_of_c.html (la suite sur http://damienkatz.net/2013/01/follow_up_to_the_unreasonable.html par le même auteur)
En 2014, Sanjeev Radhakrishnan recommande d'utiliser Chrome comme Runtime pour vos programmes C : https://www.mobilespan.com/content/chrome-is-the-new-c-runtime
Dans ce texte de 2013, David Jones relate son expérience lorsqu'il a décidé de compiler un programme C dont les sources étaient vieilles de plus de trente ans : http://drj11.wordpress.com/2013/09/01/on-compiling-34-year-old-c-code/
En 2014, David Bolton s'interroge quant à la pertinence de C au XXI^e siècle : http://news.dice.com/2014/12/08/c-still-relevant-21st-century/
Est-ce que C est un bon « premier langage »? Opinion d'Evan Miller en 2015 : http://lifehacker.com/the-case-for-learning-c-as-your-first-programming-langu-1682070792
Selon Daniel Angel Muñoz Trejo en 2015, c'est encore sur des programmes écrits en code C que fonctionne le monde entier : http://www.toptal.com/c/after-all-these-years-the-world-is-still-powered-by-c-programming
En 2016, Matt Stancliff a écrit un texte nommé How to C in 2016 : https://matt.sh/howto-c
- toujours en 2016, réplique de Ken Thompson (pas « le » Ken Thompson, toutefois) : https://github.com/Keith-S-Thompson/how-to-c-response
Jonathan Whiting explique pourquoi il écrit des jeux en C : http://jonathanwhiting.com/writing/blog/games_in_c/
Texte de 2015 par Tim Hentenaar, qui critique l'approche préconisée par Zed A. Shaw dans Learn C the Hard Way : http://hentenaar.com/dont-learn-c-the-wrong-way
- réplique de Zed A. Shaw, en 2015 : http://hentenaar.com/dont-learn-c-the-wrong-way#update

Considérations d'ordre historique

L'histoire de C, qui explique certaines des décisions de design de ce langage, relatée par Dennis Ritchie lui-même : https://www.bell-labs.com/usr/dmr/www/chist.html
Article de 1983 décrivant les nouveautés (à l'époque) de C, par Bruce Roberts : https://archive.org/stream/byte-magazine-1983-08/1983_08_BYTE_08-08_The_C_Language#page/n47/mode/2up
En 2014, Charlez Petzold relate son « infâme » programme Hello World pour Windows : http://www.charlespetzold.com/blog/2014/12/The-Infamous-Windows-Hello-World-Program.html
À l'origine, C était-il un langage de Hipster? Opinion de Tim Kellogg en 2015 : http://timkellogg.me/blog/2015/02/08/history-of-C/
En 2015, Olve Maudal s'interroge à savoir si Bell Laboratories aurait cherché à cacher le fait que C aurait été conçu à partir de BCPL : http://olvemaudal.com/2015/06/17/did-bell-labs-initially-try-to-hide-that-c-was-based-on-bcpl/
Coup d'oeil en 2014 sur ce qu'était C au tout début : https://spin0r.wordpress.com/2014/11/21/kr-c/
Pourquoi les règles des glissements de bits sont ce qu'elles sont en C, selon Dennis Ritchie en 2002 : https://yarchive.net/comp/c_shifts.html, et selon John Mashey en 1998 : https://yarchive.net/comp/shift_instruction.html

Technique

Développement de logiciel à code ouvert avec C99 : http://www.ibm.com/developerworks/linux/library/l-c99.html
Proposition d'extension au langage C, nommée Cforall : http://plg.uwaterloo.ca/~cforall/
Est-ce que C est si « performant » que ça? http://scienceblogs.com/goodmath/2006/11/the_c_is_efficient_language_fa.php
À propos de printf() :
- http://brainwagon.org/2009/05/16/learning-something-about-printf-of-all-things/
- http://hostilefork.com/2010/03/14/where-the-printf-rubber-meets-the-road/
- portabilité et les formats des entiers : http://www.pixelbeat.org/programming/gcc/int_types/
- comment cette fonction est-elle implémentée? Texte de 2015 : http://blog.hostilefork.com/where-printf-rubber-meets-road/
Chaînes de caractères avec le langage C :
- bestiaire des principales fonctions de manipulation de chaînes de caractères du langage C, répertoriées par Jonas 'Sortie' Termansen : http://maxsi.org/coding/c-string-creation.html
- à propos de strcpy() :
  - http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=547
- à propos de strncpy() :
  - http://blog.liw.fi/posts/strncpy/
Un graffiti : http://www.boingboing.net/2009/10/09/c-graffiti.html
À propos des tableaux :
- un tableau est-il équivalent à un pointeur sur son 1^er élément? Presque, selon Eli Bendersky en 2009 : http://eli.thegreenplace.net/2009/10/21/are-pointers-and-arrays-equivalent-in-c/
- trouver la taille d'un tableau sans avoir recours à sizeof, texte d'Arjun Sreedharan en 2013 : http://arjunsreedharan.org/post/69303442896/the-difference-between-arr-and-arr-how-to-find-size
- que faire avec les tableaux qui se chevauchent? Texte de John Jarboe en 2014 : http://blog.coverity.com/2014/01/29/working-overlapping-buffers-c/
- calculer la taille d'un tableau, par Arjun Sreedharan en 2013 : http://arjunsreedharan.org/post/69303442896/the-difference-between-arr-and-arr-how-to-find-size
Particularités syntaxiques :
- parfois, la syntaxe de C peut sembler étrange, comme le rappelle Robert Elder en 2015 : http://blog.robertelder.org/weird-c-syntax/
- exprimer en mots des déclarations complexes du langage C?
  - http://www.cdecl.org/ (obtenu à travers http://ridiculousfish.com/blog/archives/2009/11/12/cdecl/)
  - http://ieng9.ucsd.edu/~cs30x/rt_lt.rule.html
Un dialecte de C se voulant sécuritaire : le Fail-Safe C : https://staff.aist.go.jp/y.oiwa/FailSafeC/index-en.html
À propos du mot clé restrict : http://developers.sun.com/solaris/articles/cc_restrict.html et http://cellperformance.beyond3d.com/articles/2006/05/demystifying-the-restrict-keyword.html
Le langage C, la récursivité, et... Cthulhu : http://www.bobhobbs.com/files/kr_lovecraft.html
C est, selon certains, un langage fonctionnel : Paradigmes-programmation--Liens.html#programation_fonctionnelle_langage_C
Utiliser C comme un langage OO : Paradigmes-programmation--Liens.html#poo_langage_C
Le langage C n'est pas un langage d'assemblage...
- http://james-iry.blogspot.com/2010/04/c-is-not-assembly.html
- http://james-iry.blogspot.com/2010/09/moron-why-c-is-not-assembly.html
Comment le code C est traduit en langage d'assemblage : http://www.avabodh.com/cin/introduction.html
Quelques bizarreries : http://www.danielvik.com/2010/05/c-language-quirks.html
Trop charmant pour ne pas le mentionner : http://groups.google.com/group/comp.lang.c/msg/e105e5d339edec01?pli=1
Écrire des coroutines en C : http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
C ne supporte pas les exceptions. Toutefois, voir ../Sujets/Developpement/Exceptions.html#avec_c
Tests unitaires en C : http://cutest.sourceforge.net/
Abuser du compilateur C : http://wingolog.org/archives/2010/09/07/abusing-the-c-compiler
Article du Code Project expliquant comment simuler le polymorphisme et l'héritage avec C : http://www.codeproject.com/KB/cpp/InheritancePolymorphismC.aspx
Micro manuel pour Lisp implémenté en C : http://nakkaya.com/2010/08/24/a-micro-manual-for-lisp-implemented-in-c/
écrire des extensions pour C en Python : http://code.mixpanel.com/building-c-extensions-in-python/
Quelques remarques sur le design de bibliothèques pour C, par Rusty Russell en 2010 : http://rusty.ozlabs.org/?p=140
Considération d'alignement et de padding : http://themotherbrain.posterous.com/c-struct-and-padding
Une archive de bouts de code C pertinents : http://ccan.ozlabs.org/
Comparatif de compilateurs sous Linux : http://www.phoronix.com/scan.php?page=article&item=linux_compiler_deathmatch&num=1
http://www.pragprog.com/magazines/2011-03/punk-rock-languages
Faire interagir C et Go : http://blog.golang.org/2011/03/c-go-cgo.html
Détails internes au langage C : http://www.avabodh.com/cin/cin.html
Représenter des List Comprehensions en C? http://benlynn.blogspot.com/2011/04/list-comprehensions-in-c.html
Une série intéressante sur l'internationalisation en C :
- http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=327
- http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=328
- http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=329
- http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=330
- http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=331
- http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=340
Des λ en C? http://walfield.org/blog/2010/08/25/lambdas-in-c.html
Programmation de sockets avec C99 : http://gustedt.wordpress.com/2011/10/24/socket-programming-and-c99/
Diverses fonctions pour copier des chaînes de caractères du langage C, donc des chaînes ASCIIZ, répertoriées en un même lieu : http://byuu.org/articles/programming/strcpycat
Programmation générique en C, par Randy Gaul en 2012 : http://cecilsunkure.blogspot.ca/2012/08/generic-programming-in-c.html
Implémenter un tableau dynamique en C, par Najaf Ali en 2012 : http://happybearsoftware.com/implementing-a-dynamic-array.html
C et les fonctions inline, texte de Fabien Le Mentec en 2013 : http://www.embeddedrelated.com/showarticle/172.php?articleid=172
Placer des données en mémoire Flash avec C, un texte de 2013 : http://www.coactionos.com/embedded-design/101-understanding-memory-usage-in-c.html
Écrire une « fonction partielle », un peu comme on voit des classes partielles en C#, mais en C. Texte de Leandro Pereira en 2013 : http://tia.mat.br/blog/html/2013/07/20/partial_functions_in_c.html
Initialisation composite, par Nick Desaulniers en 2013 : http://nickdesaulniers.github.io/blog/2013/07/25/designated-initialization-with-pointers-in-c/
Bogue amusant qui permettait (erronément) d'examiner si un entier pouvait représenter un NaN, décrit par ce texte de 2013 : http://blogs.freebsdish.org/theraven/2013/08/17/c-ints-are-finite-numbers/
Comment mal utiliser les typedef, texte de 2013 : http://almostvalid.blogspot.ca/2013/11/screw-your-stupid-typedefs.html
Utilité d'un struct muni d'un seul membre, texte de John Van Enk en 2014 : http://spin.atomicobject.com/2014/03/25/c-single-member-structs/
La sélective en C, texte de 2013 : http://www.comp-psyche.com/2013/11/switch-statement.html
Écrire du code C portable, texte de 2008 : http://www.ski-epic.com/source_code_essays/ten_rules_for_writing_cross_platform_c_source_code.html
Les opérateurs du langage C : http://wisegeek.in/programming/c-operators/
Implémenter des modules en C99, texte de 2014 : http://snaipe.me/c/modules-in-c99/
Cacher de l'information dans un pointeur, par Arjun Sreedharan en 2014 : http://arjunsreedharan.org/post/105266490272/hide-data-inside-pointers
Dans ce texte de 2014, Chris Wellons propose une approche pour rendre le développement de programmes C plus interactif : http://nullprogram.com/blog/2014/12/23/
Dix trucs de programmation avec C99, colligés par Guillaume Chereau en 2015 : http://blog.noctua-software.com/c-tricks.html
À propos des coûts inhérents au Runtime de C, un texte de Ryan Hileman en 2015 : http://ryanhileman.info/posts/lib43
Écrire des canaux tels que ceux de Go, mais en C, un texte de 2012 : http://devcry.heiho.net/2012/07/go-channels-in-good-old-c.html?m=1
De la métaprogrammation en C à l'aide de structures de contrôle « maison », un texte de 2012 par Simon Tatham : http://www.chiark.greenend.org.uk/~sgtatham/mp/
Implémenter une machine virtuelle en langage C, par Felix Angell en 2015 : http://blog.felixangell.com/virtual-machine-in-c/
Exécuter du code C de manière Type-Safe sur une JVM, article de Matthias Grimmer et al en 2015 : http://chrisseaton.com/plas15/safec.pdf
Écrire des programmes C qui soient « échelonnables » (Scalable), un livre en ligne par Pieter Hintjens : https://www.gitbook.com/book/hintjens/scalable-c/details

Perles et perversions

Le langage C a la réputation de permettre d'exprimer des perles de beauté... et des perversions de la pire espèce.

Un interpréteur brainfuck en deux lignes de code C : http://j.mearie.org/post/1181041789/brainfuck-interpreter-in-2-lines-of-c
Un logo animé de Yahoo! en mode texte, le tout en six lignes de code : http://a1k0n.net/2011/06/26/obfuscated-c-yahoo-logo.html
De chiffres en « mots prononçables » en 243 bytes de code C : http://j.mearie.org/post/7462182919/spelt-number-to-decimal
L'erreur d'un seul byte la plus coûteuse de l'histoire de l'informatique? Une opinion (discutable mais intéressante) de Poul-Henning Kamp, en 2011 : http://queue.acm.org/detail.cfm?id=2010365
Quelques côtés obscurs de C, mis en relief par Rob Kendrick en 2013 : https://docs.google.com/presentation/d/1h49gY3TSiayLMXYmRMaAEMl05FaJ-Z6jDOWOz3EsqqQ/preview?usp=sharing&pli=1&sle=true#slide=id.p
Quelques choses que peu de gens savent sur ce langage : http://www.locklessinc.com/articles/obscurec/
Le plus petit programme C possible qui puisse planter? Une proposition de Jesper Öqvist en 2013 : http://llbit.se/?p=1744
Que dire de ceci? http://codepad.org/ngiITeZ4

Questions de sécurité :

Réflexion de 2008 par Laurence Tratt, qui se demande pourquoi les programmes C, malgré toutes les critiques qu'on peut adresser à ce langage, sont en pratique aussi fiables qu'ils le sont (mais admet que pour atteindre ce seuil de fiabilité, il faut y investir temps et efforts) : http://tratt.net/laurie/blog/entries/how_can_c_programs_be_so_reliable
Texte de Jens Gustedt en 2013 à propos de l'annexe K du standard C11, portant sur le comportement lors de violations de préconditions à l'appel de fonctions réputées sécurisées (avec suffixe _s) : http://gustedt.wordpress.com/2013/02/04/runtime-constraint-violations/
Quel support architectural serait requis pour en arriver à une machine abstraite C qui serait Memory-Safe? Article de David Chisnall et de plusieurs autres co-auteurs, en 2015 : http://www.cl.cam.ac.uk/~dc552/papers/asplos15-memory-safe-c.pdf
Tester les conversions de pointeurs pour provoquer des avertissements dans les cas les plus suspects, une technique proposée par Pascal Cuoq en 2015 : http://trust-in-soft.com/compile-time-consistency-checks-for-types-in-c/

Critiques

Pour celles et ceux qui se demandent si la programmation C peut être aussi perverse que certain(e)s le prétendent... http://notanumber.net/archives/54/underhanded-c-the-leaky-redaction
La pire erreur dans le design du langage C est...? http://dobbscodetalk.com/index.php?option=com_myblog&show=Cs-Biggest-Mistake.html&Itemid=29
Des mauvais tours à jouer à une programmeuse ou à un programmeur C, selon John Regehr : http://blog.regehr.org/archives/574
Selon Poul-Hennings en 2011, le standard C ANSI évolue mal : https://www.varnish-cache.org/docs/trunk/phk/thetoolsweworkwith.html
De l'avis de Miloslav Trmač en 2005, la partie la plus laide du standard C99 est l'en-tête <tgmath.h>, destiné à faciliter la mgration de logiciel numérique Fortran vers C : http://carolina.mff.cuni.cz/~trmac/blog/2005/the-ugliest-c-feature-tgmathh/
En 2015, Jon Evans crie « mort à C! » : http://techcrunch.com/2015/05/02/and-c-plus-plus-too/
Message de Chris Lattner en 2015, qui décrit C comme un langage qui pose certains obstacles à l'optimisation : http://article.gmane.org/gmane.comp.compilers.llvm.devel/87749
Selon Walter Bright en 2009, la plus grave erreur de C est de confondre les pointeurs et les tableaux : http://www.drdobbs.com/architecture-and-design/cs-biggest-mistake/228701625
John Regehr, en 2015, explique ce qu'il considère être le problème avec le dialecte Friendly C : http://blog.regehr.org/archives/1287

Bibliothèques et outils

picoc, un tout petit interpréteur C : http://code.google.com/p/picoc/
Quelques ressources pour programmeurs C : http://www.mycplus.com/featured-articles/top-ten-c-language-resources/
Un tout petit compilateur C : http://en.wikipedia.org/wiki/Tiny_C_Compiler
Une bibliothèque d'acteurs en langage C : http://chrismoos.com/2009/10/28/libactor-a-c-library-based-on-the-actor-model/
Une archive de code C : http://ccodearchive.net/
La bibliothèque Safe-C : http://chat-webcam-samuro.com/safe-c/start-en.html