Awesome CS Courses 
Introduction
There are a lot of hidden treasures lying within university pages scattered across the internet. This list is an attempt to bring to light those awesome CS courses which make their high-quality materials, i.e. assignments, lectures, notes, readings and 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
- The subjects covered in this course include: C and assembly language programming, translation of high-level programs into machine language, computer organization, caches, performance measurement, parallelism, CPU design, warehouse-scale computing, and related topics.
- Lecture Videos
- Lecture Notes
- Resources
- Old Exams
- 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
- 6.004 Computation Structures MIT
- Introduces architecture of digital systems, emphasizing structural principles common to a wide range of technologies. Multilevel implementation strategies; definition of new primitives (e.g., gates, instructions, procedures, processes) and their mechanization using lower-level elements. Analysis of potential concurrency; precedence constraints and performance measures; pipelined and multidimensional systems. Instruction set design issues; architectural support for contemporary software structures. 4 Engineering Design Points. 6.004 offers an introduction to the engineering of digital systems. Starting with MOS transistors, the course develops of series of building blocks logic gates, combinational and sequential circuits, finite-state machines, computers and finally complete systems. Both hardware and software mechanisms are explored through a series of design examples.
- Youtube Playlist
- Lecture Notes
- Labs-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 Videos
- Lecture Notes
- Projects
- CS 241 Systems Programming (Spring 2016) 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
- Labs
- 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 2016 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 scheduling, file system, ect. It also includes some recommended 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
- ECGR4101/5101 Embedded Systems using the Renesas RX63N Processor University of North Carolina at Charlotte
- Introduction to designing microcontroller-based embedded computer systems using assembly and C programs. Examination of Real-time Operating Systems and their impact on performance. Computer engineering applications will be emphasized.
- The goal of this course is to solidify and build upon a student’s knowledge of computer organization by presenting hands-on experience with microcontrollers. Students will also examine a few sensors that are used in commercial and medical products and learn how to interface them in a microcontroller system.
- Lecture Videos
- Lecture Notes
- 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
- 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.
- CSEP 552 Distributed Systems University of Washington
- CSEP552 is a graduate course on distributed systems. Distributed systems have become central to many aspects of how computers are used, from web applications to e-commerce to content distribution. This course will cover abstractions and implementation techniques for the construction of distributed systems, including client server computing, the web, cloud computing, peer-to-peer systems, and distributed storage systems. Topics will include remote procedure call, maintaining consistency of distributed state, fault tolerance, high availability, and other topics. As we believe the best way to learn the material is to build it, there will be a series of hands-on programming projects.
- Lectures of a previous session are available to watch.
- 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-319/619 Cloud Computing (ICS) Carnegie-Mellon University
- This project-based on-line course focuses on skill building across various aspects of cloud computing. We cover conceptual topics and provide hands-on experience through projects utilizing public cloud infrastructures (Amazon Web Services (AWS), Microsoft Azure and Google Cloud Platform (GCP)). The adoption of cloud computing services continues to grow across a variety of organizations and in many domains. Simply, cloud computing is the delivery of computing as a service over a network, whereby distributed resources and services are rented, rather than owned, by an end user as a utility.
- For the projects, students will work with Amazon Web Services, Microsoft Azure and Google Cloud Platform, use them to rent and provision compute resources and then program and deploy applications that run on these resources. Students will develop and evaluate virtual machine (VM) and container scaling, elasticity and load balancing solutions. In addition, students will work with cloud storage systems and learn to develop different applications using batch, iterative and stream processing frameworks. 15-619 students will have to complete an extra project which entails designing and implementing a complete web-service solution for querying big data. For the extra project, the student teams are evaluated based on the cost and performance of their web service.
- Lecture Notes
- Videos
- 15-410 Operating System Design and Implementation Carnegie-Mellon University
- This awesome course covers some fundamental topics of operating system, such as process model, virtual memory concurrency, threads, locking, interrupts, preemptibility, race conditions. It also covers introductory understanding of typical OS topics (file systems, transactions, scheduling, security concepts and technologies, memory consistency)Parallel programming models / frameworks.
- Lecture Notes
- Assignments
- 15-418 Parallel 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-445/645 Database Systems Carnegie-Mellon University
- 15-749 Engineering Distributed Systems Carnegie-Mellon University
- A project focused course on Distributed Systems with an awesome list of readings
- 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'15 version by Prof. Onur Mutlu
- Lectures and Recitation
- Homeworks 7 HWs with answer set as well
- Readings
Programming Languages / Compilers
- CS 75 Principles of Compiler Design Swathmore College
- CS 91 Introduction to Programming Languages Swathmore College
- Uses the Pyret programming language & PAPL book to understand the fundamentals of programming languages.
- Labs
- 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
- 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
- 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
- Corsopl Principles of Programming Languages Politecnico di Milano - Lecture Notes - Readings
- This course gives an overview of Scheme, Haskell and Erlang while analyzing the languages' similarities and differences. As a result, many important/prevalent concepts and how they manifest differently in different programming languages are explained. Among these are (purely) functional programming, object orientation, type inference and evaluation order.
- Thorough introduction to functional programming with no preknowledge in any functional language required.
- 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
- 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
- This course provides an introduction to the languages used to program computer networks. It will examine recent proposals based on logic, functional, and distributed languages, as well as tools for establishing correctness using automatic solvers, model checkers, and proof assistants.
- 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 conventional 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
- 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
- CS 696 Functional Design and Programming San Diego State University
- Covers functional programming basis using Clojure.
- Topics include testing, functional programming, immutable collections and concurrency.
- Also includes assignments covering Clojurescript, [Reagent](Reagent Github) etc.
- L28 Advanced Functional Programming University of Cambridge
- This module aims to teach students how to use the features of modern typed functional programming languages (e.g. OCaml, Haskell) to design and implement libraries and DSLs. It aims to demonstrate how such techniques can improve both correctness and efficiency. Students wishing to take the module should have some experience of a typed functional programming language and an understanding of type inference.
- This particular session was taught by a prominent OCaml programmer, open Source contributor & author of real world OCaml - Dr Anil Madhavapeddy.
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 useful 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
- 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
- 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.
- Lecture Videos
- Assignments
- 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
- Lecture Notes
- 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
- Assignments
- 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.
- The course's OpenCourseware resides here
- 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 Videos
- 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 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
- CSCI E-1 Understanding Computers and the Internet Harvard University Extension College
- This course is all about understanding: understanding what's going on inside your computer when you flip on the switch, why tech support has you constantly rebooting your computer, how everything you do on the Internet can be watched by others, and how your computer can become infected with a worm just by being turned on. Designed for students who use computers and the Internet every day but don't fully understand how it all works, this course fills in the gaps. Through lectures on hardware, software, the Internet, multimedia, security, privacy, website development, programming, and more, this course "takes the hood off" of computers and the Internet so that students understand how it all works and why. Through discussions of current events, students are exposed also to the latest technologies.
- Lecture Videos
- Syllabus
- Notes / Recaps
- Assignments
- 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
- 6.005 Software Construction, Fall 2016 MIT
- This course introduces fundamental principles and techniques of software development. Students learn how to write software that is safe from bugs, easy to understand, and ready for change. Topics include specifications and invariants; testing, test-case generation, and coverage; state machines; abstract data types and representation independence; design patterns for object-oriented programming; concurrent programming, including message passing and shared concurrency, and defending against races and deadlock; and functional programming with immutable data and higher-order functions.
- Lectures Notes/Assignments
Machine Learning
- DEEPNLP Deep Learning for Natural Language Processing University of Oxford
- This is an applied course focussing on recent advances in analysing and generating speech and text using recurrent neural networks. We introduce the mathematical definitions of the relevant machine learning models and derive their associated optimisation algorithms. The course covers a range of applications of neural networks in NLP including analysing latent dimensions in text, transcribing speech to text, translating between languages, and answering questions. This course is organised by Phil Blunsom and delivered in partnership with the DeepMind Natural Language Research Group.
- Lectures
- Assignments are available on the organisation page titled as "practicals"
- CS20si Tensorflow for Deep Learning Research Stanford University
- This course will cover the fundamentals and contemporary usage of the Tensorflow library for deep learning research. We aim to help students understand the graphical computational model of Tensorflow, explore the functions it has to offer, and learn how to build and structure models best suited for a deep learning project. Through the course, students will use Tensorflow to build models of different complexity, from simple linear/logistic regression to convolutional neural network and recurrent neural networks with LSTM to solve tasks such as word embeddings, translation, optical character recognition. Students will also learn best practices to structure a model and manage research experiments.
- Assignments available on Github.
- 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 189 Introduction To Machine Learning UC Berkeley
- Introductory ML course covering a wide range of topics: ranging from least squares to convolutional neural networks
- Notes
- Homework
- 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 journa
Это подборка бесплатных качественных курсов по информатике из университетов разных стран. Каждый курс выкладывает в открытый доступ лекции, задания, конспекты и материалы для чтения.