The University of Chicago
Department of Computer Science

CSPP 51025 Course Syllabus

Summer 2012

Practicum in Trading Systems Development



Unix Programming Links Home Page

Teaching staff:

Instructor:          Mark Shacklette
Office:                 Ryerson 154
Office Hours:     Thursday,  3:30-4:30 pm (by appointment only)
                            Thursday,  4:30-5:15 pm (drop in)

email:     mark at cs uchicago edu (read hourly or so)
               mshack at post harvard edu (read hourly or so)

NOTE:   ALL non-confidential email should be addressed to the list.  Go here to join the list (do this today!)

Lead TA:
 Mark Weindling
Email:
 mweindling at cs uchicago edu
Laboratory Hours:
 T.B.D.
Office Hours (Ryerson)
 T.B.D.

 
SUBJECT COURSE TITLE TIME Location
324 51025 Practicum in Trading Systems
Development
 Thursday, 5:30 pm - 8:20 PM
 Ryerson 277

I. TEXT AND MATERIALS
 

Texts: Required (get the latest (i.e., currently published) editions of the following)

The Linux Programming Interface: A Linux and UNIX System Programming Handbook, Michael Kerrisk, No Starch Press, 2010
(2 copies on Ready Reserve in Eckhart)

C++ Concurrency in Action: Practical Multithreading, Anthony Williams, Manning Pub., 2012

Online References:  Required (these will be referenced in the reading schedule below prefixed by "OR-#:" with ID number)

Articles marked "Available through the Cluster only" are (only) available through the cluster are at ~mark/pub/51025/Reading

OR-1:  LMAX - How to Do 100K TPS at Less than 1ms Latency
OR-2:  What is FIX?
OR-3:  Soft Real Time Programming in Linux 2.6
OR-4:  The Evolution of MultiCast
OR-5:  Trade-Offs between Latency, Complexity, and Load Balancing with Multicast Algorithms [Available through the Cluster only]
OR-6:  The Evolution of Multicast:  From the Mbone to Interdomain Multicast to Internet2 Deployment [Available through the Cluster only]
OR-7:  Gammo et. al. Comparing and Evaluating epoll, select and poll Event Mechanisms
OR-8:  The Free Lunch is Over:  A Fundamental Turn Toward Concurrency in Software, Sutter, Dr. Dobb's Journal, 30(3), March 2005
OR-9:  Is the Free Lunch Really Over?  Scalability in Manycore Systems:  Part 1, Michael Wrinn, Intel White Paper [Available through the Cluster only]
OR-10:  Is the Free Lunch Really Over?  Scalability in Manycore Systems:  Part 2:  Using Locks Efficiently, Michael Wrinn, Intel White Paper [Available through the Cluster only]
OR-11:  Intel Threading Building Blocks (TBB) Getting Started Guide
OR-12:  Intel Threading Building Blocks (TBB) Tutorial

Texts: Highly Recommended Ancillary:

Practical .NET for Financial Markets,  Shetty & Jayaswal, Apress, 2006

Multicast Sockets: Practical Guide for Programmers, Makofske & Almeroth, Morgan Kaufman, 2003

Accelerated C++: Practical Programming by Example,  Koenig and Moo, Addison-Wesley, 2000.

Advanced Programming in the UNIX(R) Environment , Richard Stevens, Addison-Wesley, 1992 (2 copies on Ready Reserve in Eckhart)

C++ Templates: The Complete Guide, David Vandevoorde, Addison-Wesley, 2002

Programming with POSIX Threads, Butenhof, Addison-Wesley, 1997 (2 copies on Ready Reserve in Eckhart)

Understanding Unix/Linux Programming:  A Guide to Theory and Practice, Molay, Prentice Hall, 2003 (1 copy on Ready Reserve in Eckhart)

UNIX Network Programming, Volume 1: Networking APIs - Sockets and XTI (2nd Edition), Richard Stevens, Prentice Hall, 1998 (2 copies on Ready Reserve in Eckhart)

