Schedule
Labs
Assignments
TA office hours
Topic videos
Some course notes
Extra problems
Lecture recordings
Many people like this book. It seems to be at just the right level for a second-year introduction to the C programming language. I've spent a lot of time with this book (especially the first edition) and have not noticed any technical errors, which I think makes it unique for a book about C not written by a unix or C insider.
I think that this is my preferred book for the systems-programming part of CSC 209 (although also see Kerrisk, below). It's got most of what we're covering in that regard and it seems to be clear, and as far as I can recall I think I've only noticed one substantial error in it so far.
(I'm not considering this to be a "required" textbook for the course this term.)
This book is definitely not gentle or fluffy. But it still has an introductory or tutorial structure. It is targetted at people with a good understanding of computer programming in general, but no knowledge of C or unix.(The second edition covers material added to the C programming language in the 1989 ANSI C standard (also published as ISO C 1990), but not material added to the C programming language in the subsequent 1999 ISO C standard. This might not matter to you at all; at least I think it doesn't matter very much or very immediately. However, the first edition doesn't include the 1989 ANSI C revisions, some of which were substantial. I don't think you'll want to use the first edition.)
I'm undecided whether to specify this or the Haviland et al book as the official unix textbook for this course, which is why I usually list them both on the course information sheet.Basically, this book is very long. You'll find just about everything in there, but it's a bit too much to read all of it, which is the real reason I hesitate to list this as the primary unix textbook for CSC 209.
I do have a negative reaction to this book's having "linux" in the title — everything we talk about in this course, and indeed almost everything in this textbook, applies equally to unix and linux; the technical differences between them are small. This is not just about one word of the title — throughout the book he refers specifically to linux, or specifically to the GNU C library, thus deemphasizing portability, which I think is an important topic. But not necessarily something you are concerned with in your initial explorations of systems programming.
This book focuses primarily on programming in C, but also has assorted examples from Java and other programming languages where those languages can illustrate particular points better. The book discusses software tools. It's not entirely 209-relevant but it's a very good addition to yer bookshelf.Chapter 1 on "style" issues is quite relevant to this course. It also includes some material on commenting you might find useful.
In some ways this book resembles an update of Kernighan and Plaugher's The Elements of Programming Style (which I think is an amazing book, but is unfortunately completely inaccessible to most modern programmers because it is so heavy on the details of some very old programming languages).
This book has chapters about shell programming, unix system programming, the C programming language, troff/nroff, and the data-processing unix tools (sort/join/comm/uniq/etc). Amazingly, he somehow manages to cover almost all you need to know as an introduction to each of these topics. It is not written as a textbook, and you will find it rather intense (obviously, given the scope of its coverage). Yes, this is the "Bourne" as in "the Bourne shell".
In-depth information on a variety of unix system programming topics. The most-cited reference for tricky TCP / socket programming matters. Well beyond the scope of this course, but I think it's still worth a mention in this textbook list. If in the future you're looking for a more in-depth book about various unix system programming topics, you should consider the Stevens book.
We're getting farther away from CSC 209 matters here, but this is a really neat book which attempts to teach a large swath of a basic first- and second-year curriculum, entirely from the bottom up. Thus it starts with CSC 258ish material, and then uses the computer which is developed in the first bit to show how the C programming language could be implemented, and teaches C, and some first-year programming concepts such as recursion.This is not a very 209-relevant book, but actually it doesn't fit any course in our curriculum because it's based on a rather different curriculum structure (and the book's use at the authors' university involved a curriculum restructuring). You might find this book particularly helpful in understanding an OS-implementation lecture near the end dealing with interrupts, but that's just a tiny note in CSC 209. You also might find this book interesting in its discussion of how C relates to the low-level machine, to the extent that this isn't obvious after completing CSC 258 plus doing C in CSC 209.