Skip to main content

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 (or Some of SamR’s perspectives on software development) (Essay #216)

Additional perspectives that underlie the rest of the course/book/essays.

Bash Basics

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.

Combining programs

Unix systems provide power by allowing you to combine programs in interesting ways. Here are some of them.

Searching files with grep

One way to find things

Searching files with find

Another way to find things.

Command-line history (Essay #232)

Remembering what you did (or letting the computer remember for you).

Adventures in binary search, part the first (Essay #219)

In which we set the stage.

Adventures in binary search, part the second: Designing tests (Essay #220)

In which we explore how to test our procedure.

Adventures in binary search, part the third: Implementing binary search (Essay #221)

In which we consider strategies.

Miscellaneous C Topics

Preconditions for strcpy (Musing #1130)

Attempts to understand memory usage.

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)

More preprocessing!

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.

Using 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)

Why printf doesn’t always do what you expect.


static, 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)

An example

Using C Libraries

Good programmers also know how to use libraries (and what libraries might be useful).


A simple C project (Essay #181)

Thinking broadly.

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).