UNIX Network Programming, Volume 2: Interprocess Communications (2nd Edition), Richard Stevens, Prentice Hall, 1999 (2 copies on Ready Reserve in Eckhart)


Texts: Recommended

C++ Language Reference

Programming:  Principles and Practice Using C++,  Stroustrup, Addison-Wesley, 2009 (beginner's introduction to C++ programming by l'homme lui-même)

Modern C++ Design: Generic Programming and Design Patterns Applied, Andrei Alexandrescu, Addison-Wesley, 2001

Standard C++ IOStreams and Locales: Advanced Programmer's Guide and Reference, Langer and  Kreft, Addison-Wesley, 2000

C++ Cookbook, Stephens et. al., O'Reilly, 2006


C Language Reference

C:  A Reference Manual (5th Ed.), Harbison & Steele; Prentice Hall (2002).  ISBN:  013089592X

Expert C Programming--Deep C Secrets, van der Linden, Prentice Hall (1994).  ISBN:  0131774298

Introductory C, Petersen; Morgan Kaufmann Publishers; ISBN: 0125521421 ; 2nd edition (January 15, 1997)

C Programming:  A Modern Approach, King; W.W. Norton & Company; ISBN: 0393969452 ; (April 1996)
 

General Unix Programming:

Unix Systems Programming, Robbins & Robbins, Prentice Hall, 2003

Managing Projects with Make , Andy Oram and Steve Talbott, O'Reilly, 1991

Unix Systems Programming with SVR 4, David Curry, O'Reilly,   1996

Linux Socket Programming By Example, Warren Gay

Pthreads Programming, Nichols et. al, O'Reilly, 1996

The Unix Programming Environment, Kernighan & Pike, Prentice Hall, 1984

Advanced Unix Programming, Rochkind, Prentice Hall, 1985

Interprocess Communications in UNIX:  The Nooks & Crannies , Gray, Prentice Hall, 1988

Unix Distributed Programming, Brown, Prentice Hall, 1994

Power Programming with RPC, Bloomer, O'Reilly, 1992

Using C on the UNIX System, Curry, O'Reilly, 1989

GNU Online Documentation for make, gcc, gdb, etc.

General Unix:

Learning the UNIX Operating System , 4th Edition , Peek, et. al., Orielly, 1997

A Practical Guide to Linux , Mark Sobell, Addison-Wesley, 1997

Portable Shell Programming , Bruce Blinn, Prentice Hall, 1996

UNIX Power Tools, Peek et. al., O'Reilly, 1993

Learning the Bash Shell, 2nd. Ed., Newham & Rosenblatt, O'Reilly, 1998
 

General Operating Systems:

Modern Operating Systems, 2nd. Ed., Tanenbaum, Prentice Hall, 2001

Operating System Concepts, 5th Ed., Silberschatz & Galvin, Addison-Wesley, 1998

UNIX Internals:  The New Frontiers, Vahalia, Prentice Hall, 1996

UNIX Internals:  A Practical Approach, Pate, Addison-Wesley, 1996
 

II. PREREQUISITES:

1.  Knowledge of C or C++ is required as you will be actively coding in one or both of these languages.  If you do not know C++, knowledge of C is sufficient as long as there is some exposure to some object-oriented programming language, such as Java, C#, Objective C, CLOS, Smalltalk, Scala, or Ruby, etc.

2.  All students should have taken the CSPP Unix Bootcamp or the MacLab Unix Course prior to the first day of class (or have the requirement waived).  Those who have not completed this requirement will need approval of the instructor, which will most likely not be granted unless you can demonstrate substantial experience working in a Unix environment.  CSPP 51081 will prove invaluable.

Although not required, trading experience, or experience working in the financial industry either in a technical or business capacity is a definite plus but is not required.

III. COURSE DESCRIPTION

This course will focus on three general goals:  (a) the operation of exchange trading systems at a high level, (b) real world computational issues in trading systems and their communication with exchanges, and (c) the implementation details in actually developing an exchange trading system in computer software.

