

Ask HN: Examples of especially well-written C code? - dlowe

In light of the recent OpenSSL rant (http://news.ycombinator.com/item?id=1680337): what are some open source projects written in C which are particularly well-written?<p>I can give one example: I was very pleasantly surprised by the experience of cold-reading the BerkeleyDB source (trying to explain some very odd observed behavior) a few years ago. The code was laid out in a sensible way, such that I could find what I needed reasonably quickly. It was generally clear and straightforward to read, and the few places with "tricky" code were very nicely commented -- including the source of the odd behavior I was hunting for.<p>Are there other examples of great, readable C code out there?
======
kqr2
I would recommend David R. Hanson's book _C Interfaces and Implementations_.
It is an extremely well documented library and shows you how to design APIs
properly.

[http://www.amazon.com/Interfaces-Implementations-
Techniques-...](http://www.amazon.com/Interfaces-Implementations-Techniques-
Creating-Reusable/dp/0201498413/)

~~~
nkurz
Based on the recommendations here, I just got this book by interlibrary loan.
I haven't read much of it yet, but I'm glad I didn't buy it sight unseen. It's
an understatement to say does not meet the expectations I had for it. Perhaps
one could develop a good course around it, and I'm sure there are good things
an experienced coder could gleam from it, but as a standalone text for a
beginner I think it would do more damage than good.

I thought at first that the code samples he was giving were examples of "what
not to do", and then was astonished to find him defending them in the text.
From page 36, after some horrendous code for Atom_int() page 35:

"When the conversion is done, s points to the desired string, and this string
has &str[43] - s characters. str has 43 characters, which is enough to hold
the decimal representation of any integer on any conceivable machine. Suppose,
for instance, that longs are 128 bits. The string representation of any
128-bit signed integer in octal - base 8 - fits in 128/3 + 1 = 43 characters.
The decimal representation can take no more digits than the octal
representation, so 43 characters are enough.

The 43 in the definition of str is an example of a 'magic number,' and it's
usually better style to define a symbolic name for such values to ensure that
the same value is used everywhere. Here, however, the value appears only once,
and sizeof is used whenever the value is used. Defining a symbolic name might
make the code easier to read, but it will also make the code longer and
clutter the name space. In this book, a symbolic name is defined only when the
value appears more than once, or when it is part of an interface."

I'm glad to see his priorities presented in such a clear manner. If you feel
that your current code is too readable at the expense of "name space clutter",
this might be a good book for you. But otherwise, just say no!

ps. In case this example didn't convince you, the following chapter on using
setjmp() and longjmp() to roll your own macros for exception handling might be
worth glancing at in the online version before you confirm your purchase.

------
nkurz
In the past, I've found the code for SQLite to be brilliantly clear:
<http://sqlite.org>

Going further, I'd suggest that most large successful projects in C have clear
code that is worthy of study. It's some corollary of the anthropic principle
--- if the code wasn't clear, it would never have survived to become
successful.

This may only apply to the core of these projects (written by experts) than to
the periphery (written by learners). But you might be surprised by how
readable the central code is for Apache, Linux, Glibc, Mysql, Perl, Python,
etc.

~~~
GeneralMaximus
I second SQLite. They even have the entire source concatenated into a single
file, which means you don't have to use ctags (or equivalent) for jumping
around the project.

------
tolini
Do you mean something like this?

    
    
                main(l
           ,a,n,d)char**a;{
       for(d=atoi(a[1])/10*80-
      atoi(a[2])/5-596;n="@NKA\
     CLCCGZAAQBEAADAFaISADJABBA^\
     SNLGAQABDAXIMBAACTBATAHDBAN\
     ZcEMMCCCCAAhEIJFAEAAABAfHJE\
     TBdFLDAANEfDNBPHdBcBBBEA_AL\
      H E L L O,    W O R L D! "
        [l++-3];)for(;n-->64;)
           putchar(!d+++33^
                l&1);}
    

(source: <http://www.ioccc.org/years.html#1992_westley>)

------
neopallium
The Lua interpreter (pure ANSI C), both the core VM and the public C API for
modules are well written. <http://www.lua.org/>

------
acqq
In most nontrivial projects, C is used to solve problems that are worse being
solved with other platforms: targeting the biggest possible platform
independence but caring about performance. So you can't compare the "beauty"
of something that is supposed to run on my 50 USD router with 32 MB with
something that has not much to do (measuring CPU and memory use) and has the
luxury to be compiled only by a few compilers.

Another problem is that a lot projects "grow" without any vision. Once you
understand that, you'll find that most of the successful C projects didn't
have much more choice, more because of the history of them than anything else.

However when you have the full control of the platform and have a small
numbers of the developers with a good taste (you control the OS and the
compiler too) you can maintain "beauty" consistently. In this regard, I
suggest you to enjoy Plan 9 sources!

[http://plan9.bell-
labs.com/wiki/plan9/Sources_repository/ind...](http://plan9.bell-
labs.com/wiki/plan9/Sources_repository/index.html)

------
cperciva
I've been told that the Tarsnap source code is particularly good. :-)

------
iampims
Redis is wonderfully well written.

<http://github.com/antirez/redis>

~~~
kevinmahaffey
I _love_ working with the redis codebase. In my opinion, redis is beautiful
for a few reasons.

It's written in an object-oriented style (i.e. structs are "objects", each C
file is a "class", and function prototypes are consistent for
constuctors/destructors/instance methods). Also, everything is modular in
redis (i.e. you can take the redis string or network library and use it in
another project without any problems).

I also like the fact that it's portable C (C99 IIRC) that just requires make
(no autoconfiguration necessary).

------
jmspring
I'm a fan of parts of the BSD kernel myself. My first exposure was through the
book "The Design and Implementation of the FreeBSD Operating System". Then
again, dorking around in kernels and the like hold some interest for me.

~~~
cperciva
_I'm a fan of parts of the BSD kernel myself._

I hope you don't mean that. The bits of original BSD which are still in the
FreeBSD tree are pretty ugly -- recent FreeBSD code is much better.

------
j_baker
Python's C code is pretty well written. Plus it can be useful to know about if
you actually write Python.

------
lzimm
i really liked the redis codebase. not sure if its changed much since it
became a much bigger project, but back when it was mainly @antirez, it was
some of the cleanest code i've ever read.

------
inf_variance
PostgreSQL and the Linux kernel sources make great reading materials.

