by Jeffrey Forbes (Duke University) and Daniel D. Garcia (University of California, Berkeley)

Our field continues to be blessed (and plagued) with continual curriculum change, from languages to techniques (objects first) to perspectives (“sage on the stage” vs. “guide on the side”). Particular emphasis has been spent crafting and re-crafting our introductory curricula. This makes sense, since that not only defines the foundation upon which our upper-division courses are based, but is exactly where we attract (or lose) our best students who had not considered majoring in computer science. With enrollments declining, retaining our fence-sitting prospective majors takes on that much more importance.

When considering curriculum change at the introductory level, it often helps to look around at successful programs to see what they do. We surveyed the schools whose computer science Ph.D. programs were listed as the top 32 by the 2007 U.S. News & World Report ranking.

While other surveys have focused on departments, salaries and degree production, ours tried to capture the important aspects of each institution’s lower-division curriculum. First, we looked at the material on each department’s web page and course pages when accessible. We followed that initial sweep by asking representative faculty at each institution to report on the following questions, divided into the following seven major categories. The links below will take you to the raw data (answers from each school categorized by question) we used for our analysis.

• Institution
• Staff
• Demographics
• Content
• Delivery & Style
• Meta

PDF (8 MB), Powerpoint (10 MB)

Final gather of Questions and Answers

Reqs Webpage: http://cs.brown.edu/ugrad/concentrations/
Course Number/Name (Language): CS 015-016 Introduction to Object Oriented Programming/Computer Science (Java)
Course Webpage: http://www.cs.brown.edu/courses/cs015/home1.html
Course Syllabus: Unlisted
Instructor (Title and Webpage if Available):
Professor Andy Van Dam
http://www.cs.brown.edu/people/faculty/avd.html
Professor Roberto Tamassia
http://www.cs.brown.edu/people/faculty/rt.html
Course Description(if available):
CS 15/16 is a two-course sequence intended for those who plan to concentrate in Computer Science as well as for those who want a strong background in programming. No prior background in programming is assumed or required. CS15 is a challenging object-oriented programming course (using Java) in which students gain experience with object-oriented design techniques and the use of Swing, Java’s 2D graphics library, through the design and implementation of a sequence of moderate to fairly lengthy interactive programs, including Tetris, a fascinating computer game. All programs use graphical user interfaces. In CS16, students learn the theoretical tools used to analyze computation and make programs more efficient. A number of fundamental algorithms and data structures are covered, as well as their object-oriented implementation in Java. Students with questions about CS015 and CS016 are invited to email the professors teaching these courses in 2005-2006

Course Number/Name (Language): CS 017-018 An Integrated Introduction to Computer Science (Scheme/Java)
Course Webpage: http://www.cs.brown.edu/courses/cs017/
Course Syllabus: Unlisted
Instructor (Title and Webpage if Available):
Professor Phillip Klein
http://www.cs.brown.edu/people/faculty/klein.html
Course Description(if available):
The goal of CS17 is to put you on the path to mastery of computer science. Computer science is a rich, diverse field, full of intellectual delights and challenges. One common thread is problem-solving; if you enjoy puzzles that require ingenuity and have elegant solutions, you will find this course deeply satisfying. Programming is only a small part, but it is an essential part. Mastery requires that one fully understand one’s tools. This course begins by teaching a lovely programming language called Scheme, which is a dialect of LISP. The syntax and semantics of Scheme can be learned in just a few days (making it an ideal first programming language), though learning to harness its power takes much longer. CS17 continues with a language in the ML family that illustrates types and type-inference, pattern-matching, and modules. Both Scheme and ML exemplify the functional programming paradigm, which permits extremely concise and elegant solutions to many programming problems. The follow-up course, CS18, uses Java as the vehicle for teaching the object-oriented programming paradigm, which emphasizes modularity, flexibility, and extensibility. The fact that CS17-18 is multilingual and multiparadigmatic helps students to have an understand of programmming that transcends the syntax and quirks of any one language. How does one choose among the many possible methods for solving a computational problem? It is impractical to program all approaches and test them against each other. Analysis of algorithms consists in using mathematics to predict the computational performance of a method. In CS17, the study of analysis is interwoven with the study of programming. Drawing on analysis, computer scientists have discovered lovely and surprising solutions–algorithms and data structures–to many fundamental computational problems, and CS 17-18 introduces some representative examples, from the familiar algorithm for long multiplication, through organizing data for quick retrieval, to finding shortest paths in networks (used, e.g., in map navigation) and longest common subsequence (a problem arising in computational biology). CS17-18 is not a large class, and lectures are highly interactive. Collaboration on assignments is encouraged (within guidelines). Students are strongly encouraged to join the professor at twice-weekly office hours for informal discussions of ancillary topics ranging from public-key cryptography to open-source. Prospective students are encouraged to contact the CS17 instructor, Philip Klein (401-863-7680), who would be delighted to talk with you about the course.

Course Number/Name (Language): CS022 Introduction to Discrete Structures and Probability
Course Webpage: http://cs.brown.edu/courses/cs022/
Course Syllabus: http://cs.brown.edu/courses/cs022/Syllabus.html
Instructor (Title and Webpage if Available):
Professor Franco P. Preparata
http://cs.brown.edu/people/faculty/franco.html
Course Description(if available):
Seeks to place on solid foundations the most common structures of computer science, to illustrate proof techniques, to provide the background for an introductory course in computational theory, and to introduce basic concepts of probability theory. Introduces Boolean algebras, logic, set theory, elements of algebraic structures, graph theory, combinatorics, and probability. No prerequisites.

Course Number/Name (Language): CS031 Introduction to Computer Systems
Course Webpage: http://cs.brown.edu/courses/cs031/
Course Syllabus: http://cs.brown.edu/courses/cs031/syllabus.html
Instructor (Title and Webpage if Available):
Professor Pascal Van Hentenryck
http://cs.brown.edu/people/faculty/pvh.html
Course Description(if available):
Basic principles of computer organization. Begins with machine representation of data types and logic design, then explores architecture and operations of computer systems, including I/O, pipelining, and memory hierarchies. Uses assembly language as an intermediate abstraction to study introductory operating system and compiler concepts. Prerequisite: CS 15 or 18.

Reqs Webpage: http://www.cs.caltech.edu/academics/undergrad_study.html
Course Number/Name (Language): CS1 Introduction to Computation (Unlisted)
Course Webpage: http://www.cs.caltech.edu/courses/cs1/
Course Syllabus: http://www.cs.caltech.edu/courses/cs1/courseadmin/admin.html
Instructor (Title and Webpage if Available):
Mike Vanier
(Unlisted)
Professor Steven Low
http://www.cs.caltech.edu/cspeople/faculty/low_s.html
Course Description(if available):
9 units (3-4-2); first term. CS 1 is an introduction to the automated processing of information, including computer programming. This course gives students the conceptual background necessary to understand and construct programs (i.e., specify computations, understand evaluation models, use and understand major constructs, including functions and procedures, scoping and environments, data storage, side-effects, conditionals, recursion and looping, and higher-order functions). CS 1 introduces key issues that arise in computation (e.g., universality, computability, complexity, representation, abstraction management). This course puts the components of computer science in context, serving as an overview for students specializing in computational disciplines and alerting all students to important subtleties that may arise when applying computation in their studies, research, and work. At the end of this course, students should be able to read and write (synthesize, analyze, understand) small programs (100 lines) and have the intellectual framework necessary to rapidly assimilate new computer languages as the need arises. All Caltech undergraduates are encouraged to take this course. Instructors: Low, Vanier.

Course Number/Name (Language): CS2 Introduction to Programming Methods (Unlisted)
Course Webpage: (Unlisted)
Course Syllabus: (Unlisted)
Instructor (Title and Webpage if Available):
Professor Al Barr
http://www.cs.caltech.edu/cspeople/faculty/barr_a.html
Course Description(if available):
9 units (2-4-3); second term. Prerequisite: CS 1 or equivalent. CS 2 is a challenging course in programming languages and computer science, emphasizing modes of algorithmic expression. The course will include such topics as performance analysis of algorithms; proofs of program correctness; recursive and higher-order procedures; data structures, including lists, trees, graphs, and arrays; objects and abstract data types. The course includes weekly laboratory exercises and written homework covering the lecture material and program design. Instructor: Barr.