We will accomplish these goals by having lectures that (a) focus on the technological strategies in implementation, lectures that (b) focus more on relevant system functionality, as well as (c) guest lectures from industry leaders who will offer a greater breadth in the overall landscape of trading systems and exchange systems operations.

Specifically, this course is designed to give students hands-on implementation experience in designing and building a functioning trading system in C and C++ using state-of-the-art tools and environments.  Students will work collaboratively in developing an exchange platform that implements the fundamental lifecycle of client-to-exchange communication, namely:  Order Receipt, Order Matching, Market Data Broadcast, Order Book Management Strategy, and Trade Notification. 

The course structure will be a combination of lecture and laboratory where students will implement a functioning (albeit primitive) equity exchange known as The University of Chicago Equities Exchange, or UCEE (pronounced “You See”), with a focus on trading equity shares (students are free to provide additional support in their implementations for commodities, options, etc., if they feel ambitious, although only equity trading support is required).  Students will form self-organized development teams (approved by faculty) and the teams will compete with one another in creating their team's UCEE system in code. 

For the implementation, we will focus on developing an exchange platform for the processing of equity trades.  Issues in distributed systems development will be addressed.  Students will learn how to implement the various exchange workflows including an Order-Matching Engine, Broadcast/Multicast Engine, and Data Exchange and Management.  The implementation will be based on technical and functional lectures and accompanying laboratores that focus on fundamental enabling technologies including advanced signals, parent and child process management, and advanced socket management including multicast socket communication.  In addition, both UDP vs. TCP processing will be covered, along with Multithreading vs. Multiprocessing strategies, advanced issues in POSIX multithreading and synchronization, POSIX Interprocess Communication with a focus on shared memory and sempahores, and I/O multiplexing.  Other topics relevant to trading/exchange system development will be discussed as needed and as time permits.  

Lectures will alternate between technical/capability instruction and functional discription of system components as well as guest lectures on related topics from exchange members, system developers, traders, and others directly involved in trading systems operations and execution on a day-to-day basis.  Because of the time constraints of a quarter system, we cannot address certain operational aspects of a real-world exchange.  Therefore, broader ancillary topics pertaining to the larger lifecycles of equity markets including Straight Through Processing, Clearing and Settlement, Equity Arbitrage and HFT/Short-Term Algorithmic Trading will also be addressed, time permitting.  There will be no expectation that any implementations will support these operational aspects.

IV. LEARNING OBJECTIVES

Upon completion of this course students will:

A. Understand fundamental concepts and terminology around trading and exchange systems and their development.

B. Understand the various tools and techniques available for creating real world high speed/low latency trading systems.

C. Understand the fundamentals of the components required in the functioning a real world financial exchange.

D. Understand the various tradeoffs in the architecture and design of trading systems.

E. Understand in detail the core facilities used in trading and exchange systems development, including shared memory, multithreaded design, semaphores, mutexes, message queues, socket protocols and connectivity, etc.

F.  Become familiar with socket programming using the Berkeley socket API using C++, including multicast

G. Become familiar with multithreading strategies in C++/C Unix development

V. ACADEMIC INTEGRITY

Students are expected to have read and understood the University's policy on Academic Integrity. This policy is detailed in the Student Manual of University Policies and Regulations, available online at http://www.uchicago.edu/docs/studentmanual/ .
 

VI. METHOD OF INSTRUCTION

Methods include lecture and laboratory assignments.
 

VII. OTHER COURSE INFORMATION

Attendance:

No formal attendance taken. There may be information presented in class that is not in the texts. You will be responsible for all information discussed in class and assigned in the required readings.

Make-up Work:

If you miss an exam or quiz, you will need to speak with the instructor ASAP.  Prepare for unhappiness.

Students are expected to read the assigned texts before class in order to be able to full participate in the discussions.
 

