COMS 1003: Introduction to Computer Programming in C
Fall 2005
Columbia University
Department of Computer Science
Michael E. Locasto
$Id: syllabus.txt,v 1.5 2005/09/06 02:53:52 locasto Exp $
Course Syllabus
-----------------------------------------------------------------------------

[OVERVIEW]

A general introduction to computer science concepts, algorithmic 
problem-solving capabilities, and programming skills in C.

The student will learn the systems language C in the Linux environment. The
C skills are directly applicable to a number of courses, including but not
limited to Operating Systems, Advanced Programming, Architecture, Networks, 
and Network Security. 

The student will also learn the software lifecycle and a formal, scientific 
method for creating, designing, and testing a solution to computing problems. 
This algorithmic way of thinking is broadly applicable to almost any problem 
encountered in this existence.

[LECTURE SCHEDULE]

The schedule of lectures and assignments is located on the course web page at:
 
 http://www1.cs.columbia.edu/~locasto/teaching/f2005/coms1003/

[TOPICS]

 * General Topics
    - Big-O notation, time and space complexity
    - computer systems and basic architecture/organization (von Neumann) 
    - how programs are executed (model of computation)
    - data representation, memory hierarchy
    - the command line
    - the art of Unix programming
    - ethical considerations (licenses, truth, operating environments)

 * The C Programming Language
    - the structure of the language (language/compiler itself, standard
       library, and OS interface)
    - the software construction and build process, Makefiles, emacs
    - the GNU C compiler collection (GCC)
    - program entry, main(), cmd line args
    - header and src files
    - basic input and output (printf, fprintf, perror, getchar, putchar)
    - robust programming (checking error and return values, NULL, EOF)
    - variable declarations and types, typedef
    - constants
    - storage classes and scope (automatic, static, extern)
    - macros
    - simple data types (int, char, byte, double, float, long)
    - complex data types (arrays, enum, structs, unions, lists)
    - function declarations
    - function prototypes
    - variable passing
    - pointers, dereferencing, addressing, pointer operations
    - memory management, allocation/deallocation (malloc,free)
    - decision control structures (if, switch, etc.)
    - repetition control structures (for, do, while, etc.)
    - basic recursion
    - file I/O
    - signals, pids
    - simple algorithms (sorting, searching, etc.)
    - appropriate documentation (code comments, README, INSTALL, user docs)

 * Problem Solving
    - problem requirements
    - getting more information, being specific, asking questions
    - design a solution
    - discover general principles
    - use and leverage existing tools, libraries, and techniques
    - psuedocode
    - first brute force approach
    - integrate testing, test cases, regression testing
    - document and present solution    

 * Software Lifecycle
    - requirements
    - design
    - documentation
    - test construction
    - construction/implementation
    - testing
    - packaging and build process
    - maintenance


[SCIENTIFIC SKILLS]

Computer Science is a scientific discipline. As such, students are scientists
in training and will earn the following skills:

 - gain an understanding of the world via generalizable problem-solving skills
 - acquire a philosophy of algorithmic thinking
 - develop the ability to identify and abstract away the unimportant details 
    to reveal the core of a problem
 - nurture the ability to use abstraction in both problem identification and 
    solution construction to provide general solutions, not just task-specific
    one-off hacks

[TECHNICAL SKILLS]

Computer Science is also a highly technical field that employs cutting-edge
computation tools to implement ideas and automate tasks. As such, it is
critical for students to be trained in mainstream programming languages.
The student will earn the following technical skills:

 - learn the basics of the C programming language
 - an understanding of the execution environment on x86 architectures
 - learn how to structure and package an application
 - learn to use the Unix 'man' pages.
 - learn fundamentals of the Unix command line.
 - learn what a Makefile is and how to write one.
 - learn the basics of the GNU development environment (make, gcc, emacs)
 - learn the basics of the libraries and environment accessible to C
    programs written on Linux
 - acquire an appreciation for what {compilation, linking, loading} is
 - develop the ability to document code correctly and tersely