Reqs Website: http://www.csd.cs.cmu.edu/education/bscs/currreq.html
Course Name:15-111 Intermediate/Advanced Programming (Java)
Instructor(s):
Associate Teaching Professor CSD Ananda Gunawardena
http://www.cs.cmu.edu/~guna/
Syllabus: http://www.cs.cmu.edu/~scottm/Sp05/cs111/handouts/courseInfo.html
Course Description:
“An introduction to the process of program design and analysis using the Java programming language for students with some prior programming experience (functions, loops, and arrays) in a language other than Java. Topics to be covered include an overview of fundamental programming concepts using Java as well as object-oriented programming techniques, data aggregates, data structures (e.g., linked lists, stacks, queues, trees, and graphs), and an introduction to the analysis of algorithms that operate on those data structures.”

Course Name(Language): 15-123 Effective Programming in C and UNIX
Instructor(Title and Webpage if Available):
Teaching Professor, Assistant Dean for Undergrad Education, CSD Mark Stehlik
http://www-2.cs.cmu.edu/~mjs/
Course Description:
Fall and Spring: 12 units Fundamental programming concepts are presented together with supporting theoretical foundations and practical applications. This course emphasizes the practical application of techniques for writing and analyzing programs: data abstraction, program verification, and performance analysis. These techniques are applied in the design and analysis of fundamental algorithms and data structures. The course is currently taught in Java. Prerequisites: (15111 or 15200) and 21127

Course Number/Name (Language): 15-158 Freshman Immigration Course
Course Webpage: http://www.andrew.cmu.edu/course/15-128/
Course Syllabus: http://www.andrew.cmu.edu/course/15-128/
Instructor (Title and Webpage if Available):
(N/A)
Course Description(if available):
The Freshman Immigration Course is taken by first-semester Computer Science majors. The course is designed to acquaint incoming majors with computer science at CMU. Talks range from historical perspectives in the field to descriptions of the cutting edge research being conducted. 15-128 is a one unit course and is graded pass/fail. Enrollment is limited to SCS Freshmen ONLY.

Course Name(Language): 15-211 Fundamental Data Structures and Algorithms (C)
Instructor (Title and Webpage If Available):
Professor Daniel D. Sleator
http://www-2.cs.cmu.edu/~sleator/
Assistant Professor Christopher Langmead
http://www-2.cs.cmu.edu/~cjl/
Course Description(If Available):
Fall and Spring: 12 units Fundamental programming concepts are presented together with supporting theoretical foundations and practical applications. This course emphasizes the practical application of techniques for writing and analyzing programs: data abstraction, program verification, and performance analysis. These techniques are applied in the design and analysis of fundamental algorithms and data structures. The course is currently taught in Java. Prerequisites: (15111 or 15200) and 21127

Course Webpage/Syllabus: http://www.cs.cmu.edu/~fp/courses/15213-s06/

General Information: http://www.cs.cmu.edu/afs/cs/usr/cathyf/www/ugcourses.htm

Reqs Webpage: http://www.cs.columbia.edu/education/undergrad/undergradfaq
Course Number/Name (Language): COMS W1004 Introduction To Computer Science And Programming (Offered in Java and C)
Course Webpage: Unlisted
Course Syllabus: Unlisted
Instructor (Title and Webpage if Available):
Professor Alfred Aho
http://www1.cs.columbia.edu/~aho/
Course Description(if available):
A general introduction to computer science for science and engineering students interested in majoring in computer science or engineering. Covers fundamental concepts of computer science, algorithmic problem-solving capabilities, and introductory Java programming skills. Assumes no prior programming background.

Course Number/Name (Language): COMS W1007 - Object-oriented programming and design (Java)
Course Webpage: Unlisted
Course Syllabus: Unlisted
Instructor (Title and Webpage if Available):
Professor John Kender
http://www1.cs.columbia.edu/~jrk/
Course Description(if available):
Prerequisites: COMS W1004 or AP Computer Science with a grade of 4 or 5. The second course for majors in computer science. A rigorous treatment of object-oriented concepts using Java as an example language. Development of sound programming and design skills, problem solving and modeling of real world problems from science, engineering, and economics using the object-oriented paradigm.

Course Number/Name (Language): COMS W3101 - Programming Languages (Java/C)
Course Webpage: Unlisted
Course Syllabus: Unlisted
Instructor (Title and Webpage if Available): TBA
Course Description(if available):
Prerequisites: Fluency in at least one programming language. Introduction to a programming language. Each section is devoted to a specific language. Intended only for those who are already fluent in at least one programming language. Sections may meet for one hour per week for the whole term, for three hours per week for the first third of the term, or for two hours per week for the first six weeks. May be repeated for credit if different languages are involved. Note: May be repeated for credit if different languages are involved.

Course Number/Name (Language): COMS 3137 Data Structures and Algorithms (C/C++)
Course Webpage: (Unlisted)
Course Syllabus: (Unlisted)
Instructor (Title and Webpage if Available):
Professor Peter Allen
http://www.cs.columbia.edu/mice/persons/showPerson.php?personID=93&base=%2Fmice%2Fclasses%2F&
Course Description(if available):
Lect: 3. 4 pts. Prerequisites: COMS W3157. Corequisites: COMS W3203. Data types and structures: arrays, stacks singly and doubly linked lists, queues, trees, sets, and graphs. Programming techniques for processing such structures: sorting and searching, hashing, garbage collection. Storage management. Design and analysis of algorithms. Taught in C/C++. Note: Due to significant overlap, students may receive credit for only one of the following four courses: COMS W3133, W3134, W3137, and W3139.

Course Number/Name (Language): COMS 3203 Introduction to Combinatorics and Graph Theory
Course Webpage: (Unlisted)
Course Syllabus: (Unlisted)
Instructor (Title and Webpage if Available):
Professor Jonathan Gross
http://www.cs.columbia.edu/mice/persons/showPerson.php?personID=58&base=%2Fmice%2Fclasses%2F&
Course Description(if available):
Lect: 3. 3 pts. Prerequisites: Any introductory course in computer programming. Logic and formal proofs, sequences and summation, mathematical induction, binomial coefficients, elements of finite probability, recurrence relations, equivalence relations and partial orderings, and topics in graph theory (including isomorphism, traversability, planarity, and colorings).

Reqs Webpage: http://www.cs.cornell.edu/degreeprogs/ugrad/CSMajor/index.htm
Course Name: CS 100 Introduction to Computer Programming (Java)
Course Webpage: http://www.cs.cornell.edu/courses/cs100j/2006sp/
Syllabus: http://www.cs.cornell.edu/courses/cs100j/2006sp/info.html
Instructor(s):
Professor of Computer Science David Gries
http://www.cs.cornell.edu/gries/
Course Description:
CS 100 is an introduction to elementary computer programming concepts. Emphasis is on techniques of problem analysis and the development of algorithms and programs. There are two versions of the course. Both provide adequate preparation for COM S/ENGRD 211. Both versions are offered every fall and spring semester. In the fall there are two versions of the course - 100M and 100J. CS 100M assumes at least one semester of calculus (Math 191 or the equivalent). This version starts with a seven-week introduction to programming in Matlab.Iteration, functions and arrays are introduced. The second seven weeks of the course examines how these ideas are handled in the object-oriented framework provided by the Java programming language. Throughout the course, examples and assignments are chosen to give the student an appreciation for computational science and engineering. The pace of the course assumes that the student has no prior programming experience. CS 100J assumes only a background in high school mathematics. This course is a standard introduction to the Java programming language. The usual topics of iteration, functions, and arrays are introduced in the context of classes and objects. Although the course is self-contained, its pace makes it more suitable for students who have had some experience programming in high school with C, C++, Java, Pascal, etc. The course includes a two-week unit on Matlab. An option for a new student is to take CS 100 in the spring after completing a semester at Cornell. This is a good option for those who are not sure they are ready for CS 100. By taking CS 100 in the spring, you will have a semester to take more mathematics first and to adjust to the Cornell workload. CS 100 is also offered during the summer, in the six-week session. This version of the course is equivalent to CS 100J; CS 100M is not offered in the summer.