VIII. METHOD OF EVALUATING STUDENT PROGRESS

Assigned work will be evaluated as follows:
 
 
6 Labs (2 points each)   12%
Project Faculty Evaluation
   28%
Project Peer Evaluation
   25%
1 Final Exam
  20%
Team Presentation
   10%
Student QuickTalk
     5%
Total 100%

NB:  The end of the quarter is the time at which the final grade you have earned through your work in the quarter is recorded with the registrar.  It is not the time at which you begin negotiations with Professor Shacklette for ad hoc extra credit opportunities.  There is no extra credit offered in this course, either at the beginning or at the end.  If you are disatisfied with the grade you have earned at the end of the quarter, your only options will be to retake the course the next time it is offered, or accept the grade you earned.

Delivery Process:

The due dates for labs are on the syllabus schedule below.  All labs are required.

Lab assignments, when completed, should be tarballed up into a single gzipped tarball and sent to the instructors.  The instructors will post instructions on submitting labs.  Each student will work individually (NOT in teams) on the laboratory assignments.

For each part of the lab assignment there are detailed descriptions of what you should turn in. You should include ALL supporting files (source files, data files, etc.) as attachments to the submission email (a single message).  Please send only UNIX-readable (text) files unless you are including supporting design/other files, in which case you may submit that aspect of your submission in native format, for example, visio diagrams, omnigraffle diagrams, excel spreasheets, etc.. All work is evaluated and graded on the LINUX CLUSTER (i.e., not solaris, hpux, irix, aix, etc.)

FAILURE TO PROVIDE AND DELIVER TO THE GRADERS ALL SCRIPTS, ALL COMMANDS, AND ALL SUPPORTING FILES, TEXT OR SOURCE, YOU USED TO DELIVER AND PRODUCE THE SOLUTION WILL RESULT IN A LOSS OF POINTS.  IF THE GRADERS, WORKING SOLELY ON THE LINUX CLUSTER, CANNOT REPRODUCE YOUR SOLUTION OR ANY PART OF YOUR SOLUTION FROM THE SET OF INFORMATION YOU PROVIDE, YOU WILL LOSE PARTIAL OR FULL CREDIT.

Note: Labs are due as scheduled below.

All assignments are due as specified on this syllabus and supporting lab pages.  Students who turn in work late, regardless of the reason, will receive 1 point off from the first day the assignment is due (calculated as the first 24 hour period following the due date and time), and continuing for 5 days.  Assignments turned in more than 6 days late from the original due date will not be accepted and the student will receive a 0 on the assignment.  ALL late deliveries, regardless of cause, including, but not limited to, acts of God, war, riot, embargoes, acts of civil or military authority, terrorism, fire, flood, tsumami, earthquakes, hurricanes, typhoons, tropical storms or other natural disasters, fiber cuts, strikes, shortages in transportation, facilities, fuel, energy, labor or materials, failure of the telecommunications or information services infrastructure, hacking, SPAM, or any failure of a computer, server or software, including Y2K errors or omissions, the common cold, the flu, asthema, stomach flu, work, work travel, family, childcare, golf, badminton, cricket, croquet, dodgeball, football (soccer), lacrosse, other sporting events, vacation, and other life-related exigencies and necessities, while fortunate or unfortunate as the case may be, will still incur the penalty.  It is assumed that you will have plenty of time to work on each assignment, and that an individual penalty or two will have little overall effect on a student's final grade, unless lateness is chronic or other grades are poor, in which case, of course, the penalty will be more cumbersome.  If you are late with a delivery and therefore receive a penalty (which you will if you are late for any reason) and it's an isolated incident and the rest of your work is excellent, the penalty should be innocuous. 

The instructor reserves the right to alter the course contents, dates, times or percentage of credit based on time allowed and class progress through the course material. The instructor also reserves the right to curve grades if he deems it in the best interest of the majority of students.
 

IX. COURSE SCHEDULE

NB: The Instructor reserves the right to alter the schedule as class progress dictates.

