Awesome Courses
Introduction
There is a lot of ~~hidden~~ treasure lying within university pages
scattered across the internet. This list is an attempt to bring to light
those awesome courses which make their high-quality material i.e.
assignments, lectures, notes, readings & examinations available
online for free.
Table of Contents
Legend
- Lecture Videos
- Lecture Notes
- Assignments / Labs
- Readings
Courses
Systems
- CS 61C Great Ideas in Computer Architecture (Machine Structures) UC Berkeley
- CS 107 Computer Organization & Systems Stanford University
- CS107 is the third course in Stanford's introductory programming
sequence. The course will work from the C programming language down to
the microprocessor to de-mystify the machine. With a complete
understanding of how computer systems execute programs and manipulate
data, you will become a more effective programmer, especially in dealing
with issues of debugging, performance, portability, and robustness.
- Lecture Videos
- Assignments
- CS 140 Operating Systems Stanford University
- This class introduces the basic facilities provided in modern
operating systems. The course divides into three major sections. The
first part of the course discusses concurrency. The second part of the
course addresses the problem of memory management. The third major part
of the course concerns file systems.
- Lecture Notes
- Assignments
- CS 162 Operating Systems and Systems Programming UC Berkeley
- The purpose of this course is to teach the design of operating
systems and operating systems concepts that appear in other advanced
systems. Topics we will cover include concepts of operating systems,
systems programming, networked and distributed systems, and storage
systems, including multiple-program systems (processes, interprocess
communication, and synchronization), memory allocation (segmentation,
paging), resource allocation and scheduling, file systems, basic
networking (sockets, layering, APIs, reliability), transactions,
security, and privacy.
- CS 168 Introduction to the Internet: Architecture and Protocols UC Berkeley
- This course is an introduction to the Internet architecture. We will
focus on the concepts and fundamental design principles that have
contributed to the Internet's scalability and robustness and survey the
various protocols and algorithms used within this architecture. Topics
include layering, addressing, intradomain routing, interdomain routing,
reliable delivery, congestion control, and the core protocols (e.g.,
TCP, UDP, IP, DNS, and HTTP) and network technologies (e.g., Ethernet,
wireless).
- Lecture Notes & Assignments
- Discussion Notes
- CS 179 GPU Programming Caltech
- This course will cover programming techniques for the GPU. The
course will introduce NVIDIA's parallel computing language, CUDA. Beyond
covering the CUDA programming model and syntax, the course will also
discuss GPU architecture, high performance computing on GPUs, parallel
algorithms, CUDA libraries, and applications of GPU computing.
- Assignments
- Lecture Notes
- CS 186 Introduction to Database Systems UC Berkeley
- In the project assignments in CS186, you will write a basic database
management system called SimpleDB. For this project, you will focus on
implementing the core modules required to access stored data on disk; in
future projects, you will add support for various query processing
operators, as well as transactions, locking, and concurrent queries.
- Lecture Notes
- Projects
- CS 241 Systems Programming (Fall 2014) Univ of Illinois, Urbana-Champaign
- System programming refers to writing code that tasks advantage of
operating system support for programmers. This course is designed to
introduce you to system programming. By the end of this course, you
should be proficient at writing programs that take full advantage of
operating system support. To be concrete, we need to fix an operating
system and we need to choose a programming language for writing
programs. We chose the C language running on a Linux/UNIX operating
system (which implements the POSIX standard interface between the
programmer and the OS).
- Assignments
- Github Page
- Crowd Sourced Book
- CS 425 Distributed Systems Univ of Illinois, Urbana-Champaign
- Brilliant set of lectures and reading material covering fundamental
concepts in distributed systems such as Vector clocks, Consensus and
Paxos. This is the 2014 version by Prof Indranil Gupta.
- Lectures
- Assignments
- CS 452 Real-Time Programming University of Waterloo
- Write a real-time OS microkernel in C, and application code to
operate a model train set in response to real-time sensor information.
The communication with the train set runs at 2400 baud so it takes about
61 milliseconds to ask all of the sensors for data about the train's
possible location. This makes it particularly challenging because a
train can move about 3 centimeters in that time. One of the most
challenging and time-consuming courses at the University of Waterloo.
- Assignments
- Lecture notes
- CS 2043 Unix Tools & Scripting Cornell University
- UNIX-like systems are increasingly being used on personal computers,
mobile phones, web servers, and many other systems. They represent a
wonderful family of programming environments useful both to computer
scientists and to people in many other fields, such as computational
biology and computational linguistics, in which data is naturally
represented by strings. This course provides an intensive training to
develop skills in Unix command line tools and scripting that enable the
accomplishment and automation of large and challenging computing tasks.
The syllabus takes students from shell basics and piping, to
regular-expression processing tools, to shell scripting and Python.
- Syllabus
- Lectures
- Assignments
- CS 3410 Computer System Organization and Programming Cornell University
- CS3410 provides an introduction to computer organization, systems
programming and the hardware/software interface. Topics include
instruction sets, computer arithmetic, datapath design, data formats,
addressing modes, memory hierarchies including caches and virtual
memory, I/O devices, bus-based I/O systems, and multicore architectures.
Students learn assembly language programming and design a pipelined
RISC processor.
- Lectures
- Assignments
- CS 4410 Operating Systems Cornell University
- CS 4410 covers systems programming and introductory operating system
design and implementation. We will cover the basics of operating
systems, namely structure, concurrency, scheduling, synchronization,
memory management, filesystems, security and networking. The course is
open to any undergraduate who has mastered the material in
CS3410/ECE3140.
- Syllabus
- Lectures
- CS 4414 Operating Systems University of Virginia
- A course (that) covers topics including: Analysis process
communication and synchronization; resource management; virtual memory
management algorithms; file systems; and networking and distributed
systems. The primary goal of this course is to improve your ability to
build scalable, robust and secure computing systems. It focuses on doing
that by understanding what underlies the core abstractions of modern
computer systems.
- Syllabus
- Lectures
- CS 5412 Cloud Computing Cornell University
- Taught by one of the stalwarts of this field, Prof Ken Birman, this
course has a fantastic set of slides that one can go through. The Prof's
book is also a gem and recommended as a must read in Google's tutorial on Distributed System Design
- Slides
- CSCE 3613 Operating Systems University of Arkansas (Fayetteville)
- An introduction to operating systems including topics in system
structures, process management, storage management, files, distributed
systems, and case studies.
- CSCI-UA.0202: Operating Systems (Undergrad) Operating Systems NYU
- NYU's operating system course. It's a fundamental course focusing
basic ideas of operating systems, including memory management, process
shceduling, file system, ect. It also includes some recomended reading
materials. What's more, there are a series of hands-on lab materials,
helping you easily understand OS.
- Assignments
- Lectures
- Old Exams
- CSCI 360 Computer Architecture 3 CUNY Hunter College
- A course that covers cache design, buses, memory hierarchies,
processor-peripheral interfaces, and multiprocessors, including GPUs.
- CSCI 493.66 UNIX System Programming (formerly UNIX Tools) CUNY Hunter College
- A course that is mostly about writing programs against the UNIX API,
covering all of the basic parts of the kernel interface and libraries,
including files, processes, terminal control, signals, and threading.
- CSCI 493.75 Parallel Computing CUNY Hunter College
- The course is an introduction to parallel algorithms and parallel
programming in C and C++, using the Message Passing Interface (MPI) and
the OpenMP application programming interface. It also includes a brief
introduction to parallel architectures and interconnection networks. It
is both theoretical and practical, including material on design
methodology, performance analysis, and mathematical concepts, as well as
details on programming using MPI and OpenMP.
- Hack the Kernel Introduction to Operating Systems SUNY University at Buffalo, NY
- This course is an introduction to operating system design and
implementation. We study operating systems because they are examples of
mature and elegant solutions to a difficult design problem: how to
safely and efficiently share system resources and provide abstractions
useful to applications.
- For the processor, memory, and disks, we discuss how the operating
system allocates each resource and explore the design and implementation
of related abstractions. We also establish techniques for testing and
improving system performance and introduce the idea of hardware
virtualization. Programming assignments provide hands-on experience with
implementing core operating system components in a realistic
development environment. Course by Dr.Geoffrey Challen
- Syllabus
- Slides
- Video lectures
- Assignments
- Old Exams
- ECE 459 Programming for Performance University of Waterloo
- Learn techniques for profiling, rearchitecting, and implementing
software systems that can handle industrial-sized inputs, and to design
and build critical software infrastructure. Learn performance
optimization through parallelization, multithreading, async I/O,
vectorization and GPU programming, and distributed computing.
- Lecture slides
- MAE 6740 Hybrid Systems Cornell University
- This course will discuss the modeling of hybrid systems, the
analysis and simulation of their behavior, different control
methodologies as well as verification techniques. To complement the
theoretical aspect, several state of the art tools will be introduced.
New and emerging topics in hybrid systems research will be presented as
well. As the field of hybrid systems is a truly interdisciplinary one,
drawing researchers from dynamical systems, control theory, computer
aided verification, automata theory and other fields, one of the goals
of this course is to teach students the language that will allow them to
bridge the gap between these traditionally disjoint disciplines.
- Lectures
- Readings
- PODC Principles of Distributed Computing ETH-Zurich
- Explore essential algorithmic ideas and lower bound techniques,
basically the "pearls" of distributed computing in an easy-to-read set
of lecture notes, combined with complete exercises and solutions.
- Book
- Assignments and Solutions
- SPAC Parallelism and Concurrency Univ of Washington
- Technically not a course nevertheless an awesome collection of
materials used by Prof Dan Grossman to teach parallelism and concurrency
concepts to sophomores at UWash
- VU:Distributed Systems Distributed Systems: Principles and Paradigms (Fall 2012) Vrije Universiteit, Amsterdam
- Distributed systems often appear to be highly complex and
intertwined networked systems. Touching one component often affects many
others in surprising ways. In this course, we aim at explaining the
basics of distributed systems by systematically taking different
perspectives, and subsequently bringing these perspectives together by
looking at often-applied organizations of distributed systems. This
course closely follows the timeless classic Distributed Systems: Principles and Paradigms by some of the pioneers in the field of Distributes systems-Andrew S. Tanenbaum and Maarten van Steen
- Slides
- Video lectures
- Exams
- 6.824 Distributed Systems MIT
- MIT's graduate-level DS course with a focus on fault tolerance,
replication, and consistency, all taught via awesome lab assignments in
Golang!
- Assignments - Just do
git clone git://g.csail.mit.edu/6.824-golabs-2014 6.824
- Readings
- 6.828 Operating Systems MIT
- MIT's operating systems course focusing on the fundamentals of OS
design including booting, memory management, environments, file systems,
multitasking, and more. In a series of lab assignments, you will build
JOS, an OS exokernel written in C.
- Assignments
- Lectures
- Videos
Note: These are student recorded cam videos of the 2011 course. The
videos explain a lot of concepts required for the labs and assignments.
- 15-213 Introduction to Computer Systems (ICS) Carnegie-Mellon University
- The ICS 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.
- This is the must-have course for everyone in CMU who wants to learn
some computer science no matter what major are you in. Because it's CMU
(The course number is as same as the zip code of CMU)!
- Lecture Notes
- Videos
- Assignments
- 15-418Parallel Computer Architecture and Programming Carnegie-Mellon University
- The goal of this course is to provide a deep understanding of the
fundamental principles and engineering trade-offs involved in designing
modern parallel computing systems as well as to teach parallel
programming techniques necessary to effectively utilize these machines.
Because writing good parallel programs requires an understanding of key
machine performance characteristics, this course will cover both
parallel hardware and software design.
- Assignments
- Lecture Notes
- Lecture Videos
- Readings
- 15-440 Distributed Systems Carnegie-Mellon University
- Introduction to distributed systems with a focus on teaching concepts via projects implemented in the Go programming language.
- Assignments
- 15-721 Database Systems Carnegie-Mellon University
- This course is a comprehensive study of the internals of modern
database management systems. It will cover the core concepts and
fundamentals of the components that are used in both high-performance
transaction processing systems (OLTP) and large-scale analytical systems
(OLAP). The class will stress both efficiency and correctness of the
implementation of these ideas. All class projects will be in the context
of a real in-memory, multi-core database system. The course is
appropriate for graduate students in software systems and for advanced
undergraduates with strong systems programming skills.
- Assignments
- Lecture Videos
- Readings
- 15-749 Engineering Distributed Systems Carnegie-Mellon University
- A project focused course on Distributed Systems with an awesome list of readings
- 18-447 Introduction to Computer Architecture CMU
- Very comprehensive material on Computer Architecture - definitely
more than just "introduction". Online material is very user-friendly,
even the recitation videos available online. This is the Spring'14
version by Prof. Onur Mutlu
- Lectures and Recitation
- Homeworks 7 HWs with answer set as well
- Readings (http://www.ece.cmu.edu/~ece447/s14/doku.php?id=readings)
Programming Languages / Compilers
- CIS 194 Introduction to Haskell Penn Engineering
- Explore the joys of functional programming, using Haskell as a
vehicle. The aim of the course will be to allow you to use Haskell to
easily and conveniently write practical programs.
- Previous semester also available, with more exercises
- Assignments & Lectures
- CIS 198 Rust Programming UPenn
- This course covers what makes Rust so unique and applies it to
practical systems programming problems. Topics covered include traits
and generics; memory safety (move semantics, borrowing, and lifetimes);
Rust’s rich macro system; closures; and concurrency.
- Assignments
- Clojure Functional Programming with Clojure University of Helsinki
- The course is an introduction to functional programming with a
dynamically typed language Clojure. We start with an introduction to
Clojure; its syntax and development environment. Clojure has a good
selection of data structures and we cover most of them. We also go
through the basics of recursion and higher-order functions. The course
material is in English.
- Github Page
- CMSC 430 Introduction to Compilers Univ of Maryland
- The goal of CMSC 430 is to arm students with the ability to design,
implement, and extend a programming language. Throughout the course,
students will design and implement several related languages, and will
explore parsing, syntax querying, dataflow analysis, compilation to
bytecode, type systems, and language interoperation.
- Lecture Notes
- Assignments
- COS 326 Functional Programming Princeton University
- Covers functional programming concepts like closures, tail-call recursion & parallelism using the OCaml programming language
- Lectures
- Assignments
- CS 143 Compiler construction Stanford University
- CS 164 Hack your language! UC Berkeley
- CS 173 Programming Languages Brown University
- Course by Prof. Krishnamurthi (author of HtDP) and numerous other awesome books on programming languages. Uses a custom designed Pyret programming language to teach the concepts. There was an online class hosted in 2012, which includes all lecture videos for you to enjoy.
- Videos
- Assignments
- CS 223 Purely Functional Data Structures In Elm University of Chicago
- This course teaches functional reactive programming and purely
functional data structures based on Chris Okazaki's book and using the
Elm programming language.
- Lectures
- Assignments
- CS 240h Functional Systems in Haskell Stanford University
- CS 421 Programming Languages and Compilers Univ of Illinois, Urbana-Champaign
Course that uses OCaml to teach functional programming and programming language design.
- CS 3110 Data Structures and Functional Programming Cornell University
- Another course that uses OCaml to teach alternative programming paradigms, especially functional and concurrent programming.
- Lecture Slides
- Assignments
- CS 4120 Introduction to Compilers Cornell University
- An introduction to the specification and implementation of modern
compilers. Topics covered include lexical scanning, parsing, type
checking, code generation and translation, an introduction to
optimization, and compile-time and run-time support for modern
programming languages. As part of the course, students build a working
compiler for an object-oriented language.
- Syllabus
- Lectures
- Assignments
- CS 4400 Programming Languages Northeastern University
- This is a course on the study, design, and implementation of programming languages.
- The course works at two simultaneous levels: first, we will use a
programming language that can demonstrate a wide variety of programming
paradigms. Second, using this language, we will learn about the
mechanics behind programming languages by implementing our own
language(s). The two level approach usually means that we will often see
how to use a certain feature, and continue by implementing it.
- Syllabus
- Lecture Notes/Resources
- Homework
- CS 4610 Programming Languages and Compilers University of Virginia
- Course that uses OCaml to teach functional programming and
programming language design. Each assignment is a part of an interpreter
and compiler for an object-oriented language similar to Java, and you
are required to use a different language for each assignment (i.e.,
choose 4 from Python, JS, OCaml, Haskell, Ruby).
- Lecture Notes
- Assignments
- CS 5114 Network Programming Languages Cornell University
- An introduction to the specification and implementation of modern
compilers. Topics covered include lexical scanning, parsing, type
checking, code generation and translation, an introduction to
optimization, and compile-time and run-time support for modern
programming languages. As part of the course, students build a working
compiler for an object-oriented language.
- Syllabus
- Lectures
- CS 5142 Scripting Languages Cornell University
- Perl, PHP, JavaScript, VisualBasic -- they are often-requested
skills for employment, but most of us do not have the time to find out
what they are all about. In this course, you learn how to use scripting
languages for rapid prototyping, web programming, data processing, and
application extension. Besides covering traditional programming
languages concepts as they apply to scripting (e.g., dynamic typing and
scoping), this course looks at new concepts rarely found in traditional
languages (e.g., string interpolation, hashes, and polylingual code).
Through a series of small projects, you use different languages to
achieve programming tasks that highlight the strengths and weaknesses of
scripting. As a side effect, you practice teaching yourself new
languages.
- Syllabus
- Lectures
- Assignments
- CS 5470 Compilers University of Utah
- If you're a fan of Prof Matt's writing on his fantastic blog
you ought to give this a shot. The course covers the design and
implementation of compilers, and it explores related topics such as
interpreters, virtual machines and runtime systems. Aside from the
Prof's witty take on cheating the page has tons of interesting links on programming languages, parsing and compilers.
- Lecture Notes
- Projects
- CS 6118 Types and Semantics Cornell University
- Types and Semantics is about designing and understand programming
languages, whether they be domain specific or general purpose. The goal
of this class is to provide a variety of tools for designing custom
(programming) languages for whatever task is at hand. Part of that will
be a variety of insights on how languages work along with experiences
from working with academics and industry on creating new languages such
as Ceylon and Kotlin. The class focuses on types and semantics and the
interplay between them. This means category theory and constructive type
theory (e.g. Coq and richer variations) are ancillary topics of the
class. The class also covers unconventional semantic domains such as
classical linear type theory in order to both break students from
convential thinking and to provide powerful targets capable of
formalizing thinks like networking protocols, resource-sensitive
computation, and concurrency constructs. The class project is to design
and formalize a (programming) language for a purpose of the student's
choosing, and assignments are designed to ensure students have had a
chance to practice applying the techniques learned in class before
culminating these skills in the class project.
- Syllabus
- Lectures
- CSC 253 CPython internals: A ten-hour codewalk through the Python interpreter source code University of Rochester
- Nine lectures walking through the internals of CPython, the canonical Python interpreter implemented in C. They were from the Dynamic Languages and Software Development course taught in Fall 2014 at the University of Rochester.
- CSE 341 Programming Languages University of Washington
- Covers non-imperative paradigms and languages such as Ruby, Racket, and ML and the fundamentals of programming languages.
- Lectures
- Assignments and Tests
- CSE P 501 Compiler Construction University of Washington
- Teaches understanding of how a modern compiler is structured and the
major algorithms that are used to translate code from high-level to
machine language. The best way to do this is to actually build a working
compiler, so there will be a significant project to implement one that
translates programs written in a core subset of Java into executable x86
assembly language. The compilers themselves will use scanner and parser
generator tools and the default implementation language is Java.
- Lectures
- Assignments, Tests, and Solutions
- DMFP Discrete Mathematics and Functional Programming Wheaton College
- PCPP Practical Concurrent and Parallel Programming IT University of Copenhagen
- In this MSc course you learn how to write correct and efficient
concurrent and parallel software, primarily using Java, on standard
shared-memory multicore hardware.
- The course covers basic mechanisms such as threads, locks and shared
memory as well as more advanced mechanisms such as parallel streams for
bulk data, transactional memory, message passing, and lock-free data
structures with compare-and-swap.
- It covers concepts such as atomicity, safety, liveness and deadlock.
- It covers how to measure and understand performance and scalability of parallel programs.
- It covers tools and methods to find bugs in concurrent programs.
- 6.945 Adventures in Advanced Symbolic Programming MIT
- Taught by Gerald Sussman of SICP fame, this class deals with
concepts and techniques for the design an implementation of large
software systems that can be adapted to uses not anticipated by the
designer. Applications include compilers, computer-algebra systems,
deductive systems, and some artificial intelligence applications.
- Assignments:
Extensive programming assignments, using MIT/GNU Scheme. Students
should have significant programming experience in Scheme, Common Lisp,
Haskell, CAML or other "functional" language.
- Readings
Algorithms
- CS 61B Data Structures UC Berkeley
- 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.
- Full Lecture Materials
Lecture of Spring 2016. This website contains full matrials including
video links, labs, homeworks, projects. Very good for self-learner. Also
a good start for Java. And it includes some other usefull resources for
Java Documentation, Data Structure Resources, Git/GitHub and Java
Development Resources. Resources
- Labs The link to labs and projects is included in the website.
- Lecture Videos on Youtube The link to videos is included in the website.
- CS 97SI Introduction to Competitive Programming Stanford University
- Fantastic repository of theory and practice problems across various
topics for students who are interested to participate in ACM-ICPC.
- Lectures and Assignments
- CS 224 Advanced Algorithms Harvard University
- CS 224 is an advanced course in algorithm design, and topics we will
cover include the word RAM model, data structures, amortization, online
algorithms, linear programming, semidefinite programming, approximation
algorithms, hashing, randomized algorithms, fast exponential time
algorithms, graph algorithms, and computational geometry.
- Lecture Videos (Youtube)
- Assignments
- CS 261 A Second Course in Algorithms Stanford University
- Algorithms for network optimization: max-flow, min-cost flow,
matching, assignment, and min-cut problems. Introduction to linear
programming. Use of LP duality for design and analysis of algorithms.
Approximation algorithms for NP-complete problems such as Steiner Trees,
Traveling Salesman, and scheduling problems. Randomized algorithms.
Introduction to online algorithms.
- Lecture Notes, Videos & Assignments (Youtube)
- CS 473/573 Fundamental Algorithms Univ of Illinois, Urbana-Champaign
- Algorithms class covering recursion, randomization, amortization,
graph algorithms, network flows and hardness. The lecture notes by Prof.
Erikson are comprehensive enough to be a book by themselves. Highly
recommended!
- Lecture Notes
- Labs and Exams
- CS 2150 Program & Data Representation University of Virginia
- This data structures course introduces C++, linked-lists, stacks,
queues, trees, numerical representation, hash tables, priority queues,
heaps, huffman coding, graphs, and x86 assembly.
- Lectures
- Assignments
- CS 4820 Introduction to Analysis of Algorithms Cornell University
- This course develops techniques used in the design and analysis of
algorithms, with an emphasis on problems arising in computing
applications. Example applications are drawn from systems and networks,
artificial intelligence, computer vision, data mining, and computational
biology. This course covers four major algorithm design techniques
(greedy algorithms, divide and conquer, dynamic programming, and network
flow), computability theory focusing on undecidability, computational
complexity focusing on NP-completeness, and algorithmic techniques for
intractable problems, including identification of structured special
cases, approximation algorithms, and local search heuristics.
- Lectures
- Assignments
- Syllabus
- CSCI 104 Data Structures and Object Oriented Design University of Southern California (USC)
- CSCI 135 Software Design and Analysis I
CUNY Hunter College
- It is currently an intensive introduction to program development and
problem solving. Its emphasis is on the process of designing,
implementing, and evaluating small-scale programs. It is not supposed to
be a C++ programming course, although much of the course is spent on
the details of C++. C++ is an extremely large and complex programming
language with many features that interact in unexpected ways. One does
not need to know even half of the language to use it well.
- Lectures and Assignments
- CSCI 235 Software Design and Analysis II CUNY Hunter College
- Introduces algorithms for a few common problems such as sorting.
Practically speaking, it furthers the students' programming skills with
topics such as recursion, pointers, and exception handling, and provides
a chance to improve software engineering skills and to give the
students practical experience for more productive programming.
- Lectures and Assignments
- CSCI 335 Software Design and Analysis III
CUNY Hunter College
- This includes the introduction of hashes, heaps, various forms of
trees, and graphs. It also revisits recursion and the sorting problem
from a higher perspective than was presented in the prequels. On top of
this, it is intended to introduce methods of algorithmic analysis.
- Lectures and Assignments
- CSE 331 Software Design and Implementation University of Washington
- Explores concepts and techniques for design and construction of
reliable and maintainable software systems in modern high-level
languages; program structure and design; program-correctness approaches,
including testing.
- Lectures, Assignments, and Exams
- CSE 373 Analysis of Algorithms Stony Brook University
- Prof Steven Skiena's no stranger to any student when it comes to algorithms. His seminal book has been touted by many to be best for getting that job in Google. In addition, he's also well-known for tutoring students in competitive programming competitions. If you're looking to brush up your knowledge on Algorithms, you can't go wrong with this course.
- Lecture Videos
- ECS 122A Algorithm Design and Analysis UC Davis
- Taught by Dan Gusfield
in 2010, this course is an undergraduate introduction to algorithm
design and analysis. It features traditional topics, such as Big Oh
notation, as well as an importance on implementing specific algorithms.
Also featured are sorting (in linear time), graph algorithms,
depth-first search, string matching, dynamic programming,
NP-completeness, approximation, and randomization.
- Syllabus
- Lecture Videos
- Assignments
- ECS 222A Graduate Level Algorithm Design and Analysis UC Davis
- This is the graduate level complement to the ECS 122A undergraduate algorithms course by Dan Gusfield
in 2011. It assumes an undergrad course has already been taken in
algorithms, and, while going over some undergraduate algorithms topics,
focuses more on increasingly complex and advanced algorithms.
- Lecture Videos
- Syllabus
- Assignments
- 6.INT Hacking a Google Interview MIT
- This course taught in the MIT Independent Activities Period in 2009
goes over common solution to common interview questions for software
engineer interviews at highly selective companies like Apple, Google,
and Facebook. They cover time complexity, hash tables, binary search
trees, and other common algorithm topics you should have already covered
in a different course, but goes more in depth on things you wouldn't
otherwise learn in class- like bitwise logic and problem solving tricks.
- Handouts
- Topics Covered
- 6.006 Introduction to Algorithms MIT
- This course provides an introduction to mathematical modeling of
computational problems. It covers the common algorithms, algorithmic
paradigms, and data structures used to solve these problems. The course
emphasizes the relationship between algorithms and programming, and
introduces basic performance measures and analysis techniques for these
problems. This course provides an introduction to mathematical modeling
of computational problems. It covers the common algorithms, algorithmic
paradigms, and data structures used to solve these problems. The course
emphasizes the relationship between algorithms and programming, and
introduces basic performance measures and analysis techniques for these
problems.
- Lecture Videos
- Readings
- Resources
- Old Exams
- 6.046J/18.410J Design and Analysis of Algorithms MIT
- This is an intermediate algorithms course with an emphasis on
teaching techniques for the design and analysis of efficient algorithms,
emphasizing methods of application. Topics include divide-and-conquer,
randomization, dynamic programming, greedy algorithms, incremental
improvement, complexity, and cryptography. This course assumes that
students know how to analyze simple algorithms and data structures from
having taken 6.006. It introduces students to the design of computer algorithms, as well as analysis of sophisticated algorithms.
- Lecture Videos
- Assignments
- Resources
- Old Exams
- 6.851 Advanced Data Structures MIT
- This is an advanced DS course, you must be done with the Advanced Algorithms course before attempting this one.
- Lectures Contains videos from sp2012 version, but there isn't much difference.
- Assignments contains the calendar as well.
- 6.854/18.415J Advanced Algorithms MIT
- Advanced course in algorithms by Dr. David Karger covering topics
such as amortization, randomization, fingerprinting, word-level
parallelism, bit scaling, dynamic programming, network flow, linear
programming, fixed-parameter algorithms, and approximation algorithms.
- Register on NB to access the problem set and lectures.
- 6.854J/18.415J Advanced Algorithms MIT
- This course is a first-year graduate course in algorithms. Emphasis
is placed on fundamental algorithms and advanced methods of algorithmic
design, analysis, and implementation. Techniques to be covered include
amortization, randomization, fingerprinting, word-level parallelism, bit
scaling, dynamic programming, network flow, linear programming,
fixed-parameter algorithms, and approximation algorithms. Domains
include string algorithms, network optimization, parallel algorithms,
computational geometry, online algorithms, external memory, cache, and
streaming algorithms, and data structures. The need for efficient
algorithms arises in nearly every area of computer science. But the type
of problem to be solved, the notion of what algorithms are
"efficient,'' and even the model of computation can vary widely from
area to area. In this second class in algorithms, we will survey many of
the techniques that apply broadly in the design of efficient
algorithms, and study their application in a wide range of application
domains and computational models. The goal is for the class to be broad
rather than deep. Our plan is to touch upon the following areas. This is
a tentative list of topics that might be covered in the class; we will
select material adaptively based on the background, interests, and rate
of progress of the students.
- Lecture Videos - Spring 2016
- Lecture Notes
- Readings
- Resources
- 15-451/651 Algorithms Carnegie Mellon University
- The required algorithms class that go in depth into all basic
algorithms and the proofs behind them. This is one of the heavier
algorithms curriculums on this page. Taught by Avrim Blum and Manuel Blum
who has a Turing Award due to his contributions to algorithms. Course
link includes a very comprehensive set of reference notes by Avrim Blum.
- 16s-4102 Algorithms University of Virginia
CS Theory
- CIS 500 Software Foundations University of Pennsylvania
- An introduction to formal verification of software using the Coq
proof assistant. Topics include basic concepts of logic,
computer-assisted theorem proving, functional programming, operational
semantics, Hoare logic, and static type systems.
- Lectures and Assignments
- Textbook
- CS 103 Mathematical Foundations of Computing Stanford University
- CS103 is a first course in discrete math, computability theory, and
complexity theory. In this course, we'll probe the limits of computer
power, explore why some problems are harder to solve than others, and
see how to reason with mathematical certainty.
- Links to all lectures notes and assignments are directly on the course page
- CS 173 Discrete Structures Univ of Illinois Urbana-Champaign
- This course is an introduction to the theoretical side of computer
science. In it, you will learn how to construct proofs, read and write
literate formal mathematics, get a quick introduction to key theory
topics and become familiar with a range of standard mathematics concepts
commonly used in computer science.
- Textbook Written by the professor. Includes Instructor's Guide.
- Assignments
- Exams
- CS 276 Foundations of Cryptography UC Berkeley
- This course discusses the complexity-theory foundations of modern
cryptography, and looks at recent results in the field such as Fully
Homomorphic Encryption, Indistinguishability Obfuscation, MPC and so on.
- CS 278 Complexity Theory UC Berkeley
- A graduate level course on complexity theory that introduces P vs
NP, the power of randomness, average-case complexity, hardness of
approximation, and so on.
- CS 374 Algorithms & Models of Computation (Fall 2014) University of Illinois Urbana-Champaign
- CS 498 section 374 (unofficially "CS 374") covers fundamental tools
and techniques from theoretical computer science, including design and
analysis of algorithms, formal languages and automata, computability,
and complexity. Specific topics include regular and context-free
languages, finite-state automata, recursive algorithms (including divide
and conquer, backtracking, dynamic programming, and greedy algorithms),
fundamental graph algorithms (including depth- and breadth-first
search, topological sorting, minimum spanning trees, and shortest
paths), undecidability, and NP-completeness. The course also has a
strong focus on clear technical communication.
- Assignments/Exams
- Lecture Notes/Labs
- Lecture videos
- CS 3110 Data Structures and Functional Programming Cornell University
- CS 3110 (formerly CS 312) is the third programming course in the
Computer Science curriculum, following CS 1110/1112 and CS 2110. The
goal of the course is to help students become excellent programmers and
software designers who can design and implement software that is
elegant, efficient, and correct, and whose code can be maintained and
reused.
- Syllabus
- Lectures
- Assignments
- CS 3220 Introduction to Scientific Computing Cornell University
- In this one-semester survey course, we introduce numerical methods
for solving linear and nonlinear equations, interpolating data,
computing integrals, and solving differential equations, and we describe
how to use these tools wisely (we hope!) when solving scientific
problems.
- Syllabus
- Lectures
- Assignments
- CS 4300 Information Retrieval Cornell University
- Studies the methods used to search for and discover information in
large-scale systems. The emphasis is on information retrieval applied to
textual materials, but there is some discussion of other formats.The
course includes techniques for searching, browsing, and filtering
information and the use of classification systems and thesauruses. The
techniques are illustrated with examples from web searching and digital
libraries.
- Syllabus
- Lectures
- Assignments
- CS 4810 Introduction to Theory of Computing Cornell University
- This undergraduate course provides a broad introduction to the
mathematical foundations of computer science. We will examine basic
computational models, especially Turing machines. The goal is to
understand what problems can or cannot be solved in these models.
- Syllabus
- Lectures
- Assignments
- CS 6810 Theory of Computing Cornell University
- This graduate course gives a broad introduction to complexity
theory, including classical results and recent developments. Complexity
theory aims to understand the power of efficient computation (when
computational resources like time and space are limited). Many
compelling conceptual questions arise in this context. Most of these
questions are (surprisingly?) difficult and far from being resolved.
Nevertheless, a lot of progress has been made toward understanding them
(and also why they are difficult). We will learn about these advances in
this course. A theme will be combinatorial constructions with
random-like properties, e.g., expander graphs and error-correcting
codes. Some examples:
- Is finding a solution inherently more difficult than verifying it?
- Do more computational resources mean more computing power?
- Is it easier to find approximate solutions than exact ones?
- Are randomized algorithms more powerful than deterministic ones?
- Is it easier to solve problems in the average case than in the worst case?
- Are quantum computers more powerful than classical ones?
- Syllabus
- Lectures
- Assignments
- CSCE 3193 Programming Paradigms University of Arkansas (Fayetteville)
- Programming in different paradigms with emphasis on object oriented
programming, network programming and functional programming. Survey of
programming languages, event driven programming, concurrency, software
validation.
- Syllabus
- Notes
- Assignments
- Practice Exams
- 6.045 Great Ideas in Theoretical Computer Science MIT
- This course provides a challenging introduction to some of the
central ideas of theoretical computer science. Beginning in antiquity,
the course will progress through finite automata, circuits and decision
trees, Turing machines and computability, efficient algorithms and
reducibility, the P versus NP problem, NP-completeness, the power of
randomness, cryptography and one-way functions, computational learning
theory, and quantum computing. It examines the classes of problems that
can and cannot be solved by various kinds of machines. It tries to
explain the key differences between computational models that affect
their power.
- Syllabus
- Lecture Notes
- Lecture Videos
Introduction to CS
- CS 10 The Beauty and Joy of Computing UC Berkeley
- CS10 is UCB's introductory computer science class, taught using the
beginners' drag-and-drop language. Students learn about history, social
implications, great principles, and future of computing. They also learn
the joy of programming a computer using a friendly, graphical language,
and will complete a substantial team programming project related to
their interests.
- Snap! (based on Scratch by MIT).
- Curriculum
- CS 50 Introduction to Computer Science Harvard University
- CS50x is Harvard College's introduction to the intellectual
enterprises of computer science and the art of programming for majors
and non-majors alike, with or without prior programming experience. An
entry-level course taught by David J. Malan.
- Lectures
- Problem Sets
- The course can also be taken from edX.
- CS 61A Structure and Interpretation of Computer Programs [Python] UC Berkeley
- 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.
- Lecture Resources by Type
- Lecture Resources by Topic
- Additional Resources
- Practice Problems
- Extra Lectures
- CS 61AS Structure & Interpretation of Computer Programs [Racket] UC Berkeley
- A self-paced version of the CS61 Course but in Racket / Scheme. 61AS
is a great introductory course that will ease you into all the amazing
concepts that future CS courses will cover, so remember to keep an open
mind, have fun, and always respect the data abstraction
- Lecture Videos
- Assignments and Notes
- CS 101 Computer Science 101 Stanford University
- CS101 teaches the essential ideas of Computer Science for a
zero-prior-experience audience. Participants play and experiment with
short bits of "computer code" to bring to life to the power and
limitations of computers.
- Lectures videos will available for free after registration.
- CS 106A Programming Methodology Stanford University
- This course is the largest of the introductory programming courses
and is one of the largest courses at Stanford. Topics focus on the
introduction to the engineering of computer applications emphasizing
modern software engineering principles: object-oriented design,
decomposition, encapsulation, abstraction, and testing. Programming
Methodology teaches the widely-used Java programming language along with
good software engineering principles.
- Lecture Videos
- Assignments
- All materials in a zip file
- CS 106B Programming Abstractions Stanford University
- This course is the natural successor to Programming Methodology and
covers such advanced programming topics as recursion, algorithmic
analysis, and data abstraction using the C++ programming language, which
is similar to both C and Java.
- Lectures
- Assignments
- All materials in a zip file
- CS 107 Programming Paradigms Stanford University
- Topics: Advanced memory management features of C and C++; the
differences between imperative and object-oriented paradigms. The
functional paradigm (using LISP) and concurrent programming (using C and
C++)
- Lectures
- Assignments
- [CS 109] (http://otfried.org/courses/cs109/index.html) Programming Practice Using Scala KAIST
- This course introduces basic concepts of programming and computer
science, such as dynamic and static typing, dynamic memory allocation,
objects and methods, binary representation of numbers, using an editor
and compiler from the command line, running programs with arguments from
the command line, using libraries, and the use of basic data structures
such as arrays, lists, sets, and maps. We will use Scala for this
course.
- [Lectures] (http://otfried.org/courses/cs109/index.html)
- Assignments (http://otfried.org/courses/cs109/index.html)
- CS 1109 Fundamental Programming Concepts Cornell University
- This course provides an introduction to programming and problem
solving using a high-level programming language. It is designed to
increase your knowledge level to comfortably continue to courses CS111x.
Our focus will be on generic programming concepts: variables,
expressions, control structures, loops, arrays, functions, pseudocode
and algorithms. You will learn how to analyze problems and convert your
ideas into solutions interpretable by computers. We will use MATLAB;
because it provides a productive environment, and it is widely used by
all engineering communities.
- Syllabus
- Lectures
- Assignments
- CS 1110 Introduction to Computing Using Python Cornell University
- Programming and problem solving using Python. Emphasizes principles
of software development, style, and testing. Topics include procedures
and functions, iteration, recursion, arrays and vectors, strings, an
operational model of procedure and function calls, algorithms,
exceptions, object-oriented programming, and GUIs (graphical user
interfaces). Weekly labs provide guided practice on the computer, with
staff present to help. Assignments use graphics and GUIs to help develop
fluency and understanding.
- Syllabus
- Lectures
- Assignments
- CS 1112 Introduction to Computing Using Matlab Cornell University
- Programming and problem solving using MATLAB. Emphasizes the
systematic development of algorithms and programs. Topics include
iteration, functions, arrays and vectors, strings, recursion,
algorithms, object-oriented programming, and MATLAB graphics.
Assignments are designed to build an appreciation for complexity,
dimension, fuzzy data, inexact arithmetic, randomness, simulation, and
the role of approximation. NO programming experience is necessary; some
knowledge of Calculus is required.
- Syllabus
- Lectures
- Assignments
- Projects
- CS 1115 Introduction to Computational Science and Engineering Using Matlab Graphical User Interfaces Cornell University
- Programming and problem solving using MATLAB. Emphasizes the
systematic development of algorithms and programs. Topics include
iteration, functions, arrays and vectors, strings, recursion,
algorithms, object-oriented programming, and MATLAB graphics.
Assignments are designed to build an appreciation for complexity,
dimension, fuzzy data, inexact arithmetic, randomness, simulation, and
the role of approximation. NO programming experience is necessary; some
knowledge of Calculus is required.
- Syllabus
- Lectures
- Projects
- CS 1130 Transition to OO Programming Cornell University
- Introduction to object-oriented concepts using Java. Assumes
programming knowledge in a language like MATLAB, C, C++, or Fortran.
Students who have learned Java but were not exposed heavily to OO
programming are welcome.
- Syllabus
- Lectures
- Assignments
- CS 1133 Transition to Python Cornell University
- Introduction to the Python programming language. Covers the basic
programming constructs of Python, including assignment, conditionals,
iteration, functions, object-oriented design, arrays, and vectorized
computation. Assumes programming knowledge in a language like Java,
Matlab, C, C++, or Fortran.
- Syllabus
- Lectures
- Assignments
- CS 1410-2 and CS2420-20 Computer Science I and II for Hackers University of Utah
- CS 2110 Object-Oriented Programming and Data Structures Cornell University
- CS 2110 is an intermediate-level programming course and an
introduction to computer science. Topics include program design and
development, debugging and testing, object-oriented programming, proofs
of correctness, complexity analysis, recursion, commonly used data
structures, graph algorithms, and abstract data types. Java is the
principal programming language. The course syllabus can easily be
extracted by looking at the link to lectures.
- Syllabus
- Lectures
- Assignments
- CS 4302 Web Information Systems Cornell University
- This course will introduce you to technologies for building
data-centric information systems on the World Wide Web, show the
practical applications of such systems, and discuss their design and
their social and policy context by examining cross-cutting issues such
as citizen science, data journalism and open government. Course work
involves lectures and readings as well as weekly homework assignments,
and a semester-long project in which the students demonstrate their
expertise in building data-centric Web information systems.
- Syllabus
- Lectures
- Assignments
- CSCE 2004 Programming Foundations I University of Arkansas (Fayetteville)
- Introductory course for students majoring in computer science or
computer engineering. Software development process: problem
specification, program design, implementation, testing and
documentation. Programming topics: data representation, conditional and
iterative statements, functions, arrays, strings, file I/O, and classes.
Using C++ in a UNIX environment.
- Syllabus
- Notes
- Assignments
- Practice Exams
- CS-for-all CS for All Harvey Mudd College
- This book (and course) takes a unique approach to “Intro CS.” In
a nutshell, our objective is to provide an introduction to computer
science as an intellectually rich and vibrant field rather than focusing
exclusively on computer programming. While programming is certainly an
important and pervasive element of our approach, we emphasize concepts
and problem-solving over syntax and programming language features.
- Lectures and Other resources
- 6.001 Structure and Interpretation of Computer Programs MIT
- Teaches big-picture computing concepts using the Scheme programming
language. Students will implement programs in a variety of different
programming paradigms (functional, object-oriented, logical). Heavy
emphasis on function composition, code-as-data, control abstraction with
continuations, and syntactic abstraction through macros. An excellent
course if you are looking to build a mental framework on which to hang
your programming knowledge.
- Lectures
- Textbook (epub, pdf)
- IDE
Machine Learning
- COMS 4771 Machine Learning Columbia University
- Course taught by Tony Jebara
introduces topics in Machine Learning for both generative and
discriminative estimation. Material will include least squares methods,
Gaussian distributions, linear classification, linear regression,
maximum likelihood, exponential family distributions, Bayesian networks,
Bayesian inference, mixture models, the EM algorithm, graphical models,
hidden Markov models, support vector machines, and kernel methods.
- Lectures and Assignments
- CS 109 Data Science Harvard University
- Learning from data in order to gain useful predictions and insights.
This course introduces methods for five key facets of an investigation:
data wrangling, cleaning, and sampling to get a suitable data set; data
management to be able to access big data quickly and reliably;
exploratory data analysis to generate hypotheses and intuition;
prediction based on statistical methods such as regression and
classification; and communication of results through visualization,
stories, and interpretable summaries.
- Lectures
- Slides
- Labs and Assignments
- 2014 Lectures
- 2013 Lectures (slightly better)
- CS 156 Learning from Data Caltech
- This is an introductory course in machine learning (ML) that covers
the basic theory, algorithms, and applications. ML is a key technology
in Big Data, and in many financial, medical, commercial, and scientific
applications. It enables computational systems to adaptively improve
their performance with experience accumulated from the observed data. ML
has become one of the hottest fields of study today, taken up by
undergraduate and graduate students from 15 different majors at Caltech.
This course balances theory and practice, and covers the mathematical
as well as the heuristic aspects.
- Lectures
- Homework
- Textbook
- CS 224d Deep Learning for Natural Language Processing Stanford University
- Natural language processing (NLP) is one of the most important
technologies of the information age. Understanding complex language
utterances is also a crucial part of artificial intelligence.
Applications of NLP are everywhere because people communicate most
everything in language: web search, advertisement, emails, customer
service, language translation, radiology reports, etc. There are a large
variety of underlying tasks and machine learning models powering NLP
applications. Recently, deep learning approaches have obtained very high
performance across many different NLP tasks. These models can often be
trained with a single end-to-end model and do not require traditional,
task-specific feature engineering. In this spring quarter course
students will learn to implement, train, debug, visualize and invent
their own neural network models. The course provides a deep excursion
into cutting-edge research in deep learning applied to NLP.
- Syllabus
- Lectures and Assignments
- CS 229r Algorithms for Big Data Harvard University
- Big data is data so large that it does not fit in the main memory of
a single machine, and the need to process big data by efficient
algorithms arises in Internet search, network traffic monitoring,
machine learning, scientific computing, signal processing, and several
other areas. This course will cover mathematically rigorous models for
developing such algorithms, as well as some provable limitations of
algorithms operating in those models.
- Lectures (Youtube)
- Assignments
- CS 231n Convolutional Neural Networks for Visual Recognition Stanford University
- Computer Vision has become ubiquitous in our society, with
applications in search, image understanding, apps, mapping, medicine,
drones, and self-driving cars. This course is a deep dive into details
of the deep learning architectures with a focus on learning end-to-end
models for these tasks, particularly image classification. During the
10-week course, students will learn to implement, train and debug their
own neural networks and gain a detailed understanding of cutting-edge
research in computer vision.
- Lecture Notes
- Lecture Videos
- Github Page
- CS 287 Advanced Robotics UC Berkeley
- The course introduces the math and algorithms underneath
state-of-the-art robotic systems. The majority of these techniques are
heavily based on probabilistic reasoning and optimization---two areas
with wide applicability in modern Artificial Intelligence. An intended
side-effect of the course is to generally strengthen your expertise in
these two areas.
- Lectures Notes
- Assignments
- CS 395T Statistical and Discrete Methods for Scientific Computing University of Texas
- Practical course in applying modern statistical techniques to real
data, particularly bioinformatic data and large data sets. The emphasis
is on efficient computation and concise coding, mostly in MATLAB and
C++.
Topics covered include probability theory and Bayesian inference;
univariate distributions; Central Limit Theorem; generation of random
deviates; tail (p-value) tests; multiple hypothesis correction;
empirical distributions; model fitting; error estimation; contingency
tables; multivariate normal distributions; phylogenetic clustering;
Gaussian mixture models; EM methods; maximum likelihood estimation;
Markov Chain Monte Carlo; principal component analysis; dynamic
programming; hidden Markov models; performance measures for classifiers;
support vector machines; Wiener filtering; wavelets; multidimensional
interpolation; information theory.
- Lectures and Assignments
- CS 4780 Machine Learning Cornell University
- This course will introduce you to technologies for building
data-centric information systems on the World Wide Web, show the
practical applications of such systems, and discuss their design and
their social and policy context by examining cross-cutting issues such
as citizen science, data journalism and open government. Course work
involves lectures and readings as well as weekly homework assignments,
and a semester-long project in which the students demonstrate their
expertise in building data-centric Web information systems.
- Syllabus
- Lectures
- CS 4786 Machine Learning for Data Science Cornell University
- An introductory course in machine learning, with a focus on data
modeling and related methods and learning algorithms for data sciences.
Tentative topic list:
- Dimensionality reduction, such as principal component analysis (PCA)
and the singular value decomposition (SVD), canonical correlation
analysis (CCA), independent component analysis (ICA), compressed
sensing, random projection, the information bottleneck. (We expect to
cover some, but probably not all, of these topics).
- Clustering, such as k-means, Gaussian mixture models, the
expectation-maximization (EM) algorithm, link-based clustering. (We do
not expect to cover hierarchical or spectral clustering.).
- Probabilistic-modeling topics such as graphical models,
latent-variable models, inference (e.g., belief propagation), parameter
learning.
- Regression will be covered if time permits.
- Assignments
- Lectures
- CVX 101 Convex Optimization Stanford University
- The course concentrates on recognizing and solving convex
optimization problems that arise in applications. Topics addressed
include the following. Convex sets, functions, and optimization
problems. Basics of convex analysis. Least-squares, linear and
quadratic programs, semidefinite programming, minimax, extremal volume,
and other problems. Optimality conditions, duality theory, theorems of
alternative, and applications. Interior-point methods. Applications to
signal processing, statistics and machine learning, control and
mechanical engineering, digital and analog circuit design, and finance.
- DS-GA 1008 Deep Learning New York University
- This increasingly popular course is taught through the Data Science Center at NYU. Originally introduced by Yann Lecun, it is now led by Zaid Harchaoui,
although Prof. Lecun is rumored to still stop by from time to time. It
covers the theory, technique, and tricks that are used to achieve very
high accuracy for machine learning tasks in computer vision and natural
language processing. The assignments are in Lua and hosted on Kaggle.
- Course Page
- Recorded Lectures
- EECS E6893 & EECS E6895 Big Data Analytics & Advanced Big Data Analytics Columbia University
- Students will gain knowledge on analyzing Big Data. It serves as an
introductory course for graduate students who are expecting to face Big
Data storage, processing, analysis, visualization, and application
issues on both workplaces and research environments.
- Taught by Dr. Ching-Yung Lin
- Course Site
- Assignments - Assignments are present in the Course Slides
- EECS E6894 Deep Learning for Computer Vision and Natural Language Processing Columbia University
- This graduate level research class focuses on deep learning
techniques for vision and natural language processing problems. It gives
an overview of the various deep learning models and techniques, and
surveys recent advances in the related fields. This course uses Theano
as the main programming tool. GPU programming experiences are preferred
although not required. Frequent paper presentations and a heavy
programming workload are expected.
- Readings
- Assignments
- Lecture Notes
- EE103 Introduction to Matrix Methods Stanford University
- The course covers the basics of matrices and vectors, solving linear
equations, least-squares methods, and many applications. It'll cover
the mathematics, but the focus will be on using matrix methods in
applications such as tomography, image processing, data fitting, time
series prediction, finance, and many others. EE103 is based on a book
that Stephen Boyd and Lieven Vandenberghe are currently writing. Students will use a new language called Julia to do computations with matrices and vectors.
- Lectures
- Book
- Assignments
- Code
- Info 290 Analyzing Big Data with Twitter UC Berkeley school of information
- In this course, UC Berkeley professors and Twitter engineers provide
lectures on the most cutting-edge algorithms and software tools for
data analytics as applied to Twitter's data. Topics include applied
natural language processing algorithms such as sentiment analysis, large
scale anomaly detection, real-time search, information diffusion and
outbreak detection, trend detection in social streams, recommendation
algorithms, and advanced frameworks for distributed computing.
- Lecture Videos
- Previous Years coursepage
- Machine Learning: 2014-2015 University of Oxford
- The course focusses on neural networks and uses the Torch
deep learning library (implemented in Lua) for exercises and
assignments. Topics include: logistic regression, back-propagation,
convolutional neural networks, max-margin learning, siamese networks,
recurrent neural networks, LSTMs, hand-writing with recurrent neural
networks, variational autoencoders and image generation and
reinforcement learning
- Lectures and Assignments
- Source code
- StatLearning Intro to Statistical Learning Stanford University
- This is an introductory-level course in supervised learning, with a
focus on regression and classification methods. The syllabus includes:
linear and polynomial regression, logistic regression and linear
discriminant analysis; cross-validation and the bootstrap, model
selection and regularization methods (ridge and lasso); nonlinear
models, splines and generalized additive models; tree-based methods,
random forests and boosting; support-vector machines.
- The lectures cover all the material in An Introduction to Statistical Learning, with Applications in R which is a more approachable version of the Elements of Statistical Learning (or ESL) book.
- 10-601 Machine Learning Carnegie Mellon University
- This course covers the theory and practical algorithms for machine
learning from a variety of perspectives. It covers topics such as
Bayesian networks, decision tree learning, Support Vector Machines,
statistical learning methods, unsupervised learning and reinforcement
learning. The course covers theoretical concepts such as inductive bias,
the PAC learning framework, Bayesian learning methods, margin-based
learning, and Occam's Razor. Short programming assignments include
hands-on experiments with various learning algorithms. This course is
designed to give a graduate-level student a thorough grounding in the
methodologies, technologies, mathematics and algorithms currently needed
by people who do research in machine learning.
- Taught by one of the leading experts on Machine Learning - Tom Mitchell
- Lectures
- Project Ideas and Datasets
- 10-708 Probabilistic Graphical Models Carnegie Mellon University
- Many of the problems in artificial intelligence, statistics,
computer systems, computer vision, natural language processing, and
computational biology, among many other fields, can be viewed as the
search for a coherent global conclusion from local information. The
probabilistic graphical models framework provides a unified view for
this wide range of problems, enabling efficient inference,
decision-making and learning in problems with a very large number of
attributes and huge datasets. This graduate-level course will provide
you with a strong foundation for both applying graphical models to
complex problems and for addressing core research topics in graphical
models.
- Lecture Videos
- Assignments
- Lecture notes
- Readings
- 11-785 Deep Learning Carnegie Mellon University
- The course presents the subject through a series of seminars and
labs, which will explore it from its early beginnings, and work
themselves to some of the state of the art. The seminars will cover the
basics of deep learning and the underlying theory, as well as the
breadth of application areas to which it has been applied, as well as
the latest issues on learning from very large amounts of data. We will
concentrate largely, although not entirely, on the connectionist
architectures that are most commonly associated with it. Lectures and Reading Notes are available on the page.
Security
- CIS 4930 / CIS 5930 Offensive Computer Security Florida State University
- Course taught by W. Owen Redwood and Xiuwen Liu.
It covers a wide range of computer security topics, starting from
Secure C Coding and Reverse Engineering to Penetration Testing,
Exploitation and Web Application Hacking, both from the defensive and
the offensive point of view.
- Lectures and Videos
- Assignments
- CS 155 Computer and Network Security Stanford
- Principles of computer systems security. Attack techniques and how
to defend against them. Topics include: network attacks and defenses,
operating system holes, application security (web, email, databases),
viruses, social engineering attacks, privacy, and digital rights
management. Course projects focus on building reliable code.
Recommended: Basic Unix. Primarily intended for seniors and first-year
graduate students.
- CS 161 Computer Security UC Berkeley
- Introduction to computer security. Cryptography, including
encryption, authentication, hash functions, cryptographic protocols, and
applications. Operating system security, access control. Network
security, firewalls, viruses, and worms. Software security, defensive
programming, and language-based security. Case studies from real-world
systems.
- CS 259 Security Modeling and Analysis Stanford
- The course will cover a variety of contemporary network protocols
and other systems with security properties. The course goal is to give
students hands-on experience in using automated tools and related
techniques to analyze and evaluate security mechanisms. To understand
security properties and requirements, we will look at several network
protocols and their properties, including secrecy, authentication, key
establishment, and fairness. In parallel, the course will look at
several models and tools used in security analysis and examine their
advantages and limitations. In addition to fully automated finite-state
model checking techniques, we will also study other approaches, such as
constraint solving, process algebras, protocol logics, probabilistic
model checking, game theory, and executable models based on logic
programming.
- CS 261 Internet/Network Security UC Berkeley
- This class aims to provide a thorough grounding in network security
suitable for those interested in conducting research in the area, as
well as students more generally interested in either security or
networking. We will also look at broader issues relating to Internet
security for which networking plays a role. Topics include:
denial-of-service; capabilities; network intrusion detection; worms;
forensics; scanning; traffic analysis / inferring activity;
architecture; protocol issues; legality and ethics; web attacks;
anonymity; honeypots; botnets; spam; the underground economy; research
pitfalls. The course is taught with an emphasis on seminal papers rather
than bleeding-edge for a given topic.
- CS 5430 System Security Cornell University
- This course discusses security for computers and networked
information systems. We focus on abstractions, principles, and defenses
for implementing military as well as commercial-grade secure systems.
- Syllabus
- Lectures
- Assignments
- CSCI 4968 Modern Binary Exploitation Rensselaer Polytechnic Institute
- This repository contains the materials as developed and used by RPISEC to
teach Modern Binary Exploitation at Rensselaer Polytechnic Institute in
Spring 2015. This was a university course developed and run solely by students to teach
skills in vulnerability research, reverse engineering, and binary exploitation.
- Lectures Notes
- Labs
- Projects
- CSCI 4976 Malware Analysis Rensselaer Polytechnic Institute
- This repository contains the materials as developed and used by RPISEC to
teach Malware Analysis at Rensselaer Polytechnic Institute in
Fall 2015. This was a university course developed and run soley by students, primarily using the
- EECS 588 Computer & Network Security University of Michigan
- 6.857 Computer and Network Security MIT
- Emphasis on applied cryptography and may include: basic notion of
systems security, cryptographic hash functions, symmetric cryptography
(one-time pad, stream ciphers, block ciphers), cryptanalysis,
secret-sharing, authentication codes, public-key cryptography
(encryption, digital signatures), public-key attacks, web browser
security, biometrics, electronic cash, viruses, electronic voting,
Assignments include a group final project. Topics may vary year to year.
Lecture Notes
References
- 6.858 Computer Systems Security MIT
- Design and implementation of secure computer systems. Lectures cover
threat models, attacks that compromise security, and techniques for
achieving security, based on recent research papers. Topics include
operating system (OS) security, capabilities, information flow control,
language security, network protocols, hardware security, and security in
web applications.
- Taught by James Mickens and Nickolai Zeldovich
- Video Lectures and Labs
- Quizzes
- Readings
- Final Projects
- 18-636 Browser Security Stanford
- The Web continues to grow in popularity as platform for retail
transactions, financial services, and rapidly evolving forms of
communication. It is becoming an increasingly attractive target for
attackers who wish to compromise users' systems or steal data from other
sites. Browser vendors must stay ahead of these attacks by providing
features that support secure web applications. This course will study
vulnerabilities in existing web browsers and the applications they
render, as well as new technologies that enable web applications that
were never before possible. The material will be largely based on
current research problems, and students will be expected to criticize
and improve existing defenses. Topics of study include (but are not
limited to) browser encryption, JavaScript security, plug-in security,
sandboxing, web mashups, and authentication.
Artificial Intelligence
- CS 188 Introduction to Artificial Intelligence UC Berkeley
- This course will introduce the basic ideas and techniques underlying
the design of intelligent computer systems. A specific emphasis will be
on the statistical and decision-theoretic modeling paradigm. By the end
of this course, you will have built autonomous agents that efficiently
make decisions in fully informed, partially observable and adversarial
settings. Your agents will draw inferences in uncertain environments and
optimize actions for arbitrary reward structures. Your machine learning
algorithms will classify handwritten digits and photographs. The
techniques you learn in this course apply to a wide variety of
artificial intelligence problems and will serve as the foundation for
further study in any application area you choose to pursue.
- Lectures
- Projects
- Exams
- CS 4700 Foundations of Artificial Intelligence Cornell University
- This course will provide an introduction to computer vision, with
topics including image formation, feature detection, motion estimation,
image mosaics, 3D shape reconstruction, and object and face detection
and recognition. Applications of these techniques include building 3D
maps, creating virtual characters, organizing photo and video databases,
human computer interaction, video surveillance, automatic vehicle
navigation, and mobile computer vision. This is a project-based course,
in which you will implement several computer vision algorithms
throughout the semester.
- Assignments
- Lectures
- CS 6700 Advanced Artificial Intelligence Cornell University
- The design of systems that are among top 10 performers in the world (human, computer, or hybrid human-computer).
- Syllabus
- Lectures
- Readings
- 6.868J The Society of Mind MIT
- This course is an introduction, by Prof. Marvin Minsky,
to the theory that tries to explain how minds are made from collections
of simpler processes. It treats such aspects of thinking as vision,
language, learning, reasoning, memory, consciousness, ideals, emotions,
and personality. It incorporates ideas from psychology, artificial
intelligence, and computer science to resolve theoretical issues such as
wholes vs. parts, structural vs. functional descriptions, declarative
vs. procedural representations, symbolic vs. connectionist models, and
logical vs. common-sense theories of learning.
- Lectures
- Assignments
- Readings
Computer Graphics
- CAP 5415 Computer Vision University of Central Florida
- An introductory level course covering the basic topics of computer
vision, and introducing some fundamental approaches for computer vision
research.
- Lectures and Videos
- Assignments
- CIS 581 Computer Vision and Computational Photography University of Pennsylvania
- An introductory course in computer vision and computational
photography focusing on four topics: image features, image morphing,
shape matching, and image search.
- Lectures
- Assignments
- CMU 462 Computer Graphics Carnegie Mellon University
- This course provides a comprehensive introduction to computer
graphics. Focuses on fundamental concepts and techniques, and their
cross-cutting relationship to multiple problem domains in graphics
(rendering, animation, geometry, imaging). Topics include: sampling,
aliasing, interpolation, rasterization, geometric transformations,
parameterization, visibility, compositing, filtering, convolution,
curves & surfaces, geometric data structures, subdivision, meshing,
spatial hierarchies, ray tracing, radiometry, reflectance, light fields,
geometric optics, Monte Carlo rendering, importance sampling, camera
models, high-performance ray tracing, differential equations, time
integration, numerical differentiation, physically-based animation,
optimization, numerical linear algebra, inverse kinematics, Fourier
methods, data fitting, example-based synthesis.
- Lectures and Readings
- Assignments and Quizes
- CS 378 3D Reconstruction with Computer Vision UTexas
- In this lab-based class, we'll dive into practical applications of
3D reconstruction, combining hardware and software to build our own 3D
environments from scratch. We'll use open-source frameworks like OpenCV
to do the heavy lifting, with the focus on understanding and applying
state-of-the art approaches to geometric computer vision
- Lectures
- CS 4620 Introduction to Computer Graphics Cornell University
- The study of creating, manipulating, and using visual images in the computer.
- Assignments
- Exams
- CS 4670 Introduction to Computer Vision Cornell University
- This course will provide an introduction to computer vision, with
topics including image formation, feature detection, motion estimation,
image mosaics, 3D shape reconstruction, and object and face detection
and recognition. Applications of these techniques include building 3D
maps, creating virtual characters, organizing photo and video databases,
human computer interaction, video surveillance, automatic vehicle
navigation, and mobile computer vision. This is a project-based course,
in which you will implement several computer vision algorithms
throughout the semester.
- Assignments
- Lectures
- CS 6670 Computer Vision Cornell University
- Introduction to computer vision. Topics include edge detection,
image segmentation, stereopsis, motion and optical flow, image mosaics,
3D shape reconstruction, and object recognition. Students are required
to implement several of the algorithms covered in the course and
complete a final project.
- Syllabus
- Lectures
- Assignments
- CSCI-GA.2270-001 Graduate Computer Graphics New York University
- Step-by-step study computer graphics, with reading and homework at each lecture (Fall2015)
- Lectures
Misc
- AM 207 Monte Carlo Methods and Stochastic Optimization Harvard University
- This course introduces important principles of Monte Carlo
techniques and demonstrates the power of these techniques with simple
(but very useful) applications. All of this in Python!
- Lecture Videos
- Assignments
- Lecture Notes
- CS 75 Introduction to Game Development Tufts University
- The course taught by Ming Y. Chow
teaches game development initially in PyGame through Python, before
moving on to addressing all facets of game development. Topics addressed
include game physics, sprites, animation, game development methodology,
sound, testing, MMORPGs and online games, and addressing mobile
development in Android, HTML5, and iOS. Most to all of the development
is focused on PyGame for learning principles
- Text Lectures
- Assignments
- Labs
- CS 100 Open Source Software Construction UC Riverside
- This is a course on how to be a hacker. Your first four homework
assignments walk you through the process of building your own unix
shell. You'll be developing it as an open source project, and you will
collaborate with each other at various points.
- Github Page
- Assignments
- CS 108 Object Oriented System Design Stanford
- Software design and construction in the context of large OOP
libraries. Taught in Java. Topics: OOP design, design patterns, testing,
graphical user interface (GUI) OOP libraries, software engineering
strategies, approaches to programming in teams.
- CS 168 Computer Networks UC Berkeley
- This is an undergraduate level course covering the fundamental
concepts of networking as embodied in the Internet. The course will
cover a wide range of topics; see the lecture schedule for more details.
While the class has a textbook, we will not follow its order of
presentation but will instead use the text as a reference when covering
each individual topic. The course will also have several projects that
involve programming (in Python).
- You should know programming, data structures, and software
engineering. In terms of mathematics, your algebra should be very solid,
you need to know basic probability, and you should be comfortable with
thinking abstractly. The TAs will spend very little time reviewing
material that is not specific to networking. We assume that you either
know the material covered in those courses, or are willing to learn the
material as necessary. We won't cover any of this material in lecture.
- CS 193a Android App Development, Spring 2016 Stanford University
- Course Description: This course provides an introduction to developing applications for the Android mobile platform.
- Prerequisite: CS 106B or equivalent. Java experience highly recommended. OOP highly recommmended.
- Devices: Access to an Android phone and/or tablet recommended but not required.
- Videos: Videos list can be found here
- Other materials: Some codes, handsout, homework ..... and lecture
notes are not downloadable on the site due to login requirement. Please
head to my Github repo here to download them.
- CS 193p Developing Applications for iOS Stanford University
- Updated for iOS 7. Tools and APIs required to build applications for
the iPhone and iPad platform using the iOS SDK. User interface designs
for mobile devices and unique user interactions using multi-touch
technologies. Object-oriented design using model-view-controller
paradigm, memory management, Objective-C programming language. Other
topics include: object-oriented database API, animation, multi-threading
and performance considerations.
- Prerequisites: C language and object-oriented programming experience
- Recommended: Programming Abstractions
- Updated courses for iOS8 - Swift
- Updated courses for iOS9 - Swift
- CS 223A Introduction to Robotics Stanford University
- The purpose of this course is to introduce you to basics of
modeling, design, planning, and control of robot systems. In essence,
the material treated in this course is a brief survey of relevant
results from geometry, kinematics, statics, dynamics, and control.
- Lectures
- Assignments
- CS 262a Advanced Topics in Computer Systems UC Berkeley
- CS262a is the first semester of a year-long sequence on computer
systems research, including operating systems, database systems, and
Internet infrastructure systems. The goal of the course is to cover a
broad array of research topics in computer systems, and to engage you in
top-flight systems research. The first semester is devoted to basic
thematic issues and underlying techniques in computer systems, while the
second semester goes deeper into topics related to scalable, parallel
and distributed systems. The class is based on a discussion of
important research papers and a research project.
- Parts: Some Classics, Persistent Storage,
Concurrency, Higher-Level Models, Virtual Machines, Cloud Computing,
Parallel and Distributed Computing, Potpourri.
- Prerequisites: The historical prerequisite was to pass an entrance
exam in class, which covered undergraduate operating systems material
(similar to UCB's CS162).
There is no longer an exam. However, if you have not already taken a
decent undergrad OS class, you should talk with me before taking this
class. The exam had the benefit of "paging in" the undergrad material,
which may have been its primary value (since the pass rate was high).
- Readings & Lectures
- CS 294 Cutting-edge Web Technologies Berkeley
- Want to learn what makes future web technologies tick? Join us for
the class where we will dive into the internals of many of the newest
web technologies, analyze and dissect them. We will conduct survey
lectures to provide the background and overview of the area as well as
invite guest lecturers from various leading projects to present their
technologies.
- CS 411 Software Architecture Design Bilkent University
- This course teaches the basic concepts, methods and techniques for
designing software architectures. The topics include: rationale for
software architecture design, modeling software architecture design,
architectural styles/patterns, architectural requirements analysis,
comparison and evaluation of architecture design methods,
synthesis-based software architecture design, software product-line
architectures, domain modeling, domain engineering and application
engineering, software architecture implementation, evaluating software
architecture designs.
- CS 3152 Introduction to Computer Game Development Cornell University
- A project-based course in which programmers and designers
collaborate to make a computer game. This course investigates the theory
and practice of developing computer games from a blend of technical,
aesthetic, and cultural perspectives. Technical aspects of game
architecture include software engineering, artificial intelligence, game
physics, computer graphics, and networking. Aesthetic and cultural
include art and modeling, sound and music, game balance, and player
experience.
- Syllabus
- Lectures
- Assignments
- CS 4152 Advanced Topics in Computer Game Development Cornell University
- Project-based follow-up course to CS/INFO 3152. Students work in a
multidisciplinary team to develop a game that incorporates innovative
game technology. Advanced topics include 3D game development, mobile
platforms, multiplayer gaming, and nontraditional input devices. There
is a special emphasis on developing games that can be submitted to
festivals and competitions, or that can be commercialized.
- Syllabus
- Lectures
- Assignments
- CS 4154 Analytics-driven Game Design Cornell University
- A project-based course in which programmers and designers
collaborate to design, implement, and release a video game online
through popular game portals. In this course, students will use the
internet to gather data anonymously from players. Students will analyze
this data in order to improve their game over multiple iterations.
Technical aspects of this course include programming, database
architecture, and statistical analysis.
- Syllabus
- Lectures
- Assignments
- CS 4812 Quantum Information Processing Cornell University
- Hardware that exploits quantum phenomena can dramatically alter the
nature of computation. Though constructing a working quantum computer is
a formidable technological challenge, there has been much recent
experimental progress. In addition, the theory of quantum computation is
of interest in itself, offering strikingly different perspectives on
the nature of computation and information, as well as providing novel
insights into the conceptual puzzles posed by the quantum theory. The
course is intended both for physicists, unfamiliar with computational
complexity theory or cryptography, and also for computer scientists and
mathematicians, unfamiliar with quantum mechanics. The prerequisites are
familiarity (and comfort) with finite dimensional vector spaces over
the complex numbers, some standard group theory, and ability to count in
binary.
- Syllabus
- Lectures
- CS 4860 Applied Logic Cornell University
- In addition to basic first-order logic, when taught by Computer
Science this course involves elements of Formal Methods and Automated
Reasoning. Formal Methods is concerned with proving properties of
algorithms, specifying programming tasks and synthesizing programs from
proofs. We will use formal methods tools such as interactive proof
assistants (see www.nuprl.org). We will also spend two weeks on constructive type theory, the language used by the Coq and Nuprl proof assistants.
- Syllabus
- Lectures
- Assignments
- CS 5150 Software Engineering Cornell University
- Introduction to the practical problems of specifying, designing, building, testing, and delivering reliable software systems
- Lectures
- Assignments
- CS 5220 Applications of Parallel Computers Cornell University
- How do we solve the large-scale problems of science quickly on
modern computers? How do we measure the performance of new or existing
simulation codes, and what things can we do to make them run faster? How
can we best take advantage of features like multicore processors,
vector units, and graphics co-processors? These are the types of
questions we will address in CS 5220, Applications of Parallel
Computers. Topics include:
- Single-processor architecture, caches, and serial performance tuning
- Basics of parallel machine organization
- Distributed memory programming with MPI
- Shared memory programming with OpenMP
- Parallel patterns: data partitioning, synchronization, and load balancing
- Examples of parallel numerical algorithms
- Applications from science and engineering
- Lectures
- Assignments
- CS 5540 Computational Techniques for Analyzing Clinical Data Cornell University
- CS5540 is a masters-level course that covers a wide range of
clinical problems and their associated computational challenges. The
practice of medicine is filled with digitally accessible information
about patients, ranging from EKG readings to MRI images to electronic
health records. This poses a huge opportunity for computer tools that
make sense out of this data. Computation tools can be used to answer
seemingly straightforward questions about a single patient's test
results (“Does this patient have a normal heart rhythm?”), or to
address vital questions about large populations (“Is there any
clinical condition that affects the risks of Alzheimer”). In CS5540 we
will look at many of the most important sources of clinical data and
discuss the basic computational techniques used for their analysis,
ranging in sophistication from current clinical practice to
state-of-the-art research projects.
- Syllabus
- Lectures
- Assignments
- CS 5724 Evolutionary Computation Cornell University
- This course will cover advanced topics in evolutionary algorithms
and their application to open-ended computational design. The field of
evolutionary computation tries to address large-scale optimization and
planning problems through stochastic population-based methods. It draws
inspiration from evolutionary processes in nature and in engineering,
and also serves as abstract models for these phenomena. Evolutionary
processes are generally weak methods that require little information
about the problem domain and hence can be applied across a wide variety
of applications. They are especially useful for open-ended problem
domains for which little formal knowledge exists and the number of
parameters is undefined, such as for the general engineering design
process. This course will provide insight to a variety of evolutionary
computation paradigms, such as genetic algorithms, genetic programming,
and evolutionary strategies, as well as governing dynamics of
co-evolution, arms races and mediocre stable states. New methods
involving symbiosis models and pattern recognition will also be
presented. The material will be intertwined with discussions of
representations and results for design problems in a variety of problem
domains including software, electronics, and mechanics.
- Syllabus
- Lectures
- Assignments
- CS 6452 Evolutionary Computation Cornell University
- CS6452 focuses on datacenter networks and services. The emerging
demand for web services and cloud computing have created need for large
scale data centers. The hardware and software infrastructure for
datacenters critically determines the functionality, performance, cost
and failure tolerance of applications running on that datacenter. This
course will examine design alternatives for both the hardware
(networking) infrastructure, and the software infrastructure for
datacenters.
- Syllabus
- Lectures
- CS 6630 Realistic Image Synthesis Cornell University
- CS6630 is an introduction to physics-based rendering at the graduate
level. Starting from the fundamentals of light transport we will look
at formulations of the Rendering Equation, and a series of Monte Carlo
methods, from sequential sampling to multiple importance sampling to
Markov Chains, for solving the equation to make pictures. We'll look at
light reflection from surfaces and scattering in volumes, illumination
from luminaries and environments, and diffusion models for translucent
materials. We will build working implementations of many of the
algorithms we study, and learn how to make sure they are actually
working correctly. It's fun to watch integrals and probability
distributions transform into photographs of a slightly too perfect
synthetic world.
- Syllabus
- Lectures
- Assignments
- Readings
- CS 6640 Computational Photography Cornell University
- A course on the emerging applications of computation in photography.
Likely topics include digital photography, unconventional cameras and
optics, light field cameras, image processing for photography,
techniques for combining multiple images, advanced image editing
algorithms, and projector-camera
systems.cornell.edu/courses/CS6630/2012sp/about.stm)
- Lectures
- Assignments
- CS 6650 Computational Motion Cornell University
- Covers computational aspects of motion, broadly construed. Topics
include the computer representation, modeling, analysis, and simulation
of motion, and its relationship to various areas, including
computational geometry, mesh generation, physical simulation, computer
animation, robotics, biology, computer vision, acoustics, and
spatio-temporal databases. Students implement several of the algorithms
covered in the course and complete a final project. This offering will
also explore the special role of motion processing in physically based
sound rendering.
- CS 6840 Algorithmic Game Theory Cornell University
- Algorithmic Game Theory combines algorithmic thinking with
game-theoretic, or, more generally, economic concepts. The course will
study a range of topics at this interface
- Syllabus
- Lectures
- Assignments
- Readings
- CSE 154 Web Programming University of Washington
- This course is an introduction to programming for the World Wide Web. Covers use of HTML, CSS, PHP, JavaScript, AJAX, and SQL.
- Lectures
- Assignments
- ESM 296-4F GIS & Spatial Analysis UC Santa Barbara
- Taught by James Frew, Ben Best, and Lisa Wedding
- Focuses on specific computational languages (e.g., Python, R, shell)
and tools (e.g., GDAL/OGR, InVEST, MGET, ModelBuilder) applied to the
spatial analysis of environmental problems
- GitHub (includes lecture materials and labs)
- ICS 314 Software Engineering University of Hawaii
- IGME 582 Humanitarian Free & Open Source Software Development Rochester Institute of Technology
- This course provides students with exposure to the design, creation
and production of Open Source Software projects. Students will be
introduced to the historic intersections of technology and intellectual
property rights and will become familiar with Open Source development
processes, tools and practices.
- I485 / H400 Biologically Inspired Computation Indiana University
- Course taught by Luis Rocha
about the multi-disciplinary field algorithms inspired by naturally
occurring phenomenon. This course provides introduces the following
areas: L-systems, Cellular Automata, Emergence, Genetic Algorithms,
Swarm Intelligence and Artificial Immune Systems. It's aim is to cover
the fundamentals and enable readers to build up a proficiency in
applying various algorithms to real-world problems.
- Lectures
- Assignments
- Open Sourced Elective: Database and Rails Intro to Ruby on Rails University of Texas
- An introductory course in Ruby on Rails open sourced by University of Texas' CS Adjunct Professor, Richard Schneeman.
- Lectures
- Assignments
- Videos
- SCICOMP An Introduction to Efficient Scientific Computation Universität Bremen
- This is a graduate course in scientific computing created and taught by Oliver Serang
in 2014, which covers topics in computer science and statistics with
applications from biology. The course is designed top-down, starting
with a problem and then deriving a variety of solutions from scratch.
- Topics include memoization, recurrence closed forms, string matching
(sorting, hash tables, radix tries, and suffix tries), dynamic
programming (e.g. Smith-Waterman and Needleman-Wunsch), Bayesian
statistics (e.g. the envelope paradox), graphical models (HMMs, Viterbi,
junction tree, belief propagation), FFT, and the probabilistic
convolution tree.
- Lecture videos on Youtube and for direct download
- 14-740 Fundamentals of Computer Networks CMU
- This is an introductory course on Networking for graduate students.
It follows a top-down approach to teaching Computer Networks, so it
starts with the Application layer which most of the students are
familiar with and as the course unravels we learn more about transport,
network and link layers of the protocol stack.
- As far as prerequisites are concerned - basic computer, programming and probability theory background is required.
- The course site contains links to the lecture videos, reading material and assignments.