Course Name: CS 211 Computers and Programming (Java)
Coruse Webpage: http://www.cs.cornell.edu/courses/cs211/2005fa/
Syllabus: http://www.cs.cornell.edu/courses/cs211/2005fa/info.html#CS212
Instructor(s):
Paul Chew
Unlisted
Lecturer David Schwartz
http://www.cs.cornell.edu/dis/

Description:
CS 211 is a 3-credit second semester course in programming using Java. Students taking this course should already have taken the equivalent of CS100 in Java or C++ (including object-oriented programming). CS 211 introduces the topics of program structure and organization, modules (classes), program development, proofs of program correctness, recursion, data structures and types (lists, stacks, queues, trees), object-oriented and functional programming, analysis of algorithms, and an introduction to elementary graph theory and graph algorithms.

Course Name: CS 212 Java Practicum (Java)
Course Webpage: http://www.cs.cornell.edu/courses/cs212/2006sp/
Syllabus: http://www.cs.cornell.edu/courses/cs212/2006sp/info.html
Instructor(s):
Lecturer David Schwartz
http://www.cs.cornell.edu/dis/
Description:
A project course that introduces students to the ways of software engineering using the Java programming language. The course requires the design and implementation of several large programs.

Reqs Webpage (BA): http://www.cs.duke.edu/education/undergrad/ba.php
Reqs Webpage (BS): http://www.cs.duke.edu/education/undergrad/bs.php

Course Number/Name (Language): CompSci 1 - Computer Science Fundamentals (Java)
Course Webpage: http://www.cs.duke.edu/courses/spring06/cps001/
Course Syllabus: http://www.cs.duke.edu/courses/spring06/cps001/
Instructor (Title and Webpage if Available):
Course Description(if available):
Introduction to the field of Computer Science, intended for those interested in one course in Computer Science. Elementary Java programming is used to explore the field of Computer Science, but this is NOT a programming course.

Course Number/Name (Language): CompSci 4 - Introduction to Programming (Java & Alice)
Course Webpage: http://www.cs.duke.edu/courses/spring06/cps004/
Course Syllabus: http://www.cs.duke.edu/courses/spring06/cps004/
Instructor (Title and Webpage if Available):
Course Description(if available):
This course covers an introduction to the basic concepts of computer programming. Different sections use different languages and methods, but the concepts covered are widely applicable across programming languages and applications. For example, the course material may focus on using Java as applied to video game development, or use Alice for creating 3D virtual worlds, or use lego robots.

Course Number/Name (Language): CompSci 6 - Program Design and Analysis I (Java)
Course Webpage: http://www.cs.duke.edu/courses/spring06/cps006/
Course Syllabus: http://www.cs.duke.edu/courses/spring06/cps006/
Instructor (Title and Webpage if Available):
Course Description(if available):
Introduction to Computer Science and Programming. Typically the first course for majors, minors, and those interested in a significant programming course (uses Java).

Georgia Tech is redesigning their undergraduate CS curriculum. The Threads program is replacing the previously used curriculum. Information on Threads is available but nothing specific as four year plans. Reqs Webpage: http://www.cc.gatech.edu/content/view/119/113/
Course Number/Name (Language): None Listed
Course Webpage: None Listed
Course Syllabus: None Listed
Instructor (Title and Webpage if Available): None Listed
Course Description(if available): None Listed

Reqs Webpage: http://webdocs.registrar.fas.harvard.edu/ugrad_handbook/current/PDF/Chapter%203/comp_sci.pdf
Course Number/Name (Language): CS 50 Introduction to Computer Science I (C, Ruby)
Course Webpage: http://www.fas.harvard.edu/~lib50/
Course Syllabus: http://www.fas.harvard.edu/~lib50/
Instructor (Title and Webpage if Available):
Professor Mike Smith
http://www.eecs.harvard.edu/~smith/
Course Description(if available):
Computer Science 50 is an intensive and rewarding introduction to topics in computer science – from the mathematics of computing to the art of computer programming – for a wide range of students. As well as serving as the first course for computer science concentrators, CS 50 is meant for mathematicians, biologists, engineers, economists, physicists, and linguists. The course has three goals:
• to teach problem solving through the development of algorithms
• to teach computer programming as a means to express algorithms
• and to convey a broad picture of the different aspects of computer science in the real world.

To address these goals, we will attack interesting problems with the C programming language and the Ruby scripting language. These problems include algorithms for searching, sorting, and other useful, everyday tasks. To better understand these solutions, we cover techniques for the analysis of such algorithms and devices for structuring data and other interesting content, as well as the organization and security of computer systems and networks.

Using skills developed in the class, you’ll be able to build an instant messenger, a file compressor, computer games, data analyzers, and the kinds of cool things under the Student Showcase. If you’re interested in some of the other talents our students possess, check out the winning entries of our annual lipogram contest. Hollywood stereotypes aside, computer science is not a secluded art. Computer scientists rarely work alone and neither will you. You’ll experience many parts of this process, including writing code to meet a specification, cooperating with a classmate to complete a program, and developing the architecture of your own project. And throughout the semester, our exceptional teaching staff will always be there to make sure you get the help you need to keep moving forward.

Course Number/Name (Language): CS 51 Introduction to Computer Science II (Lisp, C)
Course Webpage: http://www.fas.harvard.edu/~lib51/
Course Syllabus: http://www.fas.harvard.edu/~lib51/syllabus
Instructor (Title and Webpage if Available):
Professor Radhika Nagpal
http://www.eecs.harvard.edu/~rad/
Professor Margo Seltzer
http://www.eecs.harvard.edu/~margo/
Course Description(if available):
This course is about abstraction and design: understanding how to design large programs to make them clear, readable, maintainable, efficient and elegant. Programming is the language in which we express designs, and we will see that different kinds of languages lend themselves to different kinds of design methodologies — but ultimately a programming language is itself an abstraction that you can design and implement. Course Website: http://www.fas.harvard.edu/lib51 Prerequisites: Computer Science 50 See course website for section times and office hours

Course Number/Name (Language): CS 121 Introduction to Formal Systems and Computation
Course Webpage: http://www.courses.fas.harvard.edu/0669
Course Syllabus: http://www.courses.fas.harvard.edu/0669
Instructor (Title and Webpage if Available):
Professor Harry Lewis
http://www.eecs.harvard.edu/~lewis/
Course Description(if available):
Half course (fall term). Tu., Th., 10–11:30. EXAM GROUP: 12, 13 General introduction to formal systems and the theory of computation. Elementary treatment of automata, formal languages, computability, uncomputability, computational complexity, NP–completeness, and mathematical logic.

Reqs Webpage: http://www.cs.jhu.edu/undergraduate-programs/

Course Number/Name (Language): 600.107 Intro to Programming in Java / 600.109 Intro to Programming in C/C++
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
This course introduces the fundamental programming concepts and techniques in Java (C/C++ for 109), the leading-edge language for Internet applications. The course is intended for all who plan to use computer programming in their studies and careers. Topics covered include: control structures, arrays, functions, recursion, dynamic memory allocation, simple data structures, files, and structured program design. Elements of object-oriented design and programming are also introduced. Students generally take only one of 600.107 or 600.109. Prereq: familiarity with computers. [Houlahan, General, Fall/Summer] 3 credits

Course Number/Name (Language): 600.104 (E) Computer Ethics - Theory and Practice
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
Students will examine a variety of issues regarding various policy, legal, and moral issues related to the computer science profession itself and to the proliferation of computers in all aspects of society, especially in the era of the Internet. The course will cover general issues related to various ethical frameworks and move to topics specifically related to computers. The topics will include privacy issues, the economic effects of a computerized society, computer law - especially copyright matters, and ethical responsibilities for computer science professionals. Short course. [staff, General] 1 credit