The following abbreviations reference the following works:
 
 
Abbreviation Text

MK
Michael Kerrisk, The Linux Programming Interface
AW
 Anthony Williams, C++ Concurrency in Action
RS-1
 Richard Stevens, UNIX Network Programming, Volume 1: Networking APIs - Sockets and XTI (2nd Ed)
SJ
 Practical .NET for Financial Markets,  Shetty & Jayaswal

NOTE:  Numbers besides the references are chapter numbers.  Odd numbers like APUE 14.1-14.5 mean sections 1 through 5 of chapter 14 of APUE.
 
 
Class
 Date
 Topics for Lecture and Laboratory
 Readings and Laboratories
Class 1 June 21
 Introduction & Syllabus Review

Introduction to Distributed Trading System Development, Introduction to Exchanges & The UCEE System Overview

Team Selection & Student QuickTalk scheduling
 

JK:  2,3,6,24,25

LAB 1:  Group Introduction to emacs, cluster, compilers, debugging, calling C from C++ (Lab 1 is Pass/Fail)
Class 2 June 28
 Technical Lecture:  Introduction to Socket Programming in C++ with multiple client state managment

Application:  UCEE System Architecture Overview:  Reference Architecture, Key Components, Communication

Guest Lecture:  Messaging Protocols & Communication, Jim Northey, Senior Partner, The LaSalle Technology Group, LLC and Co-Chair, Americas Regional Committee, FIX Protocol Ltd.

Team Scrum Update (5 mins/team)
 JK:  56; 58-61; 63 (63 is very important)
RS-1:  6
OR-2
OR-7

LAB 2:  Basic Socket Programming in C++ with multiple client management
Class 3 July 5
 Technical Lecture:  Advanced Socket Programming in C++:  Broadcast & Multicast Concepts

Component Description:  Matching Engine (Part One)

Student QuickTalks

Team Scrum Update (5 mins/team)
 JK:  60-61
RS-1:  18-19
SJ:  1-2; 4
OR-4
OR-5
OR-6

LAB 3:  Advanced Socket Programming in C++
Class 4 July 12

Technical Lecture:  Introduction to POSIX Thread Programming in C++ on Linux

Component Description:  Trade Publisher

Guest Lecture:  Component Responsibilities in Exchange Trading, Jeff Illian, Chief Architect, Man Group

Student QuickTalks

Team Scrum Update (5 mins/team)

JK:  29-30
AW:  1-5
OR-3
OR-8

LAB 4:  Basic Thread Programming in C++
Class 5 July 19

 Technical Lecture:  C++ Multithreading:  Concurrency Management

Component Description:  Connection Manager

Student QuickTalks

Team Scrum Update (5 mins/team)
 JK:  31-33
AW:  6-10
OR-9
OR-10
OR-11
OR-12

LAB 5:  Managing Concurrency in MTP
Class  6 July 26
 Technical Lecture:  POSIX Interprocess Communication:  Message Queues, Shared Memory and Semaphores

Component Description:  Matching Engine Revisited

Guest Lecture:  Will High Frequency Trading be Banned?  Emerging Regulatory Trends--Keith Fishe, Keith Fishe, Managing Partner, TradeForecaster Global Markets, LLC.  Member, CFTC Subcommittee on Automated and High Frequency Trading

Student QuickTalks

Team Scrum Update (5 mins/team)
 JK:  43-48; 51-54
OR-1

LAB 6:  POSIX Message Queues, Shared Memory and Semaphores
Class 7 August 2
 Technical Lecture:  Leveraging BOOST

Component Description:  Book Publisher

Guest Lecture:  T.B.D.

Student QuickTalks

Team Scrum Update (5 mins/team)		 BOOST Library Documentation

LAB 7:  Password Cracking
Class 8 August 9
 Technical Lecture:  Advanced Topics:  Performance, Scalability, RealTime Software Development
Component Description:  Reporting Engine & SQLite

Student QuickTalks

