A reading list containing books that were fundamental in my life/career.

Book reviews also sometimes appear in my blog.


Code/exercises based on some of these books can be found here.


Refactoring: Improving the Design of Existing Code, Martin Fowler

An introduction to the extremely effective combination of Test Driven Development and systematic code editing procedures. This book thoroughly describes how to structure code for robustness and how to change and evolve it while maintaining its integrity and guaranteeing no regressions are introduced.

I had the luck of finding a copy in my university's library and reading it in my first few semesters there: it shaped how I write and edit code from the beginning.


The Design of the UNIX Operating System, Maurice J. Bach

A detailed, low-level analysis of the implementation of operating systems with examples from the early versions of Unix. Each subsystem is described, from the hardware to the user programs: algorithms and data structures are presented, with a generous amount of diagrams and C code.

A reference for programmers writing system code and a guide for those interacting with it, this book is indispensable for anyone working with Unix, the most influential operating system in history, or any of its descendants.


Structure and Interpretation of Computer Programs, Harold Abelson, Gerald Jay Sussman, Julie Sussman

Undoubtedly the best introductory programming book for Compute Science courses. Lisp and the rich collection of problems and exercises presented throughout the book will fundamentally transform how a programmer views and reasons about code and computation in general, even for those who program in different languages and paradigms.

The full accompanying course is also available on MIT's OpenCourseWare's Youtube channel.


Test Driven Development for Embedded C, James W. Grenning

A very good introduction to Test Driven Development with an emphasis on systems programming for embedded devices. Always in a very practical manner, sample programs of progressive complexity — from simple unit tests to black-box integration tests involving several components — are presented along with techniques to address the challenges inherent in designing software for constrained hardware platforms.


Effective Modern C++, Scott Meyers

The latest revision of the mandatory reading series for C++ programmers. Each new revision of the language (a steady process every three years now, since C++11) has introduced powerful and expressive constructs, always building on top of previous ones. The Effective series presents these new concepts in a pragmatic way with copious code examples and is considered a reference for best practices and guidelines among C++ programmers.


Programming in Lua, Roberto Ierusalimschy

A programming guide for this extremely elegant language. Lua is unique in many aspects of its design, not least of which is its simplicity. Very few — but powerful — language constructs underlie the implementation of concepts found in most programming languages.

This book presents common programming topics from the idiosyncratic point of view of Lua and will teach all that is necessary for someone interested in using it either directly or as an auxiliary scripting language in a larger program.


The Linux Programming Interface, Michael Kerrisk.

A comprehensive and detailed exposition of the entire API of the Linux kernel. An enormous tome written by the maintainer of the kernel manual pages, walking through every conceivable component of Linux with historical references, comparisons to other operating systems in the Unix family, code samples, and in-depth descriptions.

Also doubles as an intimidating artefact to be displayed on one's desk (I have this one autographed =)


Heterogeneous Computing with OpenCL, Benedict Gaster, Lee Howes, David R. Kaeli, Perhaad Mistry, Dana Schaa

A detailed introduction to programming for heterogeneous devices, this book presents the OpenCL language along with its C API. Additionally, each component is contextualized with discussions of traditional architectures for CPUs, GPUs, FPGAs, and other devices and several case studies, with accompanying source code examples.