Course Number/Name (Language): 600.120 (E) Intermediate Programming
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
This course replaces 600.118 and 600.121 beginning Spring 2002. It covers intermediate to advanced object-oriented programming in both C++ and Java. The focus of the course is on programming techniques, class design, and the use of class libraries. Topics to be covered include: polymorphism, overloading, inheritance, pointers, dynamic memory allocation, templates, collections, exceptions, and others as time permits. Students are expected to learn syntax and low-level language features independently. Coursework involves significant programming projects in both languages. Prerequisites: 600.107 or 600.109. Students who have taken 600.118 or 600.121 may not take this course. They should register for 600.122 instead. [Wilson, General, Fall/Spring/Summer] 4 credits

Course Number/Name (Language): 600.226 (E,Q) Data Structures
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
This course covers the design and implementation of data structures including collections, sequences, trees, and graphs. Other topics include sorting, searching and hashing. Course work involves both written homework and Java programming assignments. An overview of Java will be provided. Prerequisite: 600.107 (preferred) or 600.109; intermediate programming highly recommended. [staff, General, Fall/Spring/Summer] 3 credits

Course Number/Name (Language): 600.271 (E,Q) Automata and Computation Theory
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
This course is an introduction to the theory of computing. Topics include design of finite state automata, pushdown automata, linear bounded automata, Turing machines and phrase structure grammars; correspondence between automata and grammars; computable functions, decidable and undecidable problems, P and NP problems, NP-completeness, and randomization. Prerequisite: none. [Kosaraju, General, Spring/Summer] 3 credits

Reqs Webpage: http://www.eecs.mit.edu/ug/brief-guide.html
Course Number/Name (Language): CS 6.001 Structure and Interpretation of Computer Programs (Scheme)
Course Webpage: http://sicp.csail.mit.edu/Spring-2006/
Course Syllabus: http://sicp.csail.mit.edu/Spring-2006/outcomes.htm
http://sicp.csail.mit.edu/Spring-2006/generalinfo_sp06.htm
Instructor (Title and Webpage if Available):
Professor Eric Grimson
http://www.csail.mit.edu/biographies/PI/bioprint.php?PeopleID=2008
Professor Trevor Darrell
http://www.csail.mit.edu/biographies/PI/bioprint.php?PeopleID=2012
Course Description(if available):
Control of complexity in large programming systems. Building abstractions: computational processes; higher-order procedures; compound data; and data abstractions. Controlling interactions: generic operations; self-describing data; message passing; streams and infinite data structures; and object-oriented programming. Meta-linguistic abstraction: interpretation of programming languages; machine model; compilation; and embedded languages. Substantial weekly programming assignments are an integral part of the subject. Enrollment may be limited. 4 Engineering Design Points.

Course Number/Name (Language): CS 6.002 Circuits and Electronics
Course Webpage: (Unlisted)
Course Syllabus: (Unlisted)
Instructor (Title and Webpage if Available):
Professor Jeffrey Lang
http://lees.mit.edu/lees/lang_j.htm
Professor Anant Agarwal
http://www.csail.mit.edu/biographies/PI/bioprint.php?PeopleID=161
Course Description(if available):
Fundamentals of the lumped circuit abstraction. Resistive elements and networks; independent and dependent sources; switches and MOS devices; digital abstraction; amplifiers; and energy storage elements. Dynamics of first- and second-order networks; design in the time and frequency domains; analog and digital circuits and applications. Design exercises. Alternate week laboratory. 4 Engineering Design Points.

Reqs Webpage: http://cs.nyu.edu/web/Academic/Undergrad/majors.html

Course Number/Name (Language): V22.0101 Introduction to Computer Science (FA/SP)
Course Webpage: http://www.cs.nyu.edu/courses/spring07/V22.0002-001/index.html
Course Webpage: http://www.cs.nyu.edu/courses/spring07/V22.0002-002/index.html
Course Webpage: http://www.cs.nyu.edu/courses/spring07/V22.0002-003/index.html
Course Webpage: http://www.cs.nyu.edu/courses/spring07/V22.0002-004/index.html
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):


Course Number/Name (Language): V22.0102 Data Structures (FA/SP)
Course Webpage: http://www.cs.nyu.edu/courses/spring07/V22.0004-001/index.html
Course Webpage: http://www.cs.nyu.edu/courses/spring07/V22.0004-002/index.html
Course Webpage: http://www.cs.nyu.edu/courses/spring07/V22.0004-003/index.html
Course Webpage: http://www.cs.nyu.edu/courses/spring07/V22.0004-004/index.html
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):

Reqs Webpage: http://www.cs.princeton.edu/academics/ugradpgm/program.php
Course Number/Name (Language): CS 126 General Computer Science
Course Webpage:http://www.cs.princeton.edu/courses/archive/fall06/cos126/
Course Syllabus: None Listed
Instructor (Title and Webpage if Available):
Professor of Computer Science Douglas Clark
http://www.cs.princeton.edu/~doug/
Course Description(if available):
An introduction to computer science in the context of scientific, engineering, and commercial applications. The goal of the course is to teach basic principles and practical issues, while at the same time preparing students to use computers effectively for applications in computer science, physics, biology, chemistry, engineering, and other disciplines. Topics include: programming in Java; hardware and software systems; algorithms and data structures; fundamental principles of computation; and scientific computing, including simulation, optimization, and data analysis.

Course Number/Name (Language): CS 217 Intro to Programming Systems (Java)
Course Webpage: http://www.cs.princeton.edu/courses/archive/fall06/cos217/
Course Syllabus: N/A
Instructor (Title and Webpage if Available):
Associate Professor David August
http://www.cs.princeton.edu/~august/
Course Description(if available):
The purpose of this course is to provide the fundamental background necessary to understand, design and implement the components of programming systems. Examples of such components include text editors, assemblers, compilers, loaders, interpreters, and portions of operating systems. The course is divided into three major parts: machine organization and assembly language programming, program design and development, and software tools.

Course Number/Name (Language): CS 226 Algorithms & Data Structures
Course Webpage: http://www.cs.princeton.edu/courses/archive/fall06/cos226/
Course Syllabus: N/A
Instructor (Title and Webpage if Available):
Senior Lecturer Kevin Wayne
http://www.cs.princeton.edu/~wayne/contact/
Course Description(if available):
The study of fundamental data structures such as lists, queues, stacks, trees, heaps, hash tables, and their variations. The implementation and analysis of important algorithms for sorting, searching, string processing, geometric applications, graph manipulation, and matrix operations. Introduction to advanced algorithms and techniques. Prerequisite: COS 126.

Short overview of the program, not fully detailed.
Reqs Webpage: http://www.cs.purdue.edu/academic_programs/undergraduate/
Undergraduate Plan of Study Not Readily Available
Course Number/Name (Language):
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):

Reqs Webpage: http://compsci.rice.edu/academics.cfm?doc_id=4301
Course Number/Name (Language): CS 210 Principals of Computing and Programming (Scheme)
Course Webpage: http://www.owlnet.rice.edu/~comp210/
Course Syllabus: Unlisted
Instructor (Title and Webpage if Available):
Walid Taha
http://www.cs.rice.edu/%7Etaha/
Lecturer John Greiner
http://www.cs.rice.edu/%7Egreiner/
Course Description(if available):
Introduction to the principles of computer programming. Includes functional programming, data abstraction, procedural abstraction, reduction rules, use of control and state, object-oriented programming, program optimization, algorithm efficiency. Students will learn the practical skills required to write and modify programs. Laboratory assignments use Scheme. May not receive credit for COMP 211 after taking COMP 210. Required for computer science majors. Offered Fall.

Course Number/Name (Language): CS 212 Intermediate Programming (Java)
Course Webpage: http://www.owlnet.rice.edu/~comp212/06-spring/
Course Syllabus: http://www.owlnet.rice.edu/~comp212/06-spring/syllabus.shtml
Instructor (Title and Webpage if Available):
Alan Cox
Unlisted
Dung Nguyen
http://www.owlnet.rice.edu/~dxnguyen/
Course Description(if available):
This course focuses on teaching students how to apply the principles of program design taught in COMP 210 to the context of object-oriented programming using JAVA. Many of these principles are codified in an object-oriented context as object-oriented design patterns. The course also covers basic algorithms and data structures from an object-oriented perspective. Pre-requisite(s): COMP 210. Offered Spring.