Team Scrum Update (5 mins/team)
Class 9 August 16
 Final Written Exam

(exam preparation guide)

Student QuickTalks

Final Team Update (10 mins/team)		 No Lab.
Class 10 August 23
 Team Project Presentations & Live Demonstration
   * What Worked, What Didn't
   * Component Architecture & Design Presentation
   * Metrics:  Latency, Throughput, Resource Utilization
      (Memory & CPU), Memory Leaks
   * Live Demonstration with PerlBots

Student QuickTalks 		No Lab.




X. Online Reference and Resources:

General C++ on Unix Programming Resources:

Linux Gazette:  Socket Programming Using C++

General:

Common Unix Commands

Norman Matloff's Unix Tutoral Center

IBM Developerworks Library

The Unix Reference Desk

Davin's collection of unix programming links

Unix Guru Universe

Unix FAQ Index at faqs.org

Stanford CS Education Library (C tutorials, programmer tools pdf, pointer references, fun with Binky, et. al.)

History of Unix by Mike Loukides

History of Unix by Dennis Ritchie

DDD Debugger

glibc Manual

Regular Expressions:

Regular Expression HOWTO

Single UNIX Specification:  Regular Expressions

 Steve Ramsay's Guide to Regular Expressions

Awk:

How to Get Things Done With Awk

Awk Filters

C Programming:

Unix C Programming FAQ

A. D. Marshall's Programming in C:  UNIX System Calls and Subroutines using C

Introduction to C Programming

C Programming on Unix Tutorial at University of Strathclyde

Emacs Support

Common emacs commands (cheat sheet):

Ctrl-x-f : To open a file (Hold down Control Key and then type 'x' followed by 'f' (still holding down the Control Key))
Ctrl-x-s: To save a file
Ctrl-x-c: To close Emacs (All buffers)
Ctrl-x 2: To split buffer horizontally
Ctrl-x 3: To split buffer vertically
Ctrl-x 1: To close all the buffers except current
Ctrl-x 0: To close the current buffer
M-x : To enter a command
M-x compile: To compile
M-x gdb: GNU Debugger
Meta Key (M-) Cheat:
    Under Linux: the Esc key
    Under Windows: the Alt key
    Under MacOs it should be the Command key.

GNU Emacs QuickReference Card

GNU Emacs Manual (pdf)

Emacs Online Manuals

The emacs CC Mode Manual

The Emacs Wiki

Boston University Emacs Programming Guide for C++

POSIX Threads:

Threads FAQ

Programming Posix Threads Bounce Point
 
 

Supplemental Reading
(in no particular order)

