Don't embarass me; don't embarass yourself: Some notes on thinking in C and Unix
Introduction, part 1: On the genesis of this work (Essay #175)
The genesis of this set of writing.
Introduction, part 2: Thinking in C (Essay #176)
What I mean by "thinking in C".
Introduction, part 3: Thinking in Unix (Essay #178)
What I mean by "thinking in Unix"
Introduction, part 4: Thinking like SamR Introduction, part 4: Thinking like SamR (or Some of SamR's perspectives on software development) (Essay #216)
Additional perspectives that underlie the rest of the course/book/essays.
Bash basics: files and directories (Essay #196)
A short introduction to what you should know about the shell, including a bit of information on files and directories. I hope that this is mostly review.
File permissions (Essay #246)
Who can read what you write, or write what you read?
Miscellaneous Unix Topics
grep and regular expressions (Essay #199)
Ways of representing patterns in text and a tool for using it.
Unix systems provide power by allowing you to combine programs in interesting ways. Here are some of them.
Searching files with
One way to find things
Searching files with
Another way to find things.
Command-line history (Essay #232)
Remembering what you did (or letting the computer remember for you).
Adventures of binary search
Adventures in binary search, part the first (Essay #219)
In which we set the stage.
In which we explore how to test our procedure.
In which we consider strategies.
Miscellaneous C Topics
Stages of C compilation (Essay #179)
What some of those stages are, and why you should know.
The C Preprocessor (Musing #268)
More information on an early stage.
An introduction to C macros (Musing #280)
Simple macros for testing C programs (Musing #283)
An application of macros, along with some further exploration of some macro design issues.
Using macros for generic structures in C (Musing #287)
Another application of macros: Writing generic structures that can hold a variety of values.
Additional compiler flags
C compiler flags you should know.
assert in C (Essay #180)
An awesomely useful macro.
Why function signatures matter (Essay #190)
If you don't tell the compiler what you're doing, it may give you different results than you expect.
Formatting C Code (Essay #197)
Why style counts and how to achieve it.
Output buffers (Essay #210)
printfdoesn't always do what you expect.
extern, and many more things you never knew you could (or should) use.
Parsing integers (Essay #185)
How to parse integers sensibly, as well as a variety of other reflections on program design.
Building C libraries (Essay #194)
Programmers know how to build their own libraries.
Designing a C library: Arbitrarily large integers (Essay #249)
Using C Libraries
Good programmers also know how to use libraries (and what libraries might be useful).
A simple C project (Essay #181)
An introduction to Make (Essay #183)
Basics of a build automation tool that we'll use throughout the course.
Variables in Make (Essay #187)
Why and how to use variables in Make.
Implicit rules in Make (Essay #188)
Making your Makefiles more general and more concise.
Standard Make targets (Essay #245)
Things you should expect to see in a typical Makefile (and to put in your own Makefiles).