Course Number/Name (Language): CS 280 Mathemtics of Computation
Course Webpage: http://www.owlnet.rice.edu/~comp280/06spring/
Course Syllabus: Unlisted
Instructor (Title and Webpage if Available):
Lecturer John Greiner
http://www.cs.rice.edu/%7Egreiner/
Course Description(if available):
This course provides an introduction to the use of mathematics in modeling and reasoning about problems in computer science. Topics include logic, proof methods (including mathematical and structural induction), reasoning about recursive and iterative programs, sets, functions and their asymptotic growth, counting, and modular arithmetic. Pre-requisite(s): COMP 210. Corequisite(s): MATH 102. Offered Spring.

Reqs Webpage (BA): http://www.cs.rutgers.edu/undergraduate/newBA.whtml
Reqs Webpage (BS): http://www.cs.rutgers.edu/undergraduate/newBS.whtml

Course Number/Name (Language): 01:198:111 - Introduction to Computer Science
Course Webpage: http://www.cs.rutgers.edu/undergraduate/courses/111
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
Intensive introduction to computer science. Problem solving through decomposition. Writing, debugging, and analyzing programs in Java. Algorithms for sorting and searching. Introduction to data structures, recursion.

Course Number/Name (Language): 01:198:112 - Data Structures
Course Webpage: http://www.cs.rutgers.edu/undergraduate/courses/112
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
To investigate the essential properties of data structures and algorithms for operating on them; to use these structures as tools to assist algorithm design; to extend exposure to searching, sorting and hashing techniques.

Course Number/Name (Language): 01:198:205 - Introduction to Discrete Structures I
Course Webpage: http://www.cs.rutgers.edu/undergraduate/courses/205
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
To introduce the student to the mathematical tools of logic and induction, and to the basic definitions and theorems concerning relations, functions, and sets. Later courses in the computer science curriculum build on the mathematical foundations covered here. Particular emphasis is placed on inductive definitions and proofs, with application to problems in computer science.

Reqs Webpage: http://cs.stanford.edu/degrees/undergrad/Thinking.shtml
Course Number/Name (Language): CS 106X Programming Abstractions in C++ (C++)
Course Webpage: http://www.stanford.edu/class/cs106x/
Course Syllabus: http://www.stanford.edu/class/cs106x/handouts/01-Course-Information.pdf
Instructor (Title and Webpage if Available):
Lecturer Jerry Cain
(Unlisted)
Course Description(if available):
This course combines 90 percent of the material in CS 106A and CS 106B into a single course. In order to get through that much material in a quarter, CS 106X moves at an incredible pace. If you’ve had previous programming experience, this class is an excellent way to learn C++ and brush up on your skills. If you haven’t done much programming before, you should take the CS 106A/B sequence instead. Don’t let anyone tell you that real engineers take CS 106X. These days, most computer scientists and engineers start with CS 106A, where they do just fine. The last thing you want to do is get in over your head. CS 106X meets MWF at 9:30 in Gates B03.

Reqs Webpage: http://www.eecs.berkeley.edu/Prospective/ugrad.shtml
Course Number/Name (Language): CS61A Structure and Interpretation of Computer Programs (Scheme)
Course Webpage: http://www-inst.eecs.berkeley.edu/~cs61a/su06/
Course Syllabus: http://www-inst.eecs.berkeley.edu/~cs61a/su06/handout0.pdf
Instructor (Title and Webpage if Available):
PhD Candidate Ana Chang (SUMMER INSTRUCTOR)
http://www.cs.berkeley.edu/~anar/
Course Description(if available):
Students will receive no credit for 61A after taking 47A. Three hours of lecture, one and one-half hours of discussion, and one and one-half hours of laboratory and two and one-half hours of unscheduled laboratory per week. Prerequisites: Mathematics 1A (may be taken concurrently); programming experience equivalent to that gained in 3 or the Advanced Placement Computer Science A course. Introduction to programming and computer science. This course exposes students to techniques of abstraction at several levels: (a) within a programming language, using higher-order functions, manifest types, data-directed programming, and message-passing; (b) between programming languages, using functional and rule-based languages as examples. It also relates these techniques to the practical problems of implementation of languages and algorithms on a von Neumann machine. There are several significant programming projects, programmed in a dialect of the LISP language. (F,SP) Clancy, Garcia, Harvey

Course Number/Name (Language): CS61B Data Structures (Java)
Course Webpage: http://www-inst.eecs.berkeley.edu/~cs61b/su06/
Course Syllabus: http://www-inst.eecs.berkeley.edu/~cs61b/su06/syllabus.pdf
Instructor (Title and Webpage if Available):
Erin Korber (SUMMER INSTRUCTOR)
(Unlisted)
Course Description(if available):
Three hours of lecture, one hour of discussion, two hours of programming laboratory, and an average of six hours of self-scheduled programming laboratory per week. Prerequisites: A grade of B- or better in 61A or Engineering 77.Fundamental dynamic data structures, including linear lists, queues, trees, and other linked structures; arrays strings, and hash tables. Storage management. Elementary principles of software engineering. Abstract data types. Algorithms for sorting and searching. Introduction to the Java programming language. (F,SP) Clancy, Hilfinger, Yelick

Reqs Webpage: http://www.ics.uci.edu/ugrad/degrees/index.php?track=cse

Course Number/Name (Language): ICS 21 - Intro to Computer Science I
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
First of a three-quarter introductory course. Introduces fundamental concepts related to computer software design and construction. Develops initial design and programming skills using a high-level programming language (primarily C++/Java). Introduces useful computer-based tools for analysis, expression, discovery. Same as CSE 21. Only one course from ICS 21/CSE21 and ICS H21 may be taken for credit.

Course Number/Name (Language): ICS 22 - Intro to Computer Science II
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
Second of a three-quarter introductory sequence. Abstract behavior of classic data structures (stacks, queues, priority queues, tables, trees), alternative implementations, analysis of time and space efficiency. Recursion. Object-oriented and functional programming. Models of computation. Prerequisite: ICS 21/CSE21 with a grade of C or better. Same as CSE 22. Only one course from ICS 22/CSE22, ICS H22 or Informatics 42 may be taken for credit.

Course Number/Name (Language): ICS 23 - Fundamental Data Structure
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
Focuses on implementation and mathematical analysis of fundamental data structures and algorithms. Covers storage allocation and memory management techniques. Prerequisites: ICS 22/ CSE22 with a grade of C or better or Engineering EECS40; Mathematics 6A or ICS 6A. Same as CSE 23. Only one course from ICS 23/CSE23 and ICS H23 may be taken for credit.

Course Number/Name (Language): ICS 51 - Introductory Computer Organization
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):

Multilevel view of system hardware and software. Operation and interconnection of hardware elements. Instruction sets and addressing modes. Virtual memory and operating systems. Laboratory work using low-level programming languages. Prerequisites: ICS 21/CSE 21 with a grade of C or better; Mathematics 6B.
Course Number/Name (Language): ICS 52 - Intro to Software Engineering
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
Introduction to the concepts, methods, and current practice of software engineering. The study of large-scale software production; software life cycle models as an organizing structure; principles and techniques appropriate for each stage of production. Laboratory work involves a project illustrating these elements. Prerequisite: ICS 23/CSE 23 with a grade of C or better. ICS 52 and Informatics 43 may not both be taken for credit.

