Contacts | Program of Study | Program Requirements | Summary of Requirements | Grading | Honors | Recommended Sequences in Computer Science | Minor Program in Computer Science | Joint BA/MS or BS/MS Program | Graduate Courses | Courses
Department Website: http://www.cs.uchicago.edu
Program of Study
The computer science program prepares students for either graduate work or employment in computer science by offering both the BA and BS degrees. Students receiving the BA will have sufficient breadth and depth for either graduate study or immediate employment in computer science. Recipients of the BS will also have substantial depth and breadth in a field outside of computer science through the completion of an approved related area.
Students in other fields of study may complete a minor in computer science. Information follows the description of the major.
Program Requirements
Both the BA and BS in computer science require fulfillment of the mathematical sciences requirement in general education by completing an approved two-quarter calculus sequence. The physical sciences requirement in general education must be satisfied by completing an approved two-quarter sequence in either chemistry or physics. Both BA and BS students take at least fourteen computer science courses chosen from an approved program. BS students also take three courses in an approved related field outside computer science.
Students pursuing a bachelor's degree in computer science should note that by judicious choice of courses from another field a supplementary field can be developed that is often in itself a solid basis for graduate or professional work in that field. Some examples are biology, biophysics, chemistry, geophysical sciences, history, linguistics, mathematics, philosophy, political science, psychology, physics, sociology, statistics, and economics.
Advanced Placement
Students who are majoring in computer science may not use AP credit for computer science to meet requirements in the major. Students with AP scores of 4 or 5 on Computer Science A from May 2010 forward or Computer Science AB prior to that receive two quarters of elective credit. NOTE: Students must forgo AP elective credit if they register for one of the following:
| CMSC 10500 | Fundamentals of Computer Programming I | 100 |
| CMSC 10600 | Fundamentals of Computer Programming II | 100 |
| CMSC 15100 | Introduction to Computer Science I | 100 |
| CMSC 15200 | Introduction to Computer Science II | 100 |
Students who enroll in CMSC 12100 Computer Science with Applications I, CMSC 12200 Computer Science with Applications II, CMSC 16100 Honors Introduction to Computer Science I, and CMSC 16200 Honors Introduction to Computer Science II may retain AP elective credit.
Computer science majors may use AP credit for chemistry or physics to meet their physical sciences requirement in general education or physical science components of the major. However, no credit designated simply as "physical science" (from either AP or the College's physical sciences examinations) may be used to meet general education or requirements in the computer science majors.
Approved Programs
The notion of "approval" in the program requirements allows timely response to change in the course offerings of the various departments. The computer science department counselor is responsible for approval of specific courses and sequences. Students should consult the department counselor for details on specific courses they are considering taking to meet the requirements.
Approved Computer Science Program
For the authoritative version of the Department of Computer Science requirements and course descriptions, visit http://www.cs.uchicago.edu.
There is a single approved program comprising required courses in four topical areas, plus four elective computer science courses. This is a general program in computer science and is used for either the BA or the BS degree. Upper-level or graduate courses in similar topics may be substituted for those on the list that follows, with the approval of the department counselor.
Students considering a computer science major are strongly advised to register for an introductory sequence in their first year.
1. Introductory Sequence (three courses required):
| CMSC 15100 | Introduction to Computer Science I | 100 |
| or CMSC 16100 | Honors Introduction to Computer Science I | |
| CMSC 15200 | Introduction to Computer Science II | 100 |
| or CMSC 16200 | Honors Introduction to Computer Science II | |
| CMSC 15400 | Introduction to Computer Systems | 100 |
Students may only receive credit for one introductory programming sequence: CMSC 10500-10600 Fundamentals of Computer Programming I-II, CMSC 12100-12200 Computer Science with Applications I-II, CMSC 15100-15200 Introduction to Computer Science I-II, or CMSC 16100-16200 Honors Introduction to Computer Science I-II. Exceptions must be approved by the department counselor prior to taking the second sequence.
2. Programming Languages and Systems Sequence (two courses required):
| Two of the following: | ||
| Programming Languages | ||
| Computer Architecture | ||
| Functional Programming | ||
| Implementation of Computer Languages I | ||
| Operating Systems | ||
| Introduction to Computer Security | ||
| Networks and Distributed Systems | ||
| Mobile Computing | ||
| Introduction to Database Systems | ||
| Introduction to Computer Graphics | ||
| Scientific Visualization | ||
| Game Construction | ||
3. Algorithms and Theory Sequence (three courses required):
| Three of the following: | ||
| Discrete Mathematics | ||
| Theory of Algorithms | ||
| Introduction to Formal Languages | ||
or CMSC 28100 | Introduction to Complexity Theory | |
4. Other Sequences (one two-course sequence required):
| Artificial Intelligence Sequence (two courses required): | ||
| Two of the following: | ||
| Artificial Intelligence | ||
| Computational Linguistics | ||
| Machine Learning and Large-Scale Data Analysis | ||
| Computer Vision | ||
| Machine Learning | ||
| Computational Biology | ||
| Advanced Systems Sequence (two courses required): | ||
| Two of the following: * | ||
| Software Construction | ||
| Digital Fabrication | ||
| Programming Languages | ||
| Computer Architecture | ||
| Functional Programming | ||
| Implementation of Computer Languages I | ||
| Implementation of Computer Languages II | ||
| Operating Systems | ||
| Parallel Computing | ||
| Introduction to Computer Security | ||
| Networks and Distributed Systems | ||
| Advanced Distributed Systems | ||
| Mobile Computing | ||
| Introduction to Database Systems | ||
| Introduction to Computer Graphics | ||
| Scientific Visualization | ||
| Game Construction | ||
| Scientific Computing Sequence (two courses required): | ||
| Two of the following: | ||
| Scientific Visualization | ||
| Digital Biology | ||
| Introduction to Scientific Computing | ||
5. Electives (four courses required):
Four additional elective Computer Science courses numbered 20000 or above. A BS student with a double major in a related area may petition to have some of the electives be courses in the other major.
| * | depending upon what courses the student has taken in the Programming Languages and Systems Sequence (courses may not be used to meet both requirements) |
Summary of Requirements
| GENERAL EDUCATION | ||
| One of the following sequences: | 200 | |
| Introductory General Chemistry I and Introductory General Chemistry II (or higher or equivalent) * | ||
| General Physics I-II (or higher) * | ||
| MATH 13100-13200 | Elementary Functions and Calculus I-II (or higher) * | 200 |
| Total Units | 400 | |
| * | Credit may be granted by examination. |
| MAJOR | ||
| Introductory Sequence: | 300 | |
| Introduction to Computer Science I | ||
or CMSC 16100 | Honors Introduction to Computer Science I | |
| Introduction to Computer Science II | ||
or CMSC 16200 | Honors Introduction to Computer Science II | |
| Introduction to Computer Systems | ||
| Programming Languages and Systems Sequence (two of the following): | 200 | |
| Programming Languages | ||
| Computer Architecture | ||
| Functional Programming | ||
| Implementation of Computer Languages I | ||
| Operating Systems | ||
| Introduction to Computer Security | ||
| Networks and Distributed Systems | ||
| Mobile Computing | ||
| Introduction to Database Systems | ||
| Introduction to Computer Graphics | ||
| Scientific Visualization | ||
| Game Construction | ||
| Algorithms and Theory Sequence: | 300 | |
| Discrete Mathematics | ||
| Theory of Algorithms | ||
| Introduction to Formal Languages | ||
or CMSC 28100 | Introduction to Complexity Theory | |
| Two courses from an approved sequence | 200 | |
| Four electives numbered CMSC 20000 or above | 400 | |
| Plus the following requirements: | 0-300 | |
BA (no other courses required) | ||
BS (3 courses in an approved program in a related field) | ||
| Total Units | 1400-1700 | |
Grading
Computer science majors must take courses in the major for quality grades. A grade of C- or higher must be received in each course in the major. Any 20000-level computer science course taken as an elective beyond requirements for the major may, with consent of instructor, be taken for P/F grading.
Non-majors may take courses for either quality grades or, subject to College regulations and with consent of instructor, for P/F grading. A Pass grade is given only for work of C- quality or higher. Courses taken to meet general education requirements must be taken for quality grades.
Incompletes are typically given in the Department of Computer Science only to students who have done at least 60 percent of the course's work of a passing quality and who are unable to complete all course work by the end of the quarter. Other restrictions on Incompletes are the province of individual instructors, many of whom do not permit Incompletes. To receive an Incomplete, students must make arrangements in advance with the instructor; a consent form to be signed by the instructor is available from the College adviser.
Honors
Students may earn a BA or BS degree with honors by attaining a grade of B or higher in all courses in the major and a grade of B or higher in three approved graduate computer science courses (30000-level and above). These courses may be courses taken for the major or as electives.
Students may also earn a BA or BS degree with honors by attaining the same minimum B grade in all courses in the major and by writing a successful bachelor's thesis as part of CMSC 29900 Bachelor's Thesis. This thesis must be based on an approved research project that is directed by a faculty member and approved by the department counselor.
Recommended Sequences in Computer Science
Introductory Sequences
The Department of Computer Science offers many different introductory pathways into the program. In consultation with their College adviser and the Computer Science Department advisers, students should choose their introductory courses carefully. Some guidelines follow.
- Students interested in a technical introduction to computer science, without assuming prior experience or unusually strong preparation in mathematics, are encouraged to take CMSC 15100-15200 Introduction to Computer Science I-II.
- Students with a strong mathematics background should consider CMSC 16100-16200 Honors Introduction to Computer Science I-II.
- Students majoring in quantitative fields other than computer science, including other sciences, mathematics, and economics, should consider CMSC 12100-12200 Computer Science with Applications I-II, possibly followed by CMSC 12300 Computer Science with Applications III.
- Students in the humanities (or others with a humanistic background) and social sciences may consider CMSC 11000 Multimedia Programming as an Interdisciplinary Art I.
- Students interested in two quarters of study altogether should consider CMSC 10500-10600 Fundamentals of Computer Programming I-II or CMSC 12100-12200 Computer Science with Applications I-II. We recommend CMSC 15100 Introduction to Computer Science I or CMSC 16100 Honors Introduction to Computer Science I as the first course to students intent from the outset on advanced study.
- Students who are interested in web design should take CMSC 10100 Introduction to Programming for the World Wide Web I.
- Students may only receive credit for one introductory programming sequence: CMSC 10500-10600 Fundamentals of Computer Programming I-II, CMSC 12100-12200 Computer Science with Applications I-II, CMSC 15100-15200 Introduction to Computer Science I-II, or CMSC 16100-16200 Honors Introduction to Computer Science I-II. Exceptions must be approved by the department counselor prior to taking the second sequence.
- Students who have credit for any of the following courses (or equivalent) may not take CMSC 10200 Introduction to Programming for the World Wide Web II for credit: CMSC 10600 Fundamentals of Computer Programming II, CMSC 12100 Computer Science with Applications I, CMSC 15200 Introduction to Computer Science II, or CMSC 16200 Honors Introduction to Computer Science II.
Courses in Specific Areas of Computer Science
- Students interested in artificial intelligence (AI) should take any of the elective AI courses numbered 25000-25400.
- Students interested in advanced programming and systems should take:
CMSC 22100 Programming Languages 100 CMSC 22200 Computer Architecture 100 Time permitting, they should also take advanced programming topics including but not limited to the following: CMSC 22610
& 22620Implementation of Computer Languages I
and Implementation of Computer Languages II200 CMSC 23000 Operating Systems 100 CMSC 23010 Parallel Computing 100 CMSC 23300 Networks and Distributed Systems 100 CMSC 23400 Mobile Computing 100 CMSC 23500 Introduction to Database Systems 100 CMSC 23700 Introduction to Computer Graphics 100 CMSC 23710 Scientific Visualization 100 CMSC 23800 Game Construction 100 and such courses in advanced programming topics as may be offered - Students interested in theoretical computer science should take:
Once students have completed CMSC 27100 Discrete Mathematics, CMSC 27200 Theory of Algorithms, CMSC 28000 Introduction to Formal Languages, and/or CMSC 28100 Introduction to Complexity Theory, they will be qualified for most of the advanced topics courses offered at the 30000-level and above.CMSC 27100 Discrete Mathematics 100 CMSC 27200 Theory of Algorithms 100 CMSC 28000 Introduction to Formal Languages 100 CMSC 28100 Introduction to Complexity Theory 100 - Students interested in numerical and scientific computing should take CMSC 28510 Introduction to Scientific Computing.
The department also offers a number of special-interest courses that are detailed in the course descriptions. For information on new courses that are added on a regular basis, consult the department counselor and visit www.cs.uchicago.edu.
Preparation for Graduate Study in Computer Science
Students interested in continuing their studies beyond the undergraduate level should major in computer science and take as many computer science courses as possible. The following courses are especially important:
| CMSC 15100 | Introduction to Computer Science I | 100 |
| CMSC 15200 | Introduction to Computer Science II | 100 |
| CMSC 15400 | Introduction to Computer Systems | 100 |
| CMSC 22100 | Programming Languages | 100 |
| CMSC 22200 | Computer Architecture | 100 |
| CMSC 22610 | Implementation of Computer Languages I | 100 |
| CMSC 23000 | Operating Systems | 100 |
| CMSC 23300 | Networks and Distributed Systems | 100 |
| CMSC 23500 | Introduction to Database Systems | 100 |
| CMSC 23700 | Introduction to Computer Graphics | 100 |
| CMSC 25400 | Machine Learning | 100 |
| CMSC 27100 | Discrete Mathematics | 100 |
| CMSC 27200 | Theory of Algorithms | 100 |
| CMSC 28000 | Introduction to Formal Languages | 100 |
| CMSC 28100 | Introduction to Complexity Theory | 100 |
For more information about options for graduate study, consult the department counselor and the director of graduate studies.
Minor Program in Computer Science
The minor in computer science requires seven courses. The introductory sequence of three courses is followed by four approved upper-level courses. Courses in the minor must be taken for quality grades, with a grade of C- or higher in each course. Students may not use AP credit for computer science to meet requirements for the minor.
No courses in the minor can be double counted with the student's major(s) or with other minors; nor can they be counted toward general education requirements. More than half of the requirements for the minor must be met by registering for courses bearing University of Chicago course numbers. The minor advisor must approve the student's minor consent form and the student must submit that form to their College adviser by the end of Spring Quarter of their third year.
Introductory Courses
Students must choose three courses from the following (one course from Area A and one course from Area B):
| Area A: | 100 | |
| Computer Science with Applications I | ||
| Introduction to Computer Science I | ||
| Honors Introduction to Computer Science I | ||
| Area B: | 100 | |
| Computer Science with Applications II | ||
| Introduction to Computer Science II | ||
| Honors Introduction to Computer Science II | ||
| CMSC 15400 | Introduction to Computer Systems | 100 |
Upper-Level Courses
Four 20000-level or above computer science courses must be approved by the minor advisor. A 20000-level course must replace each 10000-level course in the list above that was used to meet general education requirements.
Joint BA/MS or BS/MS Program
Outstanding computer science majors may apply to complete an MS in computer science along with a BA or BS during their four years at the College.
Participants must be admitted to the joint MS program. Prior to applying to the program, interested students must meet with Sharon Salveter, Computer Science Department Counselor, and Ron Gorny, the College BA/MS or BS/MS Adviser. (For an appointment with Mr. Gorny, call the College Advisers Reception Desk at 702.8615.) Students must submit applications for the joint program to the department counselor, Sharon Salveter, by the end of Winter Quarter of their third year.
Participants in the joint BA/MS or BS/MS program must meet the requirements for the BA or BS plus nine courses for the MS and a master's project. Three of the nine courses for the MS may also be used to meet the requirements of the BA or BS, resulting in a total of 20 courses in computer science. For details visit www.cs.uchicago.edu/info/BxMS.
Graduate Courses
Graduate courses and seminars offered by the Department of Computer Science are open to College students with consent of instructor and department counselor. For more information, consult the department counselor.
Computer Science Courses
CMSC 10100. Introduction to Programming for the World Wide Web I. 100 Units.
This course teaches the basics of building and maintaining a site on the World Wide Web. We discuss Internet terminology and how the Internet and its associated technologies work. Topics include programming websites, hypertext markup language (HTML), Cascading Style Sheets (CSS), and Common Gateway Interface (CGI) scripts (using PERL). Students also learn how to use JavaScript to add client-side functionality.
Instructor(s): W. Sterner Terms Offered: Winter
Note(s): This course does not meet the general education requirement in the mathematical sciences.
CMSC 10200. Introduction to Programming for the World Wide Web II. 100 Units.
This course introduces computer programming in Java with a focus on designing and implementing software for the World Wide Web. We first introduce the fundamentals of programming, giving particular attention to basic object-oriented techniques. We employ Java Server Pages to develop programs that interact with users through web browsers. Finally, we study relational databases and, integrating that study with general-purpose Java programming, build database-backed web applications.
Instructor(s): S. Salveter Terms Offered: Not offered in 2014-15
Prerequisite(s): MATH 10600, or placement into 13100 or equivalent; and knowledge of HTML
Note(s): This course meets the general education requirement in the mathematical sciences. May not be taken for credit by students who have credit for CMSC 12100, 15200, or 16200.
CMSC 10500-10600. Fundamentals of Computer Programming I-II.
This sequence meets the general education requirement in the mathematical sciences.
CMSC 10500. Fundamentals of Computer Programming I. 100 Units.
This course introduces computer programming using the functional programming language Scheme. We emphasize design, algorithm construction, and procedural/functional/data abstraction.
Instructor(s): S. Salveter Terms Offered: Winter
Prerequisite(s): MATH 10600, or placement into 13100 or equivalent; or consent of departmental counselor required; previous computer experience and advanced mathematical knowledge not required
Note(s): CMSC 10500 and 10600 may be taken in sequence or individually. This course meets the general education requirement in the mathematical sciences.
CMSC 10600. Fundamentals of Computer Programming II. 100 Units.
This course is an introduction to computer programming using the object-oriented programming language C++. We emphasize algorithm design and construction. Topics include complex types, iteration, recursion, procedural/functional/data abstraction, classes, methods, inheritance, and polymorphism.
Terms Offered: Spring
Prerequisite(s): MATH 10600, or placement into 13100 or equivalent; or consent of departmental counselor
Note(s): CMSC 10500 and 10600 may be taken in sequence or individually. This course meets the general education requirement in the mathematical sciences.
CMSC 11000-11100. Multimedia Programming as an Interdisciplinary Art I-II.
Either course in this sequence meets the general education requirement in the mathematical sciences. Like other classic Chicago general education courses, this sequence provides students with both practical programming skills and core ideas in computer science in interdisciplinary applications. Students learn how to perform in a multi-platform (Mac/Linux/Windows) environment using a high-level prototyping language (revTalk) that allows for the quick creation of useful multimedia applications. As a classic Core course in the Chicago tradition, the course presents introductory techniques of problem solving, algorithm construction, program coding, and debugging as interdisciplinary arts adaptable to a wide range of disciplines with their specialized problems. The first course moves through a sequence from step-by-step introductory labs, to labs that require independent analysis and solution, to a student-designed final project. The second course consists of several scientific and humanistic projects such as Turing Machines, biological modeling, and language manipulation with another final project.
CMSC 11000. Multimedia Programming as an Interdisciplinary Art I. 100 Units.
Instructor(s): W. Sterner Terms Offered: Spring
Prerequisite(s): MATH 10600, or placement into 13100 or equivalent; or consent of instructor
Note(s): This course meets the general education requirement in the mathematical sciences.
CMSC 11100. Multimedia Programming as an Interdisciplinary Art II. 100 Units.
Terms Offered: Not offered in 2014-15
Prerequisite(s): MATH 10600, or placement into 13100 or equivalent; or consent of instructor
Note(s): This course meets the general education requirement in the mathematical sciences.
CMSC 11710. Networks. 100 Units.
Networks help explain phenomena in such technological, social, and biological domains as the spread of opinions, knowledge, and infectious diseases. Networks also help us understand properties of financial markets, food webs, and web technologies. At the same time, the structure and evolution of networks is determined by the set of interactions in the domain. Our study of networks will employ formalisms such as graph theory, game theory, information networks, and network dynamics, with the goal of building formal models and translating their observed properties into qualitative explanations.
Instructor(s): J. Simon Terms Offered: Spring
Prerequisite(s): Completion of the general education requirement in the mathematical sciences, and familiarity with basic concepts of probability at the high school level.
Note(s): Necessary mathematical concepts will be presented in class.
CMSC 12100-12200-12300. Computer Science with Applications I-II-III.
This three-quarter sequence teaches computational thinking and skills to students who are majoring in the sciences, mathematics, and economics. Lectures cover topics in (1) programming, such as recursion, abstract data types, and processing data; (2) computer science, such as clustering methods, event-driven simulation, and theory of computation; and to a lesser extent (3) numerical computation, such as approximating functions and their derivatives and integrals, solving systems of linear equations, and simple Monte Carlo techniques. Applications from a wide variety of fields serve both as examples in lectures and as the basis for programming assignments. In recent offerings, students have written programs to evaluate betting strategies, determine the number of machines needed at a polling place, and predict the size of extinct marsupials. Students learn Java, Python, R and C++.
CMSC 12100. Computer Science with Applications I. 100 Units.
Instructor(s): A. Rogers Terms Offered: Autumn
Prerequisite(s): Placement into MATH 15200 or higher, or consent of instructor
Note(s): This course meets the general education requirement in the mathematical sciences.
CMSC 12200. Computer Science with Applications II. 100 Units.
Instructor(s): A. Rogers Terms Offered: Winter
Prerequisite(s): CMSC 12100
Note(s): This course meets the general education requirement in the mathematical sciences.
CMSC 12300. Computer Science with Applications III. 100 Units.
The course revolves around core ideas behind the management and computation of large volumes of data ("Big Data"). Topics include (1) Statistical methods for large data analysis, (2) Parallelism and concurrency, including models of parallelism and synchronization primitives, and (3) Distributed computing, including distributed architectures and the algorithms and techniques that enable these architectures to be fault-tolerant, reliable, and scalable. Students will continue to use R, and will also learn C++ and distributed computing tools and platforms, including Amazon AWS and Hadoop. This course includes a project where students will have to formulate hypotheses about a large dataset, develop statistical models to test those hypothesis, implement a prototype that performs an initial exploration of the data, and a final system to process the entire dataset.
Terms Offered: Spring
Prerequisite(s): CMSC 12200
CMSC 15100-15200. Introduction to Computer Science I-II.
This sequence, which is recommended for all students planning to take more advanced courses in computer science, introduces computer science using both functional (Scheme) and imperative (C) programming languages. Topics include control and data abstraction, self-reference, time and space analysis, and data structures. NOTE: Non-majors may use either course in this sequence to meet the general education requirement in the mathematical sciences; students who are majoring in Computer Science must use either CMSC 15100-15200 or 16100-16200 to meet requirements for the major.
CMSC 15100. Introduction to Computer Science I. 100 Units.
Instructor(s): J. Reppy (Autumn), A. Shaw (Autumn) Terms Offered: Autumn, Summer
Prerequisite(s): Placement into MATH 15100 or equivalent, or consent of departmental counselor
Note(s): This course meets the general education requirement in the mathematical sciences.
CMSC 15200. Introduction to Computer Science II. 100 Units.
Instructor(s): A. Shaw (Winter) Terms Offered: Winter, Summer
Prerequisite(s): CMSC 15100
Note(s): This course meets the general education requirement in the mathematical sciences.
CMSC 15400. Introduction to Computer Systems. 100 Units.
This course covers the basics of computer systems from a programmer's perspective. Topics include data representation, machine language programming, exceptions, code optimization, performance measurement, memory systems, and system-level I/O. Extensive programming required.
Terms Offered: Spring
Prerequisite(s): CMSC 15200, 16200 or 12200
Note(s): Required of students who are majoring in Computer Science.
CMSC 16100-16200. Honors Introduction to Computer Science I-II.
Both courses in this sequence meet the general education requirement in the mathematical sciences; students who are majoring in Computer Science must use either CMSC 15200 or 16200 to meet requirements for the major.
CMSC 16100. Honors Introduction to Computer Science I. 100 Units.
Programming in a functional language (currently Haskell), including higher-order functions, type definition, algebraic data types, modules, parsing, I/O, and monads. Basic data structures, including lists, binary search trees, and tree balancing. Basic mathematics for reasoning about programs, including induction, inductive definition, propositional logic, and proofs. Search in graphs, including depth-first and breadth-first search. Search in metric graphs, including greedy and A* search, with applications.
Instructor(s): S. Kurtz Terms Offered: Autumn
Prerequisite(s): Placement into MATH 16100 or equivalent and programming experience, or consent of department counselor
Note(s): This course meets the general education requirement in the mathematical sciences.
CMSC 16200. Honors Introduction to Computer Science II. 100 Units.
This course emphasizes the C Programming Language, but not in isolation. Instead, C is developed as a part of a larger programming toolkit that includes the shell (specifically ksh), shell programming, and standard Unix utilities (including awk). Nonshell scripting languages, in particular perl and python, are introduced, as well as interpreter (#!) files that use the command-line version of DrScheme. We cover various standard data structures, both abstractly, and in terms of concrete implementations—primarily in C, but also from time to time in other contexts like scheme and ksh. The course uses a team programming approach. There is a mixture of individual programming assignments that focus on current lecture material, together with team programming assignments that can be tackled using any Unix technology. Team projects are assessed based on correctness, elegance, and quality of documentation. We teach the "Unix way" of breaking a complex computational problem into smaller pieces, most or all of which can be solved using pre-existing, well-debugged, and documented components, and then composed in a variety of ways.
Instructor(s): S. Kurtz Terms Offered: Winter
Prerequisite(s): CMSC 16100, or consent of department counselor
Note(s): Students who have taken CMSC 15100 may take 16200 with consent of instructor. This course meets the general education requirement in the mathematical sciences.
CMSC 22001. Software Construction. 100 Units.
Large software systems are difficult to build. The course discusses both the empirical aspects of software engineering and the underlying theory. Topics will include, among others, software specifications, software design, software architecture, software testing, software reliability, and software maintenance. Students will be expected to actively participate in team projects in this course.
Instructor(s): S. Lu Terms Offered: Autumn
Prerequisite(s): CMSC 15400
CMSC 22010. Digital Fabrication. 100 Units.
Digital fabrication involves translation of a digital design into a physical object. While digital fabrication has been around for decades, only now has it become possible for individuals to take advantage of this technology through low cost 3D printers and open source tools for 3D design and modeling. In this course we will cover the foundations of 3D object design including computational geometry, the type of models that can and can’t be fabricated, the uses and applications of digital fabrication, the algorithms, methods and tools for conversion of 3D models to representations that can be directly manufactured using computer controlled machines, the concepts and technology used in additive manufacturing (aka 3D printing) and the research and practical challenges of developing self-replicating machines. We will have several 3D printers available for use during the class and students will design and fabricate several parts during the course.
Instructor(s): R. Stevens Terms Offered: Autumn
Prerequisite(s): CMSC 15400 and some experience with 3D modeling concepts.
CMSC 22100. Programming Languages. 100 Units.
Programming language design aims at the closest possible correspondence between the structures of a program and the task it performs. This course studies some of the structural concepts affecting programming languages: iterative and recursive control flow, data types and type checking, procedural versus functional programming, modularity and encapsulation, fundamentals of interpreting and compiling, and formal descriptions of syntax and semantics. Students write short programs in radically different languages to illuminate the variety of possible designs.
Terms Offered: Spring. Generally offered alternate years.
Prerequisite(s): CMSC 15400
CMSC 22200. Computer Architecture. 100 Units.
This course is a survey of contemporary computer organization covering CPU design, instruction sets, control, processors, busses, ALU, memory, pipelined computers, multiprocessors, networking, and case studies. We focus on the techniques of quantitative analysis and evaluation of modern computing systems, such as the selection of appropriate benchmarks to reveal and compare the performance of alternative design choices in system design. We emphasize major component subsystems of high-performance computers: pipelining, instruction-level parallelism, memory hierarchies, input/output, and network-oriented interconnections.
Instructor(s): A. Chien Terms Offered: Autumn
Prerequisite(s): CMSC 15400
CMSC 22300. Functional Programming. 100 Units.
This course presents the functional programming paradigm, based on the idea of functions as "first-class" values that can be manipulated like other data. This idea leads to great power of expression while maintaining simplicity, making it easier to write correct and maintainable software. We use the languages Haskell and ML as representatives of the two main schools of functional programming, the pure and the impure. After learning the basic elements of these languages, we explore functional programming techniques that can be exploited in many areas of application using a surprising variety of languages (e.g., C#, Python) that have included first-class functions as a feature. We compare functional and object oriented programming and include an brief overview of concurrent functional programming in ML and Haskell.
Terms Offered: Spring. Generally offered alternate years.
Prerequisite(s): CMSC 15400
CMSC 22311. Functional Systems in Haskell. 100 Units.
Advanced and systems programming in Haskell, including testing, meta-programming, exceptions, concurrency, web, IO, and network programming.
Instructor(s): S. Kurtz Terms Offered: Spring
Prerequisite(s): CMSC 16100 and CMSC 15400, or consent of instructor
CMSC 22610. Implementation of Computer Languages I. 100 Units.
This course covers principles and techniques for implementing computer languages (e.g., programming languages, query languages, specification languages, domain-specific languages). Topics include lexical analysis, parsing, tree representations of programs (both parse trees and abstract syntax trees), types and type checking, interpreters, abstract machines, and run-time systems. This is a project-based course involving the implementation of a small language using Standard ML.
Instructor(s): J. Reppy Terms Offered: Winter. Generally offered alternate years.
Prerequisite(s): CMSC 15400 required; CMSC 22100 recommended
Note(s): Prior experience with ML programming not required. This course is offered in alternate years.
CMSC 22620. Implementation of Computer Languages II. 100 Units.
This course is a continuation of CMSC 22610, covering compilers for general-purpose languages. Topics include compiler-immediate representations, continuation-passing style, runtime representations, code generation, code optimization, register allocation, instruction scheduling, and garbage collection. This is a project-based course in which students construct a complete, working compiler for a small language using Standard ML.
Instructor(s): J. Reppy Terms Offered: Spring. Generally offered alternate years.
Prerequisite(s): CMSC 22610 required; CMSC 22100 strongly recommended
Note(s): Generally offered alternate years.
Equivalent Course(s): CMSC 32620
CMSC 22630. Advanced Implementation of Computer Languages. 100 Units.
This course explores advanced topics in the implementation of high-level programming languages that vary each year (e.g., control-flow analysis algorithms, abstract interpretation, partial evaluation, advanced optimizations, runtime system representations, garbage collection algorithms, foreign-function interfaces). Students are expected to develop both a foundational and applied understanding of these topics.
Instructor(s): J. Reppy Terms Offered: Autumn. Generally offered alternate years.
Prerequisite(s): CMSC 22100 and 22620, or equivalent
CMSC 23000. Operating Systems. 100 Units.
This course provides an introduction to the basic concepts and techniques used to implement operating systems. Topics include processes and threads, interprocess communication and synchronization, memory management, segmentation, paging, linking and loading, scheduling, file systems, and input/output. The course will revolve around the implementation of an x86 operating system kernel.
Instructor(s): H. Gunawi Terms Offered: Autumn
Prerequisite(s): CMSC 15400, and one of the following: CMSC 22200, CMSC 22610, CMSC 23300, CMSC 23400, CMSC 23500, CMSC 23700, CMSC 23710, or CMSC 23800.
CMSC 23010. Parallel Computing. 100 Units.
This course provides an introduction to the concepts of parallel programming, with an emphasis on programming multicore processors. Topics include: Processes and threads, shared memory, message passing, direct-memory access (DMA), hardware mechanisms for parallel computing, synchronization and communication, patterns of parallel programming. The course will involve a substantial programming project implementing a parallel computations.
Instructor(s): H. Hoffmann Terms Offered: Winter
Prerequisite(s): CMSC 15400 and one of the following: CMSC 22000 (Architecture), CMSC 23000 (Operating Systems), or CMSC 23300 (Networks and Distributed Systems), or consent of the instructor.
CMSC 23200. Introduction to Computer Security. 100 Units.
This course introduces the principles and practice of computer security. It aims to teach how to model threats to computer systems and how to think like a potential attacker. It presents standard cryptographic functions and protocols and gives an overview of threats and defenses for software, host systems, networks, and the Web. It also touches on some of the legal, policy, and ethical issues surrounding computer security in areas such as privacy, surveillance, and the disclosure of security vulnerabilities. The goal of this course is to provide a foundation for further study in computer security and to help better understand how to design, build, and use computer systems more securely.
Instructor(s): A. Feldman Terms Offered: Autumn
Prerequisite(s): CMSC 15400
CMSC 23300. Networks and Distributed Systems. 100 Units.
This course focuses on the principles and techniques used in the development of networked and distributed software. Topics include programming with sockets; concurrent programming; data link layer (Ethernet, packet switching, etc.); internet and routing protocols (UDP, TCP); and other commonly used network protocols and techniques. This is a project-oriented course in which students are required to develop software in C on a UNIX environment.
Instructor(s): B. Sotomayor Terms Offered: Winter
Prerequisite(s): CMSC 15400
Equivalent Course(s): CMSC 33300
CMSC 23310. Advanced Distributed Systems. 100 Units.
This course explores advanced topics in distributed systems. Topics include supercomputing (architectures, applications, programming models, etc.); grid computing with an emphasis on Globus technologies; Infrastructure-as-a-Service clouds (virtual infrastructure management, Amazon EC2, etc.), Platform-as-a-Service clouds (Google App Engine, etc.), and the Software-as-a-Service model; and other current topics related to using and building distributed systems. The course includes a substantial practical component but also requires students to read papers and articles on current advances in the field.
Instructor(s): B. Sotomayor Terms Offered: Spring
Prerequisite(s): CMSC 23300 or consent of instructor
Equivalent Course(s): CMSC 33310
CMSC 23340. Grid Computing. 100 Units.
The new Open Grid Services Architecture (OGSA) defines interfaces and protocols that promise to make it far easier to construct decentralized, dynamic, large-scale systems. We explore and evaluate this technology by using it to develop a range of scalable distributed services. We use the Globus Toolkit, an open source implementation of key OGSA standards, to design and build services. We then evaluate our implementations from the perspectives of performance and programmability.
Instructor(s): I. Foster Terms Offered: Generally offered alternate years.
Prerequisite(s): Substantial programming experience
CMSC 23400. Mobile Computing. 100 Units.
Mobile computing is pervasive and changing nearly every aspect of society. Sensing, actuation, and mediation capabilities of mobile devices are transforming all aspects of computing: uses, networking, interface, form, etc. This course explores new technologies driving mobile computing and their implications for systems and society. Current focus areas include expanded visual experience with computational photography, video and interactive augmented reality, and synchronicity and proximity-detection to enable shared social experiences. Labs expose students to software and hardware capabilities of mobile computing systems, and develop the capability to envision radical new applications for a large-scale course project.
Instructor(s): A. Chien Terms Offered: Winter
Prerequisite(s): CMSC 15200 and 15400 are required and CMSC 23000 or 23300 are recommended. Knowledge of Java is required. A short course is available at http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-092-introduction-to-programming-in-java-january-iap-2010/index.htm
Equivalent Course(s): CMSC 33400
CMSC 23500. Introduction to Database Systems. 100 Units.
This course is an introduction to database design and programming using the relational model. Topics include DBMS architecture, entity-relationship and relational models, relational algebra, relational calculus, functional dependencies and normal forms, web DBs and PHP, query optimization, and physical data organization. The lab section guides students through the collaborative implementation of a relational database management system, allowing students to see topics such as physical data organization and DBMS architecture in practice, and exercise general skills such as collaborative software development.
Instructor(s): A. Shaw Terms Offered: Spring. Generally offered alternate years.
Prerequisite(s): CMSC 15400
CMSC 23700. Introduction to Computer Graphics. 100 Units.
This course introduces the basic concepts and techniques used in three-dimensional computer graphics. The focus is on real-time rendering techniques, such as those found in computer games. These include coordinate systems and transformations, the graphics pipeline, basic geometric algorithms, texture mapping, level-of detail optimizations, and shadows. Students are required to complete both written assignments and programming projects using OpenGL.
Instructor(s): J. Reppy Terms Offered: Winter. Generally offered alternate years.
Prerequisite(s): CMSC 15400
Note(s): This course is offered in alternate years.
CMSC 23710. Scientific Visualization. 100 Units.
Scientific visualization combines computer graphics, numerical methods, and mathematical models of the physical world to create a visual framework for understanding and solving scientific problems. The mathematical and algorithmic foundations of scientific visualization (for scalar, vector, and tensor fields) will be explained in the context of real-world data from scientific and biomedical domains. The course is also intended for students outside computer science who are experienced with programming and scientific computing on scientific data. Programming projects will be in C.
Instructor(s): G. Kindlmann Terms Offered: Winter. Generally offered alternate years.
Prerequisite(s): CMSC 15300 and CMSC 15400, or (equivalent linear algebra and programming experience and consent of the instructor).
CMSC 23800. Game Construction. 100 Units.
Computer games are one of the most exciting applications of computer technology. They also are large software systems that embody cutting-edge graphics, as well as techniques from AI, scientific simulation, networking, and databases. This course introduces the student to the basic algorithms and techniques used in computer-game construction. Students work in teams to design and create games using existing libraries for graphics, physics simulation, and so forth.
Instructor(s): J. Reppy Terms Offered: Spring. Generally offered alternate years.
Prerequisite(s): CMSC 15400, and at least two of the following courses: CMSC 23700, CMSC 23000, CMSC 23300, CMSC 23500. Strong background in programming and expertise in at least two technical areas underlying computer games (e.g., AI, graphics, scientific computing, networking).
Equivalent Course(s): CSPP 53800
CMSC 25020. Computational Linguistics. 100 Units.
This course introduces the problems of computational linguistics and the techniques used to deal with them, focusing primarily on probabilistic models and techniques. Topics are drawn primarily from phonology, morphology, and syntax. Special topics include automatic learning of grammatical structure and the treatment of languages other than English.
Instructor(s): J. Goldsmith Terms Offered: Spring
Prerequisite(s): CMSC 12200, 15200 or 16200, or competence in a programming language
Equivalent Course(s): CMSC 35050,LING 28600,LING 38600
CMSC 25025. Machine Learning and Large-Scale Data Analysis. 100 Units.
This course is an introduction to machine learning and the analysis of large data sets using distributed computation and storage infrastructure. Basic machine learning methodology and relevant statistical theory will be presented in lectures. Homework exercises will give students hands-on experience with the methods on different types of data. Methods include algorithms for clustering, binary classification, and hierarchical Bayesian modeling. Data types include images, archives of scientific articles, online ad clickthrough logs, and public records of the City of Chicago. Programming will be based on Python and R, but previous exposure to these languages is not assumed.
Instructor(s): J. Lafferty Terms Offered: Spring
Prerequisite(s): (STAT 22000 or STAT 23400) and (CMSC 15400 or CMSC 12200), or consent of the instructor
Equivalent Course(s): STAT 37601
CMSC 25050. Computer Vision. 100 Units.
This course covers deformable models for detecting objects in images. Topics include one-dimensional models to identify object contours and boundaries; two-dimensional models for image matching; and sparse models for efficient detection of objects in complex scenes. Mathematical tools needed to define the models and associated algorithms are developed. Applications include detecting contours in medical images, matching brains, and detecting faces in images. Neural network implementations of some of the algorithms are presented, and connections to the functions of the biological visual system are discussed.
Instructor(s): Y. Amit Terms Offered: Not offered in 2014-15
Equivalent Course(s): CMSC 35500,STAT 37900
CMSC 25400. Machine Learning. 100 Units.
This course offers a practical, problem-centered introduction to machine learning. Topics covered include the Perceptron and other online algorithms; boosting; graphical models and message passing; dimensionality reduction and manifold learning; SVMs and other kernel methods; and a short introduction to statistical learning theory. Weekly programming assignments give students the opportunity to try out each learning algorithm on real world datasets.
Instructor(s): R. Kondor Terms Offered: Winter
Prerequisite(s): CMSC 15300, CMSC 15400. STAT 22000 or STAT 23400 strongly recommended.
Equivalent Course(s): STAT 27725
CMSC 27100. Discrete Mathematics. 100 Units.
This course emphasizes mathematical discovery and rigorous proof, which are illustrated on a refreshing variety of accessible and useful topics. Basic counting is a recurring theme and provides the most important source for sequences, which is another recurring theme. Further topics include proof by induction; recurrences and Fibonacci numbers; graph theory and trees; number theory, congruences, and Fermat's little theorem; counting, factorials, and binomial coefficients; combinatorial probability; random variables, expected value, and variance; and limits of sequences, asymtotic equality, and rates of growth.
Instructor(s): J. Simon Terms Offered: Autumn
Prerequisite(s): CMSC 15400, or MATH 16300 or higher. Computer science majors should take CMSC 15300 before CMSC 27100.
Note(s): This is a directed course in mathematical topics and techniques that is a prerequisite for courses such as CMSC 27200 and 27400.
CMSC 27200. Theory of Algorithms. 100 Units.
This course covers design and analysis of efficient algorithms, with emphasis on ideas rather than on implementation. Algorithmic questions include sorting and searching, discrete optimization, algorithmic graph theory, algorithmic number theory, and cryptography. Design techniques include "divide-and-conquer" methods, dynamic programming, greedy algorithms, and graph search, as well as the design of efficient data structures. Methods of algorithm analysis include asymptotic notation, evaluation of recurrent inequalities, the concepts of polynomial-time algorithms, and NP-completeness.
Instructor(s): J. Simon Terms Offered: Winter
Prerequisite(s): CMSC 27100 or consent of instructor
CMSC 27410. Honors Combinatorics. 100 Units.
Methods of enumeration, construction, and proof of existence of discrete structures are discussed in conjunction with the basic concepts of probability theory over a finite sample space. Enumeration techniques are applied to the calculation of probabilities, and, conversely, probabilistic arguments are used in the analysis of combinatorial structures. Other topics include basic counting, linear recurrences, generating functions, Latin squares, finite projective planes, graph theory, Ramsey theory, coloring graphs and set systems, random variables, independence, expected value, standard deviation, and Chebyshev's and Chernoff's inequalities.
Instructor(s): L. Babai Terms Offered: Spring
Prerequisite(s): MATH 19900 or 25400, or CMSC 27100, or consent of instructor. Experience with mathematical proofs.
Note(s): This course is offered in alternate years.
CMSC 27500. Graph Theory. 100 Units.
This course covers the basics of the theory of finite graphs. Topics include shortest paths, spanning trees, counting techniques, matchings, Hamiltonian cycles, chromatic number, extremal graph theory, Turan's theorem, planarity, Menger's theorem, the max-flow/min-cut theorem, Ramsey theory, directed graphs, strongly connected components, directed acyclic graphs, and tournaments. Techniques studied include the probabilistic method.
Instructor(s): S. Kurtz Terms Offered: Spring
Prerequisite(s): CMSC 15400 or MATH 20400
CMSC 27610. Digital Biology. 100 Units.
Explores the digital nature of biology at the molecular scale. Focuses on the role of hydrophobic effect in protein/ligand associations. Utilizes data-mining as a tool both to understand basic biophysics and to explain protein-ligand associations. Shows how such analog interactions can lead to digital devices (e.g., switches). No biochemistry background will be assumed.
Instructor(s): L. R. Scott Terms Offered: Spring. Generally offered alternate years.
Prerequisite(s): MATH 15100-15200 and ability to program. All prerequisites will be provided in class.
Note(s): High school chemistry is helpful.
CMSC 27700-27800. Mathematical Logic I-II.
Mathematical Logic I-II
CMSC 27700. Mathematical Logic I. 100 Units.
This course introduces mathematical logic. Topics include propositional and predicate logic and the syntactic notion of proof versus the semantic notion of truth (e.g., soundness, completeness). We also discuss the Gödel completeness theorem, the compactness theorem, and applications of compactness to algebraic problems.
Terms Offered: Autumn
Prerequisite(s): MATH 25400 or 25700; open to students who are majoring in computer science who have taken CMSC 15400 along with MATH 16300 or MATH 19900
Equivalent Course(s): MATH 27700
CMSC 27800. Mathematical Logic II. 100 Units.
Topics include number theory, Peano arithmetic, Turing compatibility, unsolvable problems, Gödel's incompleteness theorem, undecidable theories (e.g., the theory of groups), quantifier elimination, and decidable theories (e.g., the theory of algebraically closed fields).
Terms Offered: Winter
Prerequisite(s): MATH 27700 or equivalent
Equivalent Course(s): MATH 27800
CMSC 28000. Introduction to Formal Languages. 100 Units.
This course is a basic introduction to computability theory and formal languages. Topics include automata theory, regular languages, context-free languages, and Turing machines.
Instructor(s): K. Mulmuley Terms Offered: Winter
Prerequisite(s): CMSC 15400, or MATH 19900 or MATH 25500
Equivalent Course(s): MATH 28000
CMSC 28100. Introduction to Complexity Theory. 100 Units.
Computability topics are discussed (e.g., the s-m-n theorem and the recursion theorem, resource-bounded computation). This course introduces complexity theory. Relationships between space and time, determinism and non-determinism, NP-completeness, and the P versus NP question are investigated.
Instructor(s): K. Mulmuley Terms Offered: Spring
Prerequisite(s): CMSC 27100, or MATH 19900 or 25500; and experience with mathematical proofs
Equivalent Course(s): MATH 28100
CMSC 28501. Topics in Scientific Computing. 100 Units.
This course covers current topics in scientific computing.
Terms Offered: Autumn, Winter, Spring
Prerequisite(s): Consent of instructor
CMSC 28510. Introduction to Scientific Computing. 100 Units.
Basic processes of numerical computation are examined from both an experimental and theoretical point of view. This course deals with numerical linear algebra, approximation of functions, approximate integration and differentiation, Fourier transformation, solution of nonlinear equations, and the approximate solution of initial value problems for ordinary differential equations. We concentrate on a few widely used methods in each area covered.
Instructor(s): T. Dupont Terms Offered: Autumn. Generally offered alternate years.
Prerequisite(s): A year of calculus (MATH 15300 or higher), a quarter of linear algebra (MATH 19620 or higher), and CMSC 10600 or higher; or consent of instructor
CMSC 29700. Reading and Research in Computer Science. 100 Units.
Students do reading and research in an area of computer science under the guidance of a faculty member. A written report is typically required.
Terms Offered: Summer, Autumn, Winter, Spring
Prerequisite(s): Consent of instructor and approval of department counselor
Note(s): Open both to students who are majoring in Computer Science and to nonmajors. Students are required to submit the College Reading and Research Course Form.
CMSC 29900. Bachelor's Thesis. 100 Units.
Terms Offered: Summer, Autumn, Winter, Spring
Prerequisite(s): Consent of instructor and department counselor. Students are required to submit the College Reading and Research Course Form.
Note(s): Open to fourth-year students who are candidates for honors in Computer Science