C Interfaces and Implementations: Techniques for Creating Reusable Software (Addison-Wesley Professional Computing Series)

I don't normally leave reviews, but I cannot believe how good this book really is. I'm a power C++20 developer who recently has become fascinated with cross-language interoperability and as such have sought to build my own C runtime framework and utility library from scratch (libGimbal), influenced by GLib's GObject and Microsoft COM. I've personally implemented my own C17-based versions of C++'s containers, standard algorithms, multiple types of custom strings, custom allocators, and a meta type system providing uniform object representation across languages. I cannot believe the fact that this book is an almost complete, beautifully architected collection of what amounts to a general-purpose C framework and set of standard containers and algorithms, similar to C++'s STL. If you were to release the examples in the book as a framework, you'd have something similar to GNOME's GLib, which powers all of GTk and the GNOME stack. Is this book still relevant today? 100% absolutely. It's timeless. It should be a must-have for any C programmer--especially with the breadth of subjects it covers. There is pretty much something in here for every type of developer at every skill level. Even for a C++ developer, you can still learn a lot and "C++-itize" a lot of these data structures and concepts. His programming style is concise, easy to read, and unlike most C texts, is not an bunch of small, abstract, academic snippets. These are production-ready and useful in the real world. Also unlike a lot of the esteemed C classic texts, even though the book was written in '97, this feels like how modern C is written today. I only wish I had found this book sooner. I cannot recommend it enough.

A very good book also for the embedded field; you can't use much of the code in small 8bit microcontroller environments, but if you work with bigger 16/32bit microcontrollers many of the abstract data types (ADTs) described here can be useful. Maybe the "threads" interface can even be used as a base to develop a tiny cooperative embedded OS, too. The title of the book is not exactly true: this is not a generic text on "C interfaces an implementation", it's a complete and detailed documentation of a well-projected C user level generic library, implementing a lot of ADTs that are not available in the C standard library but are available in many other high(er?) level languages. You may like or not the semantic details and coding style, probably depending on your background: unix/linux programmers may not like it, as they may not like the ADTs prefix-verbosity... It's a way to add modularity to a not-object-oriented language as C is; the same for the "typedef struct T *T" (opaque pointers) in headers: modularity and encapsulation. Pseudocode notation (literate programming) is clear, as long as you read chapter 1.

This book has implementations for lots of C interfaces, and uses the literate programming style. Literate programming looks strange at first, but it is very easy to learn to read it. Once you get past that, this book is a swiss army knife of utilities that some of us have implemented from scratch a dozen times. This time someone took a lot of care and effort to implement small little libraries that have a big impact. If you're not interested in the implementation in the book, that's fine. I think the APIs presented can inspire people to design better software interfaces. And the concise style is something that we should all work harder to imitate. Most functions are only a half page of text in the book. And the literate programming means those functions are cross referenced and easy for the reader to find. Really just a joy to read.

Whatever method they used to create the ebook resulted in the ISBN and related content being repeated constantly throughout the pages which is incredibly annoying. Even if you get over that, the code formatting is completely broken. This is a shame and an effort should really be made to either fix this or stop selling it as an ebook.

This is the best book to read after learning the fundamentals of C programming. The patterns drilled into your head by Mr. Hanson (concealing implementation behind opaque pointers, documenting which runtime errors an implementation will check vs. which ones client code must guard against, ...) will make your C programs more robust, maintainable, and reusable. Can't recommend this book highly enough!!

Working in any business or industrial setting and you will need to write APIs. This book contains wonderful examples of many types of APIs for the unacquainted reader.

A number of years ago, I asked more experienced programmers about how to write larger programs in C and was recommended to read "C Interfaces and Implementations." I can definitely say I was not disappointed, as the book does a good job of showing how to structure a large code base. In fact, if you look at large, open source C code bases such as the Python interpreter or Quake 3 Arena, you will find a number of the principles at work. So, in that regard, the book does a fantastic job. The book also excels at showing how more advanced and/or less used parts of the language and standard library can augment the capabilities of your programs. The chapter on Exceptions using setjmp() and longjmp() is worth the price of entry alone. While especially dry, the multiple and extended precision arithmetic chapters also present a topic that is not found in many other places. If I had to point out one thing that drove me crazy during my reading, it would have to be the overuse of one- and two-letter variable names. While space is at a premium on the page, using names such as "dest" instead of "z" or "sign_of_x" instead of "sx" would have been more elucidating. I found myself losing track of which variable was which in functions that had as many as six one-letter variable names (I'm looking at you XP_div()!).

Easy to understand and apply. Will help you to understand the basic and advanced data structures used in every day coding and applications written in C. I used it to get a deeper understanding of all those Microsoft interview questions, and to provide succinct solutions in coding using pointer arithmetic.