Reqs Webpage: http://www.seasoasa.ucla.edu/curric05_06.html/HTML/compsci.html
Course Number/Name (Language): CS31
Course Webpage: (WEBSITE DOWN Consult: http://websrv.seas.ucla.edu:8901/listClasses.php?subarea=COM+SCI)
Course Syllabus: (WEBSITE DOWN Consult: http://websrv.seas.ucla.edu:8901/listClasses.php?subarea=COM+SCI)
Instructor (Title and Webpage if Available):
Course Description(if available):

Course Number/Name (Language): CS32
Course Webpage: (WEBSITE DOWN Consult: http://websrv.seas.ucla.edu:8901/listClasses.php?subarea=COM+SCI)
Course Syllabus: (WEBSITE DOWN Consult: http://websrv.seas.ucla.edu:8901/listClasses.php?subarea=COM+SCI)
Instructor (Title and Webpage if Available):
Course Description(if available):

Reqs Webpage: http://www.cse.ucsd.edu/undergrad/undergradeduhome.html
Course Number/Name (Language): CSE 91 Perspectives in Computer Science and Engineering (Unlisted)
Course Webpage: (Unlisted)
Course Syllabus: (Unlisted)
Instructor (Title and Webpage if Available):
(Unlisted)
Course Description(if available):
The intention is that this requirement will be in place for new students entering Fall 2004. The purpose of the course is to apprise new students of what is actually involved in doing computer science, the better to orient them early toward research opportunities, graduate study, and industry careers. For new CSE majors. A seminar format discussion led by CSE faculty on topics in central areas of computer science, concentrating on the relation among them, recent developments and future directions. 1.5 hours of seminar per week, 1.5 hours of outside preparation. Majors only. Fall quarter.

Course Number/Name (Language): CS11 Inreoduction to Computer science and Object-Oriented Programming- Java (Java)
Course Webpage: http://www.cse.ucsd.edu/classes/su06/cse11/
Course Syllabus: http://www.cse.ucsd.edu/classes/su06/cse11/
Instructor (Title and Webpage if Available):
(Unlisted)
Course Description(if available):
Introduction to computer science and programming using the Java language. Basic UNIX. Modularity and abstraction. Documentation, testing and verification techniques. Basic object-oriented programming including inheritance and dynamic binding. Exception handling. Event driven programming. Experience with AWT library or other similar library. 3 hours of lecture per week, 1 hour of discussion section, 3 hours of computer lab and 5 hours of outside preparation.High school algebra and a course in programming in a compiled language. Programming assignments Every quarter: Fall, Winter, and Spring.

Course Number/Name (Language): CSE12 - Basic Data Structures and Object-Oriented Design
Course Webpage: http://www.cse.ucsd.edu/classes/sp06/cse12/
Course Syllabus: http://www.cse.ucsd.edu/classes/sp06/cse12/syllabus.html
Instructor (Title and Webpage if Available):
Lecturr Gary Gillespie
(Unlisted)
Course Description(if available):
Basic data structures including stacks, queues, lists, binary trees, and hash tables. Basic object-oriented design including encapsulation, polymorphism, classes as the implementation of abstract data types. Memory management, pointers, recursion, and “big-o” notation. Uses the C/C++ and Java programming languages.

Course Number/Name (Language): CSE20 - Discrete Mathematics
Course Webpage: http://www.cse.ucsd.edu/classes/sp06/cse20/
Course Syllabus: http://www.cse.ucsd.edu/classes/sp06/cse20/syllabus.html
Instructor (Title and Webpage if Available):
Alon Orlitsky
http://ece.ucsd.edu/~alon/
Course Description(if available):
Basic discrete mathematical structure; sets relations, functions, sequences, equivalence relations, partial orders, and number systems. Methods of reasoning and proofs; propositional logic, predicate logic, induction, recursion, and pigeonhole principle. Infinite sets and diagonalization. Basic counting techniques; permutation and combinations. Applications will be given to digital logic design, elementary number theory, design of programs, and proofs of program correctness.

Reqs Webpage: http://www.cs.uiuc.edu/undergraduate/programs.php
Course Number/Name (Language): CS 100 Freshman Orientation in CS (Unlisted)
Course Webpage: http://www.cs.uiuc.edu/class/cs100/
Course Syllabus: http://www.cs.uiuc.edu/class/cs100/
Instructor (Title and Webpage if Available):
Associate Professor Samuel Kamin
http://www.cs.uiuc.edu/directory/directory.php?name=kamin
Course Description(if available):
Introduction to Computer Science as a field and career for computer science majors. Overview of the field is presented along with specific examples of problem areas and methods of solution. Recommended for all freshman Computer Science majors.

Course Number/Name (Language): CS 125 Introduction to Computer Science (Unlisted)
Course Webpage: http://www.cs.uiuc.edu/class/cs125/
Course Syllabus: (Unlisted)
Instructor (Title and Webpage if Available):
(Unlisted)
Course Description(if available):
First course for computer science majors and other students with a deep interest in computing. The course introduces students to basic concepts in computing and fundamental techniques for solving computational problems.

Course Number/Name (Language): CS 173 Discrete Structures
Course Webpage: http://www.cs.uiuc.edu/class/cs173/
Course Syllabus: (Unlisted)
Instructor (Title and Webpage if Available):
(Unlisted)
Course Description(if available):
Studies discrete mathematical structures frequently encountered in the study of Computer Science. Topics will include sets, propositions, boolean algebra, induction, recursion, relations, functions, and graphs. Credit is not given for both <a href=”../CS/173.html”>CS 173</a> and <a href=”../MATH/213.html”>MATH 213</a>.

Reqs Webpage: http://www.cs.umd.edu/Ugrad/current/MajorReqs.shtml
Course Number/Name (Language): CSMC 131 Object-Oriented Programming (Java)
Course Webpage: http://www.cs.umd.edu/class/spring2005/cmsc131/index.shtml
Course Syllabus: http://www.cs.umd.edu/class/spring2005/cmsc131/syllabus.shtml
Instructor (Title and Webpage if Available):
Professor Bonnie Dorr
http://www.umiacs.umd.edu/~bonnie/index.html
Nelson Padua-Perez
http://www.cs.umd.edu/~nelson/
Course Description(if available):\\This is a first programming course for Computer Science majors with a focus on object-oriented programming. The goal of the course is to develop skills such as program design and testing as well as the implementation of programs using a graphical IDE. All programming will be done in Java.This is a challenging course, but it is fun. There will be several programming assignments. Each aims to provide experience with the basic elements of programming such as loops, arrays, and inheritance. The assignments also try to show how programming can be useful and fun, and how even relatively simple constructs can accomplish real tasks. Assignments will include picture manipulation and games. For further information, please see the course syllabus.

Course Number/Name (Language): CSMC 132 Object-Oriented Programming II (Java)
Course Webpage: http://www.cs.umd.edu/class/spring2005/cmsc132/index.shtml
Course Syllabus: http://www.cs.umd.edu/class/spring2005/cmsc132/syllabus.shtml
Instructor (Title and Webpage if Available):
Fawzi Emad
http://www.cs.umd.edu/~fpe
Associate Professor Chau-Wen Tseng
http://www.cs.umd.edu/~tseng/
Course Description(if available):
This is a second programming course for Computer Science majors with a focus on object-oriented programming. The goal of the course is to develop skills such as program design and testing as well as the implementation of programs using a graphical IDE. All programming will be done in Java. For further information, please see the course syllabus.

Course Number/Name (Language): CMSC 212 INTRODUCTION TO LOW-LEVEL PROGRAMMING CONCEPTS (Java)
Course Webpage: (Unlisted)
Course Syllabus: http://www.cs.umd.edu/Ugrad/NewIntro/cmsc212-syllabus.shtml
Instructor (Title and Webpage if Available):
(Unlisted)
Course Description(if available):
Introduction to many of the concepts that lie behind software, such as hardware, memory layout, memory management, and operating systems. Explain how these concepts affect the design of software systems. Provids transition from the Java environment of preceding two courses to programming in C.

Course Number/Name (Language): CMSC 250 INTRODUCTION TO DISCRETE STRUCTURES
Course Webpage:(Unlisted)
Course Syllabus: http://www.cs.umd.edu/Ugrad/syllabi/250.html
Instructor (Title and Webpage if Available):
(Unlisted)
Course Description(if available):
Fundamental mathematical concepts related to computer science, including finite and infinite sets, relations, functions, and propositional logic. Introduction to other techniques, modeling and solving problems in computer science. Introduction to permutations, combinations, graphs, and trees with selected applications.

Reqs Webpage: http://www.cs.umass.edu/csinfo/uginfo/underreqs.html

Course Number/Name (Language): CmpSci 121 Introduction to Problem Solving Using the Computer (Java)
Course Webpage: http://www-edlab.cs.umass.edu/cs121
Course Syllabus: http://www-edlab.cs.umass.edu/cs121/syllabus.html
Instructor (Title and Webpage if Available): Learned-Miller http://www.cs.umass.edu/~elm
Course Description(if available):
An introductory course in problem solving and computer programming using the programming language Java. The course focuses on the fundamental concepts of problem solving and the techniques associated with the development of algorithms and their implementation as computer programs. This course or its equivalent is required for all additional courses in CMPSCI. Three hours of lecture/recitation per week. About 7 programming projects are assigned. In addition there are assigned homework problems, a midterm exam and a final. No computer science prerequisite, although basic math skills (e.g. R1) and basic computer literacy (as taught in CMPSCI 105) are assumed. Use of computer is required. Prerequisite: R1. 3 credits.

Course Number/Name (Language): CmpSci 191B (aka CompSci 123) Introduction to Java II (Java)
Course Webpage: http://www-edlab.cs.umass.edu/cs123
Course Syllabus:
Instructor (Title and Webpage if Available): Lehnert http://www.cs.umass.edu/~lehnert/
Course Description(if available):
CmpSci 191B (123) is a programming course in Java for students who have previous programming experience in Java, C or C++. Students will be introduced to a variety of advanced topics such as inheritance, polymorphism, interface design, threads, and design patterns. Object-oriented concepts will be covered in great detail, but 123 assumes general familiarity with basic programming concepts such as arithmetic operators, boolean operators, conditional control structures, iterative control structures, and arrays. Students will have an opportunity to strengthen object-oriented programming skills through a series of required programming projects.

Course Number/Name (Language): CmpSci 187 Programming with Data Structures (Java)
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available): Allan http://ciir.cs.umass.edu/~allan/
Course Description(if available):
The course introduces and develops methods for designing and implementing abstract data types, using the Java programming language. The main focus is on how to build and encapsulate data objects and their associated operations. Specific topics include linked structures, recursive structures and algorithms, binary trees, balanced trees, and hash tables. There will be weekly assignments, consisting of programming and written exercises, a midterm, and a final exam. Prerequisites: CMPSCI 123 (191B) (or equivalent-not necessarily in Java) and Basic Math Skills (R1). Basic Java language concepts are introduced quickly. Prior experience with an object-oriented language is very helpful; if unsure of background, contact instructor. 4 credits.

Reqs Webpage: http://www.eecs.umich.edu/eecs/undergraduate/ugcslsa/CSLSA2005-06.html
Course Number/Name (Language): EECS203 Discrete Mathematics (Unlisted)
Course Webpage: (Unlisted)
Course Syllabus: (Unlisted)
Instructor (Title and Webpage if Available):
(Unlisted)
Course Description(if available):
(Unlisted)

Course Number/Name (Language): EECS 280 Data Structures and Algorithms (C++)
Course Webpage: http://www.eecs.umich.edu/~guskov/281/
Course Syllabus: http://www.eecs.umich.edu/~guskov/281/
Instructor (Title and Webpage if Available):
Assistant Professor Igor Guskov
http://www.eecs.umich.edu/~guskov/
Course Description(if available):
Introduction to algorithm analysis and O-notation. Fundamental data structures including lists, stacks, queues, priority queues, hash tables, binary triees, search trees, balanced trees and graphs. Searching and sorting algorithms, recursive algorithms, basic graph algorithms. Introduction to greedy algorithms and divide-and-conquer strategy. Several programming assignments.

Reqs Webpage: http://www.cs.unc.edu/Admin/AcademicPrograms/
Course Number/Name (Language): CS 114 Foundations of Programming (Java)
Course Webpage: http://www.cs.unc.edu/%7Ehedlund/comp114/
Course Syllabus: (Unlisted)
Instructor (Title and Webpage if Available):
Associate Professor Kye Hedlund
http://www.cs.unc.edu/~hedlund/
Course Description(if available):
Introduction to the basic principles of computer programming in the small: algorithms, data structures, basic principles of object oriented programming, and survey material. Principles will be illustrated through programming exercises and written assignments. Students will develop skills and techniques for good programming ‘in the small.’ The course will emphasize a mathematical approach to the subject matter. Characterizing how a program works (via documentation and assertions) will be considered as important as producing a program that apparently produces the correct answers.

Reqs Webpage: http://www.cis.upenn.edu/ugrad/
Course Number/Name (Language): CS120 Programming Languages and Techniques I (Java, Python, C)
Course Webpage: http://www.seas.upenn.edu/%7Ecse120/
Course Syllabus: http://www.seas.upenn.edu/%7Ecse120/syllabus.shtml
Instructor (Title and Webpage if Available):
Professor Fernando Pereira
http://www.cis.upenn.edu/~pereira
Course Description(if available):
(Fall semester only; Corequisite: CSE 130) This will be a fast-paced introduction to the fundamental concepts of programming, with Java as the main experimental vehicle. In contrast to previous editions of this course, this Fall we will assume some previous programming experience at the level of a high school computer science class. If you got at least 4 in the AP Computer Science A or AB exam, you will do great. However, we do not assume you know Java. Basic experience with any programming language (for instance C, C++, VB, PHP, Perl, or Scheme) will be sufficient. A quiz will be given in the second week of class to test your programming knowledge so that you can decide whether the class is for you. If you have never programmed before, you should take CSE 110 first. We will mainly use Java and the DrJava programming environment, but we will also experiment lower-level (C) and higher-level (Python) languages.

Course Number/Name (Language): CS 121 Programming Languages and Techniques (Java)
Course Webpage: http://www.seas.upenn.edu/%7Ecse121/
Course Syllabus: http://www.seas.upenn.edu/%7Ecse121/syllabus.shtml
Instructor (Title and Webpage if Available):
Professor Val Tannen
http://www.cis.upenn.edu/~val/home.html
Course Description(if available):
(Spring semester only; Prerequisite: CSE 120; Corequisite: CSE 131. CSE 260 is a pre or co-requisite for CSE121). How do you write well-designed programs? We learn how to specify programs, how to prove that they are correct and have the expected performance, and how to organize information in data structures and process it with efficient algorithms. We also introduce software engineering methods including modular design, generic and reusable code, and design patterns. Java programming is used throughout to illustrate and exercise the course concepts.

Reqs Webpage (BS - Games): http://www.cs.usc.edu/current/undergrad/BS-GameDevelopment.pdf
Reqs Webpage (BS - CS & Bus Admin): http://www.cs.usc.edu/current/undergrad/CSBA.pdf
Reqs Webpage (BS - CS): http://www.cs.usc.edu/current/undergrad/CSBRO.pdf
Reqs Webpage (BS - CS Eng): http://www.cs.usc.edu/current/undergrad/CECSBRO.pdf

Course Number/Name (Language): CS 101L - Fundamentals of Computer Programming
Course Webpage: http://www-scf.usc.edu/~csci101
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
Introduction to the design of solutions to computer solvable problems. Algorithm design, solution implementation using a high-level programming language, program correctness and verification.

Course Number/Name (Language): CS 102L - Data Structures
Course Webpage: http://www-scf.usc.edu/~csci102
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
Linear lists, strings, arrays, and orthogonal lists; graphs, trees, binary trees, multilinked structures, sorting techniques; dynamic storage allocation; applications.

Course Number/Name (Language): CS 105 - Object Oriented Programming
Course Webpage: http://www-scf.usc.edu/~csci105
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
The principles of object-oriented programming are examined using Java. Topics include graphics, graphical user interfaces and multi-threaded programming.

Reqs Webpage: http://academics.cs.utexas.edu/undergraduate/degrees_courses/checklists.html
Course Number/Name (Language): CS 307 Fundamentals of Computer Science (Java)
Course Webpage: http://www.cs.utexas.edu/%7Escottm/cs307/
Course Syllabus: http://www.cs.utexas.edu/%7Escottm/cs307/syllabusSummer.htm
Instructor (Title and Webpage if Available):
Lecturer Mike Scott (SUMMER INSTRUCTOR)
http://www.cs.utexas.edu/%7Escottm/index.htm
Course Description(if available):
This is a second course in computer programming. The purposes of the course are to learn fundamental computer science concepts including data types, data structures (lists, stacks, queues, and trees), and algorithms; recursion; data abstraction and encapsulation; correctness: specification, testing, and proving. Object oriented design and implementation. Introduction to reasoning about programs correctness and efficiency. The course is taught using Java.

Course Number/Name (Language): CS 315 Algorithms and Data Structures (Java)
Course Webpage: http://www.cs.utexas.edu/users/downing/cs315/
Course Syllabus: N/A
Instructor (Title and Webpage if Available):
Lecturer Glenn Downing http://www.cs.utexas.edu/users/downing/
Course Description(if available):
This is a course on algorithms and data structures and will be taught exclusively using Java and the Java Collections Framework (JCF) Estimates of the required effort to do well are: 1. 5 hours per week of studying. 2. 10 hours per week of programming. 3. 5,000 lines of Java code. prerequisites CS315 and CS315h may not both be counted, CS307 with a grade of at least C and credit or registration for PHL313k. A working knowledge of Java is assumed.

Course Number/Name (Language): CS 313K Logic Sets and Functions
Course Webpage: dead link
Course Syllabus: dead link
Instructor (Title and Webpage if Available):
Lecturer Mary Eberlein http://www.cs.utexas.edu/~eberlein/
Course Description(if available): dead link.

Reqs Webpage (BA - CS): http://www.cs.virginia.edu/undergrad_program/ba-cs-degree-plan.html
Reqs Webpage (BS - CS): http://www.cs.virginia.edu/undergrad_program/bs-cs-degree-plan.html
Reqs Webpage (BS - CS Eng): http://www.cpe.virginia.edu/UG%20Curriculum.html

Course Number/Name (Language): CS 101 - Intro to Computer Science
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
Introduces the basic principles and concepts of object-oriented programming through a study of algorithms, data structures and software development methods in Java. Emphasizes both synthesis and analysis of computer programs. (S)

Course Number/Name (Language): CS 201 - Software Development Methods
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
A continuation of CS 101, emphasizing modern software development methods. An introduction to the software development life cycle and processes. Topics include requirements analysis, specification, design, implementation, and verification. Emphasizes the role of the individual programmer in large software development projects. (S)

Course Number/Name (Language): CS 216 - Program and Data Representation
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
Introduces programs and data representation at the machine level. Data structuring techniques and the representation of data structures during program execution. Operations and control structures and their representation during program execution. Representations of numbers, arithmetic operations, arrays, records, recursion, hashing, stacks, queues, trees, graphs, and related concepts. (S)

Course Number/Name (Language): CS 230 - Digital Logic Design
Course Webpage:
Course Syllabus:
Instructor (Title and Webpage if Available):
Course Description(if available):
Includes number systems and conversion; Boolean algebra and logic gates; minimization of switching functions; combinational network design; flip-flops; sequential network design; arithmetic networks. Introduces computer organization and assembly language. Cross-listed as ECE 230. (S)

Reqs Webpage: http://www.cs.washington.edu/education/ugrad/current/New_CS_reqs.pdf
Course Number/Name (Language): CS 142 Computer Programming I (Java)
Course Webpage: http://www.cs.washington.edu/education/courses/142/06su/
Course Syllabus: http://www.cs.washington.edu/education/courses/142/06su/syllabus142.html
Instructor (Title and Webpage if Available):
Carl Ebeling (SUMMER INSTRUCTOR)
http://www.cs.washington.edu/homes/ebeling/
Course Description(if available):
Basic programming-in-the-small abilities and concepts. Highlights include procedural and functional abstraction with simple built-in data type manipulation. Basic abilities of writing, executing, and debugging programs.

Course Number/Name (Language): CS 143 Computer Programming II (Java)
Course Webpage: http://www.cs.washington.edu/education/courses/143/06su/
Course Syllabus: http://www.cs.washington.edu/education/courses/143/06su/syllabus.html
Instructor (Title and Webpage if Available):
Andrew Peterson (SUMMER INSTRUCTOR)
http://www.cs.washington.edu/homes/petersen
Course Description(if available):
Continuation of 142. Concepts of modularity and encapsulation, focusing on modules and abstract data types. Covers some basic data structures.

Reqs Webpage: http://www.cs.wisc.edu/%7Epubs/ugrad-guidebook/node3.html
Course Number/Name (Language): CS 240 Introduction to Discrete Mathematics (Unlisted)
Course Webpage: Unlisted
Course Syllabus: Unlisted
Instructor (Title and Webpage if Available): Unlisted
Course Description(if available):
Basic concepts of logic, sets, partial order and other relations, and functions. Fundamental principles of counting. Basic algebraic structures: modulo arithmetic, group, ring, and field structures, Boolean algebra. Introduction to graph theory: trees, depth first search, matching, max-flow min-cut, and other optimization algorithms. Applications. Prereq: Math 221.

Course Number/Name (Language): CS 302 Introduction to Programming (Unlisted)
Course Webpage: Unlisted
Course Syllabus: Unlisted
Instructor (Title and Webpage if Available): Unlisted
Course Description(if available):
Instruction and experience in the use of an object-oriented programming language. Program design; development of good programming style; preparation for other Computer Science courses. Prereq: Problem solving skills such as those acquired in a statistics, logic, or advanced high school algebra course; or consent of instructor. Open to Fr.

Reqs Webpage: http://www.cs.yale.edu/ugrad/handbook/node18.html
Course Number/Name (Language): CptSci 201 - Introduction to Computer Science (Scheme)
Course Webpage: http://zoo.cs.yale.edu/classes/cs201/
Course Syllabus: http://zoo.cs.yale.edu/classes/cs201/Spring_2006/syllabus.html
Instructor (Title and Webpage if Available):
Professor Dana Angluin
http://www.cs.yale.edu/people/angluin.html
Course Description(if available):
The course requirements consist of class attendance, (more-or-less) weekly programming assignments in Scheme and occasional written homework, and two in-class exams. There will be no final exam. Plan on spending between 6-8 hours per week on the course outside of class. The programming assignments are an integral part of the course. Please try not to leave the homework to the last minute. You will be more efficient, learn more, have more chance to get help, and generally be calmer and happier if you do the associated reading first and start the programming or other problems early.

Course Number/Name (Language): CS 223: Data Structures and Programming Techniques (C)
Course Webpage: http://zoo.cs.yale.edu/classes/cs223/2006s/
Course Syllabus: http://zoo.cs.yale.edu/classes/cs223/2006s/syllabus.html
Instructor (Title and Webpage if Available):
Professor Michael Fischer
http://cs-www.cs.yale.edu/homes/fischer/index.html
Course Description(if available):
This course covers four main topics:
1. The C programming language, the standard C library, and tools for building software written in C.
2. Fundamental data structures for problem solving, including arrays, stacks, queues, lists, trees, heaps, and graphs.
3. Fundamental algorithms for sorting, searching, and storage allocation and management.
4. Techniques for the specification, design, verification, testing, debugging, and performance tuning of software.

Course Number/Name (Language): CPSC 323 Introduction to Systems Programming and Computer Organization
Course Webpage: http://zoo.cs.yale.edu/classes/cs323
Course Syllabus: http://zoo.cs.yale.edu/classes/cs323/Syllabus.html
Instructor (Title and Webpage if Available):
(Unlisted)
Course Description(if available):
(Unlisted)

Course Number/Name (Language): Computer Science 365b, Design and Analysis of Algorithms
Course Webpage: http://zoo.cs.yale.edu/classes/cs365/index.html
Course Syllabus: http://zoo.cs.yale.edu/classes/cs365/schedule.html
Instructor (Title and Webpage if Available):
Professor Daniel Spielman
http://www.cs.yale.edu/homes/spielman/
Course Description(if available):
(Unlisted)