Mastering Regular Expressions, Jeffrey E. F. Friedl (O'Reilly & Assoc. 1997, ISBN: 1-56592-257-3). An thorough discussion of an inexhaustible subject.

Learning the UNIX Operating System , 4th Edition, Jerry Peek, Grace Todino & John Strang (Orielly & Associates, 1997, ISBN: 1-56592-390-1) A virtual "Cliffs Notes" for the Unix Operating System.

Using C on the UNIX System, David A. Curry (O'Reilly & Assoc., 1985, ISBN: 0-937175-23-4). A good introduction to C programming on Unix.

Learning GNU Emacs, Debra Cameron & Bill Rosenblatt (O'Reilly & Assoc., 1991, ISBN: 0-937175-84-6). A good introduction to emacs.

UNIX for the Impatient, Paul W. Abrahams & Bruce R. Larson (Addison-Wesley Publishing Company, 1992, ISBN 0-201-55703-7). Good, clear coverage of the utilities, recommended for Unix beginners.

UNIX in a Nutshell: A Desktop Quick Reference for System V & Solaris 2.0 (O'Reilly & Associates, Inc., 1992, ISBN 0-56592-001-5). A handy reference for SysV and Solaris 2.

When You Can't Find Your UNIX System Administrator, Linda Mui (O'Reilly & Associates, Inc., 1995, ISBN 1-56592-104-6). The title says it all.

UNIX Power Tools, Jerry Peek, Tim O'Reilly, and Mike Loukides (O'Reilly & Associates, 1993, ISBN 0-679-79073-X). An excellent compendium of tricks of the masters, written for beginners and intermediates. Includes a CDROM of useful software.

Exploring the UNIX System, Stephen G. Kochan & Patrick H. Wood (SAMS, a division of Macmillan Computer Publishing, 1989, ISBN 0-8104-6268-0).(OUT OF PRINT)

Learning GNU Emacs, Debra Cameron and Bill Rosenblatt (O'Reilly & Associates, 1992, ISBN 0-937175-84-6).

Unix Shell Programming, Stephen G. Kochan & Patrick H. Wood (Hayden Book Co., 1990, ISBN 0-8104-6309-1). The classic on shell programming. The third edition is available at amazon

The Unix C Shell Field Guide, Gail Anderson and Paul Anderson (Prentice Hall, 1986, ISBN 0-13-937468-X).

A Student's Guide to UNIX, Harley Hahn. (McGraw-Hill, 1993, ISBN 0-07-025511-3). This, and its almost identical sister, Open Computing's Unix Unbound (same author and publisher), is an excellent aid for beginners. Hahn's wry humor runs throughout.

Tricks of the UNIX Masters, Russell G. Sage (Howard W. Sams & Co., Inc., 1987, ISBN 0-672-22449-6).

Unix System V: A Practical Guide , Mark Sobell (Benjamin/Cummings, 1995, ISBN 0805375678) (A classic)

Unix Network Programming, Volume 1: Networking APIs: Sockets and XTI , Richard Stevens (Prentice Hall, 1998, ISBN 013490012X) The definitive work on Unix Sockets

Unix Network Programming, Volume 2: Interprocess Communication, Richard Stevens(Prentice Hall, 1999, ISBN 0130810819) The definitive work on IPC.

Applied Unix Programming, Volume 2 , Bharat Kurani (Prentice Hall, 1997, ISBN 0133043460) The Unix C Library Reference Manual, includes C Library, math library, socket library, transport library, and internet library.

Advanced Programming in the Unix Environment , Richard Stevens (Addison-Wesley, 1992, ISBN: 0201563177). A practical guide to the theory of sockets and IPC on Unix.

The C Programming Language, Brian Kernighan and Dennis Ritchie (Prentice Hall, 1988, ISBN 0131103626). The definitive tutorial on the C Programming Language.

Pointers on C, Kenneth Reek (Addisson-Wesley, 1998, ISBN 0673999866). A good introduction to the C Programming Language.

C: A Reference Manual, Fourth Edition , Harbinson and Steele (Prentice Hall, 1995, ISBN 0133262243). A good reference manual for the C langugage.

Absolute Beginner's Guide to C , Greg Perry (Sams, 1994, ISBN 0672305100). One of the easiest avenues into C Programming in print.

Practical C Programming, Third Edition , Steve Oualline (O'Reilly, 1997, ISBN 1565923065). A good tutorial on C, and one of the few that assumes you might be using GNU tools as opposed to Microsoft's.

Design of the Unix Operating System , Maurice Bach (Prentice Hall, 1986, ISBN 0132017997). Perhaps the best general discussion of the details of the Unix Operating System.

Unix Internals: The New Frontiers , Uresh Vahalia (Prentice Hall, 1996, ISBN 0131019082). A newer discussion of the details of Unix, published 10 years after Bach's book.

Unix Internals: A Practical Approach , Steve Pate (Addison-Wesley, 1996, ISBN 020187721X). A good and readable discussion of the details of the Unix kernel.

The Linux Kernel Book, Card, et. al. (Wiley, 1998, ISBN 0471981419). A good book which concentrates on the particularities of the Linux Kernel code itself. A gentle tour through the kernel's source code. The book comes with a CD for RedHat 5.0, whose kernel's code is examined throughout the book.