Download Appendix B Analysis of CSE Computer Science Program

Appendix B Analysis of CSE Computer Science Program
Topic
Stanford
Berkeley
CMU
UNSW
SDF/Algorithms and Design
SDF/Fundamental Programming Concepts
SDF/Fundamental Data Structures
SDF/Development Methods
cs106
cs106
cs106
cs106
cs61A
cs61A
cs61A
cs61A
15-122
15-122
15-122
15-122
comp1917
comp1917
comp1917
comp1917
AR/Digital logic and digital systems
AR/Machine level representation of data
AR/Assembly level machine organization
AR/Memory system organization & architecture
AR/Interfacing and communication
——
cs107
cs107
cs107
——
cs61C
cs61C
cs61C
cs61C
——
——
15-213
15-213
15-213
——
comp2121
comp2121
comp2121
——
comp2121
SF/Computational Paradigms
SF/Cross-Layer Communications
SF/State-State Transition-State Machines
SF/System Support for Parallelism
SF/Performance
SF/Resource Allocation & Scheduling
cs107
cs107
cs107
cs107
cs107
——
cs61C
cs61C
cs61C
cs61C
cs61C
——
15-213
15-213
15-213
15-213
15-213
——
comp2121
comp2121
comp2121
comp2121
comp2121
——
NC/Introduction
NC/Networked Applications
NC/Reliable Data Delivery
NC/Routing and Forwarding
cs110
cs110
cs110
cs110
——
——
——
——
15-213
15-213
15-213
15-213
comp2041
comp2041
——
——
PD/Parallelism Fundamentals
PD/Parallel Decomposition
cs110
cs110
cs61C
cs61C
15-210
15-210
——
——
OS/Overview of Operating Systems
OS/Operating System Principles
OS/Concurrency
OS/Scheduling and Dispatch
OS/Memory Management
OS/Security and Protection
cs110
cs110
cs110
cs110
cs110
cs110
——
——
——
——
——
——
——
——
——
——
——
——
comp2041
——
——
——
——
——
AL/Basic Analysis
AL/Algorithmic Strategies
AL/Fundamental Data Structures & Algorithms
AL/Basic Automata, Computability & Complexity
cs161
cs161
cs161
cs103
cs61B
cs61B
cs61B
cs61B
15-210
15-210
15-210
15-251
comp1927
comp1927
comp1927
——
PL/Object-Oriented Programming
PL/Functional Programming
PL/Event-Driven and Reactive Programming
PL/Basic Type Systems
PL/Program Representation
PL/Language Translation and Execution
cs106
—–
cs107
cs107
cs107
cs107
cs61A
cs61A
——
——
——
cs61C
——
15-150
——
15-150
——
15-213
comp2911
——
comp2121
comp2911
——
——
IM/Information Management Concepts
IM/Database Systems
IM/Data Modeling
——
——
——
——
——
——
——
——
——
——
——
——
GV/Fundamental Concepts
——
——
15-210
comp2911
HC/Foundations
HC/Designing Interaction
——
——
——
——
——
——
comp2911
comp2911
IS/Fundamental Issues
IS/Basic Search Strategies
IS/Basic Knowledge Representation & Reasoning
IS/Basic Machine Learning
——
——
——
——
——
——
——
——
15-251
15-251
——
——
comp1927
comp1927
——
——
SE/Software Processes
SE/Software Project Management
SE/Tools and Environments
SE/Software Design
SE/Software Construction
SE/Software Verification and Validation
——
——
——
——
——
——
cs61B
——
——
cs61B
——
——
——
——
——
——
——
——
comp2041
comp2041
comp2041
comp2041
comp2041
comp2041
DS/Sets, Relations & Functions
DS/Basic Logic
DS/Proof Techniques
DS/Basics of Counting
DS/Graphs & Trees
DS/Discrete Probability
cs103
cs103
cs103
cs103
cs103
cs109
——
——
——
——
——
——
15-151
15-151
15-151
15-151
15-151
15-151
math1081
math1081
math1081
math1081
math1081
math1081
SP/Social Context
SP/Analytical Tools
SP/Professional Ethics
SP/Intellectual Property
SP/Privacy and Civil Liberties
SP/Professional Communication
——
——
——
——
——
——
——
——
——
——
——
——
15-221
15-221
15-221
15-221
15-221
15-221
comp4920
comp4920
comp4920
comp4920
comp4920
comp4920
Summary
• comp1917 and comp1927, while retaining their primary focus on programming and algorithms, could perhaps be modified to include a brief
introduction to operating systems, unit testing and software lifecycle
(borrowing elements from cs106, cs61A or 15-122).
• comp2121 might be a bit too “low-level” for CompSci and SoftEng
students – could be modified to include less on sensors/interfacing and
more on computer organization, compilation and execution (similar to
cs107, cs61C or 15-213).
• comp2911 could include software development, basic network protocols, database, and a team-based project based on a simple networked
application (similar to cs110 or part of 15-213).
• comp2041 contains some elements that would be valuable also for
CompEng students (e.g. networking), others that are specific to CompSci and SoftEng. Perhaps the common elements could be moved to
other course(s), replaced by material specific to CompSci/SoftEng.
• should try to find some place in the curriculum for basic automata,
comptability and complexity (cs103, cs61B, 15-251).
Stanford
Programming Abstractions (CS106B or CS106X)
CS106B introduces students to many fundamental programming concepts
and software engineering techniques using the C++ language. The course
will focus on teaching problem solving skills, basic abstract data typs, and recursion. General topics include basic programming methodology (engineering, modularity, documentation), data abstractions (stacks, queues, linked
lists, hash tables, binary trees, generics and templates), recursion (procedural, backtracking), searching and sorting, and basic algorithmic analysis
(including Big-Oh notation).
Computer Organization and Systems (CS107)
CS107 transitions students to programming on the UNIX machines. The
class aims to teach students about computer systems from the hardware up
to the source code. Topics include machine architecture (registers, I/O, basic assembly language), memory models (pointers, memory allocation, data
representation), compilation (stack frames, semantic analysis, code generation), and basic concurrency (threading, synchronization).
Principles of Computer Systems (CS110)
CS110 will teach students how to build larger scale systems using operating
system and networking abstractions. Topics include processes (threading,
context switching, interprocess communication), storage and file management (file systems, virtual memory), networking (sockets, TCP/IP, routing)
and an understanding of distributed systems.
Mathematical Foundations of Computing (CS103)
CS103 will give students the mathematical foundations necessary for computer science. Topics include proof techniques and logic; induction; sets,
functions, and relations; an introduction to formal languages; DFA’s, NFA’s,
and Regular Expressions; Context-Free Grammars, Turing Machines, and
NP-Completeness.
Introduction to Probability for Computer Scientists (CS109)
CS109 is designed to teach students material from probability and statistics
that is relevant to computer science. Topics include combinatorics; probability theory; conditional probability, and independence; probability distributions; Bayes’ Theorem, Law of Large Numbers, and the Central Limit
Theorem; and hypothesis testing. The class will also cover applications of
probability including hashing, data analysis, inference, and an introduction
to machine learning.
Data Structures and Algorithms (CS161)
CS161 gives students the tools to analyze data structures and algorithms.
Students will also practice devising algorithms for various problems. These
skills are widely applicable and alumni report CS161 as one of the most useful classes at Stanford. Topics include algorithmic complexity analysis (Big
Oh, Omega, Theta), recurrence relations, and the master method. In addition, students learn about several different classes of algorithms and data
structures, including randomized algorithms, divide and conquer strategies,
greedy algorithms, hasing, heaps, graph algorithms, and search algorithms
(including blind and A* search).
Berkeley
CS61A The Structure and Interpretation of Computer Programs
The CS 61 series is an introduction to computer science, with particular
emphasis on software and on machines from a programmer’s point of view.
This first course concentrates mostly on the idea of abstraction, allowing the
programmer to think in terms appropriate to the problem rather than in lowlevel operations dictated by the computer hardware. The next course, CS
61B, will deal with the more advanced engineering aspects of software, such
as constructing and analyzing large programs. Finally, CS 61C concentrates
on machines and how they carry out the programs you write.
In CS 61A, we are interested in teaching you about programming, not about
how to use one particular programming language. We consider a series of
techniques for controlling program complexity, such as functional programming, data abstraction, and object-oriented programming. Mastery of a
particular programming language is a very useful side effect of studying
these general techniques. However, our hope is that once you have learned
the essence of programming, you will find that picking up a new programming language is but a few days’ work.
61A uses the Python 3 programming language. In previous semesters, this
course was taught using the Scheme language, a dialect of Lisp.
CS61B Data Structures
CS 61B is the second course in the CS 61 series. In this course, you will study
advanced programming techniques including data structures, encapsulation,
abstract data types, interfaces, and algorithms for sorting and searching, and
you will get a taste of software engineering the design and implementation
of large programs.
CS61C Great Ideas in Computer Architecture
Starting this semester, Fall 2010, we are reinventing CS61C, starting with
a blank page as to what makes sense to teach of computer architecture and
hardware in 2010 that will give a solid foundation on the topic on which to
build that should last for decades.
Rather the be something of a catchall, as in the past, the goal is to learn
the great ideas of computer design and implementation:
• Memory Hierarchy (e.g., Caches)
• Thread Level Parallelism (e.g., Multicore)
• Data Level Parallelism (e.g., MapReduce and Graphical Processing
Units or GPUs)
• Instruction Level Parallelism (e.g., Pipelining)
• The Transistor and its rate of change (e.g., Moore’s Law)
• Quantitative Evaluation (e.g., GFLOPS, Clocks Per Instruction or
CPI)
• Layering of Hardware Levels of Abstraction (e.g., AND gates, Arithmetic Logic Unit or ALU, Central Processing Units or CPU)
• Compilation vs. Interpretation (e.g., C compiler, Java interpreter)
• Hardware Instruction Set Interpretation (e.g., instructions as binary
numbers)
• The idea is to go over the big ideas at a higher level in the first twothirds of the course, and then go back in more depth in the last third
of the course.
We use a running example through the whole course to illustrate the ideas,
and will be the basis of a programming contest in the last third of the course
to see who can make the fastest version running on the latest multicore
hardware.
We use the C programming language and MIPS assembly language to demonstrate these great ideas. The course closely follows the Patterson and Hennessy textbook supplemented by material on the C programming language.
A sample week-by-week outline follows.
1. Introduction - Moblie Client vs. Cloud Server
2. C programming language vs MIPS assembly language
3. Computer Components and Compilation vs. Interpreation
4. Quantitative Evaluation
5. Memory Hiearchy
6. Thread Level Parallelism
7. Data Level Parallelism
8. Transistors and Logic
9. Layers of HW Abstraction
10. Instruction Level Parallelism
11. In More Depth: Cache associativity, Cache coherence, Locks
12. In More Depth: Illusion of machine to yourself - Virtual Memory,
Virtual Machines
13. In More Depth: Dependability via Redundancy - Error Correcting
Codes, Redundant Array of Inexpensive Disks
14. Contest Results and Conclusion
CMU
15-122 Principles of Imperative Computation
For students with a basic understanding of programming (variables, expressions, loops, arrays, functions). Teaches imperative programming and
methods for ensuring the correctness of programs. Students will learn the
process and concepts needed to go from high-level descriptions of algorithms
to correct imperative implementations, with specific application to basic
data structures and algorithms. Much of the course will be conducted in a
subset of C amenable to verification, with a transition to full C near the end.
This course prepares students for 15-213 and 15-210. NOTE: students must
achieve a C or better in order to use this course to satisfy the pre-requisite
for any subsequent Computer Science course.
15-150 Principles of Functional Programming
Description: An introduction to programming based on a ”functional” model
of computation. The functional model is a natural generalization of algebra
in which programs are formulas that describe the output of a computation
in terms of its inputs—that is, as a function. But instead of being confined
to real- or complex-valued functions, the functional model extends the algebraic view to a very rich class of data types, including not only aggregates
built up from other types, but also functions themselves as values. This
course is an introduction to programming that is focused on the central
concepts of function and type. One major theme is the interplay between
inductive types, which are built up incrementally; recursive functions, which
compute over inductive types by decomposition; and proof by structural induction, which is used to prove the correctness and time complexity of a
recursive function. Another major theme is the role of types in structuring large programs into separate modules, and the integration of imperative
programming through the introduction of data types whose values may be
altered during computation. NOTE: students must achieve a C or better
in order to use this course to satisfy the pre-requisite for any subsequent
Computer Science course.
15-151 Mathematical Foundations for Computer Science
This course is offered to incoming Computer Science freshmen and focuses
on the fundamental concepts in Mathematics that are of particular interest
to Computer Science such as logic, sets,induction, functions, and combinatorics. These topics are used as a context in which students learn to
formalize arguments using the methods of mathematical proof. Unlike more
traditional courses, we use experimentation and collaboration as ways to
gain better understanding of the material. Non-CS freshmen would take
21-127 instead.
15-210 Parallel and Sequential Data Structures and Algorithms
Teaches students about how to design, analyze, and program algorithms and
data structures. The course emphasizes parallel algorithms and analysis, and
how sequential algorithms can be considered a special case. The course goes
into more theoretical content on algorithm analysis than 15-122 and 15-150
while still including a significant programming component and covering a
variety of practical applications such as problems in data analysis, graphics,
text processing, and the computational sciences. NOTE: students must
achieve a C or better in order to use this course to satisfy the pre-requisite
for any subsequent Computer Science course.
15-213 Introduction to Computer Systems
This course provides a programmer’s view of how computer systems execute programs, store information, and communicate. It enables students
to become more effective programmers, especially in dealing with issues
of performance, portability and robustness. It also serves as a foundation
for courses on compilers, networks, operating systems, and computer architecture, where a deeper understanding of systems-level issues is required.
Topics covered include: machine-level code and its generation by optimizing
compilers, performance evaluation and optimization, computer arithmetic,
memory organization and management, networking technology and protocols, and supporting concurrent computation. NOTE: students must achieve
a C or better in order to use this course to satisfy the pre-requisite for any
subsequent Computer Science course.
15-251 Great Theoretical Ideas in Computer Science
This course is about how to use theoretical ideas to formulate and solve problems in computer science. It integrates mathematical material with general
problem solving techniques and computer science applications. Examples
are drawn from Algorithms, Complexity Theory, Game Theory, Probability Theory, Graph Theory, Automata Theory, Algebra, Cryptography, and
Combinatorics. Assignments involve both mathematical proofs and programming. NOTE: students must achieve a C or better in order to use
this course to satisfy the pre-requisite for any subsequent Computer Science
course.
15-451 Algorithm Design and Analysis
This course is about the design and analysis of algorithms. We study specific
algorithms for a variety of problems, as well as general design and analysis
techniques. Specific topics include searching, sorting, algorithms for graph
problems, efficient data structures, lower bounds and NP-completeness. A
variety of other topics may be covered at the discretion of the instructor.
These include parallel algorithms, randomized algorithms, geometric algorithms, low level techniques for efficient programming, cryptography, and
cryptographic protocols.
15-221 Technical Communication for Computer Scientists
The course is designed for sophomore computer science majors to improve
their abilities in practical, professional communications (both written and
oral). It aims to help students compose clear, concise technical writings
and oral presentations for multi-level audiences. Assignments include technical definitions, descriptions, instructions, process explanations, abstracts,
memos, and research reports. Assignments may incorporate recent computer
science research at Carnegie Mellon, projects in related technical courses,
and professional case studies. Sophomores will likely find the course more
useful if they have either had an internship or faculty-supervised research,
including SURG projects prior to enrollment.
UNSW
COMP1917 Computing 1
The objective of this course is for students to develop proficiency in programming using a high level language. Topics covered include: fundamental programming concepts, program testing and debugging, the underlying
memory representation of data, programming style. Practical experience of
these topics is supplied by laboratory programming exercises and assignments.
COMP1927 Compiting 2
Programming in the large, abstraction and ADTs, interfaces, complexity.
Data types and data structures: lists, trees, graphs; and associated algorithms. Programming assignments, laboratory exercises, formal examination. Preparation work may be available for interested students before the
course starts (see course outline for details).
MATH1131 Mathematics 1A
Complex numbers, vectors and vector geometry, linear equations, matrices
and matrix algebra, determinants. Functions, limits, continuity and differentiability, integration, polar coordinates, logarithms and exponentials,
hyperbolic functions. Introduction to computing and the Maple symbolic
algebra package.
MATH1231 Mathematics 1B
Vector spaces, linear transformations, eigenvalues and eigenvectors. Introduction to probability and statistics. Integration techniques, solution of
ordinary differential equations, sequences, series, applications of integration.
MATH1081 Discrete Mathematics
Role of proof in mathematics, logical reasoning and implication, different
types of proofs. Sets, algebra of sets, operations on sets. Mathematical logic,
truth tables, syntax, induction. Graphs and directed graphs, basic graph
algorithms. Counting, combinatorial identities, binomial and multinomial
theorems. Binary operations and their properties, ordered structures. Recursion relations.
COMP2911 Engineering Design in Computing
The engineering design and use of reliable and complex systems. Object
orientation and design. Problem solving design methodologies: backtrack,
greedy method, divide and conquer, dynamic methods. Practical assignments, laboratory exercises, formal examination.
COMP2121 Microprocessors & Interfacing
Instruction Set Architecture (ISA), Floating point number representation,
computer arithmetic, assembly and machine language programming, machine language fundamentals; addressing modes; instruction repertoire, assembly language programming methodology, interrupts and I/O interfacing
(hardware and software), serial communication, timers, analog input and
output, converting analog signals to digital signals (data acquisition), taking input from a variety of sensors and driving actuators, buses and memory
system, low level device drivers.
COMP2041 Software Construction
Software system decomposition and design. Overview of the software development life-cycle. Command languages. Version control and configuration management, programming for reliability. Testing and debugging
techniques. Profiling and code improvement techniques. Practical work
involving programming-in-the-large.
COMP4920 Management and Ethics
This course will develop a framework on which management and ethical
issues can be developed. Topics covered will include management issues
such as:
• management of innovation
• engineering project planning and control
• human factors
• patents
• technical strategy
In addition, the following ethics topics will be covered:
• introduction to ethics
• workable ethical theories
• morality of breaking the law
• privacy
• public information and records
• and related topics