宾夕法尼亚州立大学【中英⚡数据库管理系统|CMPSC431 Fall 2015, Database Management Systems】

p0 Lec01 Introduction Course Overview

p1 Lec02 Basic Processor Components

p2 Lec03 Branching Instruction Support

p3 Lec04 Subroutines

p4 Lec05 x86 64 Instructions

p5 Lec06 x86 64 Implementation Of C Program

p6 Lec07 Vector Add Example

p7 Lec08 Allocation Strategies

p8 Lec09 Implicit Allocators Indirection And References

p9 Lec10 Object Oriented Programming Model

p10 Lec11 Exception Handling

p11 Lec12 Midterm Review

p12 Lec13 Physical Constraints On Memory

p13 Lec14 Caching Motivations General Approach

p14 Lec15 Caches II

p15 Lec16 MSI Cache Coherence Protocol

p16 Lec17 Virtualization

p17 Lec18 UNIX Operating System Calls Via x86 Traps

p18 Lec19 UNIX Signal Handlers And Reentrancy

p19 Lec20 Signal Handlers And Multiple Signals

p20 Lec21 Process Control Blocks

p21 Lec22 Process Scheduling Algorithms

p22 Lec23 Disk backed Virtual Memory

p23 Lec24 x86 64 Page Directory And Ttable Entries

p24 Lec26 Final Exam Review

p0 1. Prologue ｜ CMU Principles of Functional Programming M23

p1 2. Equivalence, Binding, and Scope ｜ CMU Principles of Functional Programming

p2 3. Induction and Recursion ｜ CMU Principles of Functional Programming M23

p3 4. Structural Induction and Tail Recursion ｜ CMU Principles of Functional Pro

p4 5. Trees ｜ CMU Principles of Functional Programming M23

p5 6. Asymptotic Analysis ｜ CMU Principles of Functional Programming M23

p6 7. Sorting and Parallelism ｜ CMU Principles of Functional Programming M23

p7 8. Polymorphism ｜ CMU Principles of Functional Programming M23

p8 9. Higher-Order Functions ｜ CMU Principles of Functional Programming M23

p9 10. Combinators and Staging ｜ CMU Principles of Functional Programming M23

p10 11. Continuation-Passing Style ｜ CMU Principles of Functional Programming M2

p11 12. Exceptions ｜ CMU Principles of Functional Programming M23

p12 13. Regular Expressions ｜ CMU Principles of Functional Programming M23

p13 14. Structures and Signatures ｜ CMU Principles of Functional Programming M23

p14 15. Functors ｜ CMU Principles of Functional Programming M23

p15 16. Red-Black Trees ｜ CMU Principles of Functional Programming M23

p16 17. Sequences ｜ CMU Principles of Functional Programming M23

p17 18. Lazy Programming ｜ CMU Principles of Functional Programming M23

p18 19. Imperative Programming ｜ CMU Principles of Functional Programming M23

p19 20. Compilers ｜ CMU Principles of Functional Programming M23

p20 21. Program Analysis ｜ CMU Principles of Functional Programming

p21 22. Finale ｜ CMU Principles of Functional Programming M23

Lecture 1： Introduction

Lecture 2： RPC and Threads

Lecture 3： GFS

Lecture 4： Primary-Backup Replication

Lecture 5： Go, Threads, and Raft

Lecture 6： Fault Tolerance： Raft (1)

Lecture 7： Fault Tolerance： Raft (2)

Lecture 8： Zookeeper

Lecture 9： More Replication, CRAQ

Lecture 10： Cloud Replicated DB, Aurora

Lecture 11： Cache Consistency： Frangipani

Lecture 12： Distributed Transactions

Lecture 13： Spanner

Lecture 14： Optimistic Concurrency Control

Lecture 15： Big Data： Spark

Lecture 16： Cache Consistency： Memcached at Facebook

Lecture 17： COPS, Causal Consistency

Lecture 18： Fork Consistency, Certificate Transparency

Lecture 19： Bitcoin

Lecture 20： Blockstack

p1 Lecture 1 Part 1 Intro and Why

p2 Lecture 1 Part 2 What

p3 Lecture 1 Part 3 Who

p4 Lecture 1 Part 4 How

p5 SQL 1 Clip 1

p6 SQL 1 Clip 2

p7 SQL 1 Clip 3

p8 SQL 1 Clip 4

p9 SQL 1 Clip 5

p10 SQL 1 Clip 6 7

p11 SQL II 1 4

p12 SQL II 6 10

p13 SQL II 11 12

p14 SQL II 13 15 slides

p15 SQL II 17 21

p16 SQL II 23 28

p17 SQL II 30 34

p18 SQL II 35

p19 SQL II 37 39

p20 SQL II 41 46

p21 SQL II 48 53

p22 SQL II 55 56

p23 SQL II 58 66

p24 SQL II 68 69

p25 Lec 4 Part 1 Architecture

p26 Lec 4 Part 2 Storage Hierarchy

p27 Lec 4 Part 3 Components of a Disk

p28 Lec 4 Part 4 Flash

p29 Lec 4 Part 5 Storage Pragmatics and Trends

p30 Lec 4 Part 6 Disk Space Management

p31 Lec 4 5 Part 1 Files

p32 Lec 4 5 Part 2 Pages for Fixed Length

p33 Lec 4 5 Part 3 Pages for Variable Length

p34 Lec 4 5 Part 4 Record Layout

p35 Lec 4 5 Part 5 Summary

p36 Lecture 5 Part 1 Review and Goals

p37 Lec 5 Part 2 Model and Assumptions

p38 Lec 5 Part 3 Scan

p39 Lec 5 Part 4 Equality

p40 Lec 5 Part 5 Range Search

p41 Lec 5 Part 6 Insert

p42 Lec 5 Part 7 Delete

p43 Lec 5 Part 8 Summary

p44 Lec 6 Part 1 Intro to Indexes

p45 Lec 6 Part 2 High Fan out Search Tree

p46 Lec 6 Part 3 Search and Insertion in ISAM

p47 Lecture 6 Part 4 B+ Tree Intro

p48 Lecture 6 Part 5

p49 Lecture 6 Part 6

p50 Lecture 6 Part 7

p51 Lecture 6 Part 8 B+ Tree Deletion

p52 Lecture 6 Part 9 (OLD)

p53 Lecture 6 Part 10

p54 Lec 7 Part 1 Lecture Introduction

p55 Lec 7 Part 2 Query Support Overview

p56 Lec 7 Part 3 Composite Search Keys in One Dimension

p57 Lec 7 Part 4 Three Alternatives for Data Entry Storage

p58 Lec 7 Part 5 Clustered vs Unclustered Indexes

p59 Lec 7 Part 6 Variable Length Keys： Occupancy and Compression

p60 Lec 7 Part 7 Clustered B+ Tree Cost Model

p61 Lec 7 Part 8 Lecture Summary

p62 Lec 8 Part 1 Intro to Buffer Management

p63 Lec 8 Part 2 Mapping Pages

p64 Lec 8 Part 3 Dirty Pages

p65 Lec 8 Part 4 Buf Mgr State

p66 Lec 8 Part 5 Page Replacement

p67 Lec 8 Part 6 LRU

p68 Lec 8 Part 7 Clock

p69 Lec 8 Part 8 LRU and Sequential Flooding

p70 Lec 8 Part 9 MRU and Repeated Scans

p71 Lec8 Part 10 Additional Topics

p72 Lec 8 Part 11 Summary

p73 Lec 9 Part 1 Intro

p74 Lec 9 Part 2 Unary Operators

p75 Lec 9 Part 3 Set Operators

p76 Lec 9 Part 4 Joins

p77 Lec 9 Part 5 GroupBy and Summary

p78 Lec 10 Part 1 Out of Core Algs

p79 Lec 10 Part 2 Double Buffering

p80 Lec 10 Part 3 Sort Hash Specs

p81 Lec 10 Part 4 Two Way Sorting

p82 Lecture 9 Part 5 External Sort (Old)

p83 Lec 9 Part 6 External Hashing (Old)

p84 Lec 9 Part 7 Recursive Partitioning for External Hash (Old)

p85 Lec 9 Part 8 Sort Hash Duality (Old)

p86 Lec 10 Part 9 parallel hashing

p87 Lec 10 Part 10 parallel sort

p88 Lec 10 Part 11 Sort v Hash

p89 Lec 10 Part 12 Summary

p90 Lecture 11 Part 1 Intro and Select

p91 Lecture 11 Part 2 HeapScan and Sort Iterators

p92 Lecture 11 Part 3 Group By Iterator

p93 Lecture 11 Part 4 Cost Model for Subsequent Analysis

p94 Lecture 11 Part 5 Nested Loops Join (Old)

p95 Lecture 11 Part 6 Index Nested Loops Join (Old)

p96 Lecture 11 Part 7 Sort Merge Join

p97 Lecture 11 Part 8 Sort Merge Cost and a Refinement (Old)

p98 Lec 11 Part 9

p99 Lecture 11 Part 10

p100 Lecture 11 Part 11 Hash Join Costs

p101 Lecture 11 Part 12 Conclusion

p102 Lecture 12 Part 1 Intro

p103 Lecture 12 Part 2 Big Picture

p104 Lecture 12 Part 3 Algebra Equivalences

p105 Lecture 12 Part 4 Heuristics

p106 Lecture 12 Part 5 Physical Equivalences

p107 Lecture 12 Part 6 Running Example

p108 Lecture 12 Part 7 Selection Pushdown

p109 Lecture 12 Par 8 Join Orders

p110 Lecture 12 Part 9 Join Algs

p111 Lecture 12 Part 10 Projection Pushdown

p112 Lecture 12 Part 11 Indexes

p113 Lecture 12 Part 12 Conclusion

p114 Lecture 13 Part 1 Introduction

p115 Lecture 13 Part 2 Background Query Blocks and Physical Propert

p116 Lecture 13 Part 3 Plan Space

p117 Lecture 13 Part 4 Selectivity Estimation

p118 Lecture 13 Part 5 Selectivity in More Depth

p119 Lecture 13 Part 6 Using Histograms for Selectivity Estimation

p120 Lecture 13 Part 7 Selectivity for Join Queries

p121 Lecture 13 Part 8 Summary of Cost Estimation

p122 Lecture 13 Part 9 Single Table Plans

p123 Lecture 13 Part 10 Dynamic Programming

p124 Lecture 13 Part 11 Example Query

p125 Lecture 13 Part 12 Summary of Query Optimization

p126 Intro to Parallelism

p127 A Bit of History

p128 Parallel Architectures and Software Structures

p129 Kinds of Query Parallelism

p130 Parallel Data Acceess

p131 Parallel Hash Join

p132 Parallel Sort-Merge Join

p133 Parallel Grouping⧸Aggregation

p134 Symmetric Hash Join

p135 One-Sided and Broadcast Join Patterns

p136 Summary of Parallel Query Execution

p137 Lec 18 Part 1 Intro to Transactions

p138 Lec 18 Part 2 Examples and Problems

p139 Lec 18 Part 3 The Transaction Model

p140 Lect 18 Part 4 ACID Properties of Transactions

p141 Lec 18 Part 5 Serializability

p142 Lec 18 Part 6 Conflict Serializability

p143 Lec 18 Part 7 Conflict Dependency Graphs

p144 Lecture 18 Part 8 View Serializability

p145 Lecture 19 Part 01 Two Phase Locking

p146 Lecture 19 Part 2 Strict 2PL

p147 Lecture 19 Part 3 Concurrency Examples

p148 Lecture 19 Part 04 Lock Manager Implementation

p149 Lecture 19 Part 5 Deadlock Scenarios and Prevention

p150 Lecture 19 Part 6 Deadlock Avoidance

p151 Lecture 19 Part 7 Deadlock Detection and Resolution

p152 Lecture 19 Part 8 Intro to Multigranularity Locking

p153 Lecture 19 Part 9 Intent Locks and Hierarchical Lock Protocol

p154 Lecture 19 Part 10 FYI： Index Latching and Phantoms

p155 Lecture 19 Part 11 Conclusion

p156 Lecture 16 Introduction

p157 Lecture 16 Part 2 Overview of DB Design

p158 Lecture 16 Part 3 Data Models and Relational Levels of Abstrac

p159 Lecture 16 Part 4 Data Independence

p160 Lecture 16 Part 6 Basics of Entities and Relationships

p161 Lecture 16 Part 7 Key and Participation Constraints

p162 Lecture 16 Part 8 Weak Entities

p163 Lecture 16 Part 9 Alternative Notation and Terminology

p164 Lecture 16 Part 10 Binary vs Ternary Relationships

p165 Lecture 16 Part 11 Aggregation and Ternary Relationships

p166 Lecture 16 Part 12 Entities vs Attributes

p167 Lecture 16 Part 13 Entities vs Relationships

p168 Lecture 16 Part 14 Converting ER to Relational

p169 Lecture 16 Part 15 Translating Weak Entity Sets

p170 Lecture 16 part 16 Summary

p171 Lecture 17 Part 1 Functional Dependencies

p172 Lecture 17 Part 2 Anomalies

p173 Lecture 17 Part 3 Armstrongs Axioms

p174 Lecture 17 Part 4 Attribute Closures (Old)

p175 Lecture 17 Part 5 BCNF and other Normal Forms

p176 Lecture 17 Part 6 Lossless Join Decompositions

p178 Lecture 17 Part 8 Conclusion

p179 Lecture 15 Part 1 Intro to Text Search

p180 Lecture 15 Part 2 Bag of Words

p181 Lecture 15 Part 3 Inverted Files and Single-Term Queries

p182 Lecture 15 Part 4 Inverted Indexes and Boolean Logic

p183 Lecture 15 Part 5 Phrase Queries and Content Results

p184 Lecture 15 Part 6 Updating Text Indexes

p185 Lecture 15 Part 7 Text Search Summary

p186 Lecture 21 1 Cosine Similarity

p187 Lecture 21 2 TFxIDF

p188 Lecture 21 3 Precision and Recall

p189 Lecture 21 10 Conclusion

p190 Lecture 21 4 Parallelization and Zipf Distributions

p191 Lecture 21 5 n-grams, q-grams and other tricks

p192 Lecture 21 6 PageRank

p193 Lecture 21 7 Notes from the Real World

p194 Lecture 21 8 Webcrawler Intro

p195 Lecture 21 9 Webcrawler Refinements

p196 Lecture 20 Part 1 Recovery Intro

p197 Lecture 20 Part 2 Need for Atomicity and Durability, SQL suppo

p198 Lecture 20 Part 3 Strawman Solution

p199 Lecture 20 Part 4 STEAL ⧸ NO FORCE, UNDO and REDO

p0 Lecture 1. Computer Science

p1 Lab 0. Setup

p2 Lecture 2. Functions

p3 Lecture 2. Q&A

p4 Homework 1. Hints

p5 Lecture 3. Control

p6 Lecture 3. Q&A

p7 Lecture 4. Higher-Order Functions

p8 Lecture 4 Q&A

p9 Project 1. Hog Hint

p10 Lecture 5. Environments

p11 Lecture 5. Q&A

p12 Lab 2. Lambda Expression

p13 Lab 2. Multiple Environment

p14 Lecture 6. Design

p15 Lecture 6. Q&A

p16 Lecture 7. Function Examples

p17 Lecture 7. Q&A

p18 Lecture 8. Recursion

p19 Lecture 8. Q&A

p20 Lecture 9. Tree Recursion

p21 Lecture 9. Q&A

p22 Homework 2. Recursion Hint

p23 Lecture 10. Containers

p24 Lecture 10. Q&A

p25 Lecture 11. Data Abstraction

p26 Lecture 11. Q&A

p27 Project 2. Cats Hint

p28 Lecture 12. Trees

p29 Lecture 12. Q&A

p30 Lecture 13. Binary Numbers

p31 Lecture 13. Q&A

p32 Lecture 14. Circuits

p33 Lecture 14. Q&A

p34 Lecture 15. Mutable Values

p35 Lecture 15. Q&A

p36 Homework 3. Trees, Data Abstraction Hint

p37 Lecture 16. Mutable Functions

p38 Lecture 16. Q&A

p39 Lecture 17. Iterations

p40 Lecture 17. Q&A

p41 Lecture 18. Objects

p42 Lecture 18. Q&A

p43 Homework 4. Nonlocal, Iterators Hint

p44 Lecture 19. Inheritance

p45 Lecture 19. Q&A

p46 Project 3. Ants Hint

p47 Lecture 20. Representation

p48 Lecture 20. Q&A

p49 Lecture 21. Composition

p50 Lecture 21. Q&A

p51 Homework 5. OOP, Linked List, Trees Hint

p52 Lecture 22. Efficiency

p53 Lecture 22. Q&A

p54 Lecture 23. Decomposition

p55 Lecture 23. Q&A

p56 Lecture 24. Data Example

p57 Lecture 24. Q&A

p58 Lecture 25. Users

p59 Lecture 25. Q&A

p60 Lecture 26. Ethical AI & Data

p61 Lecture 27. Scheme

p62 Lecture 27. Q&A

p63 Homework 6. Scheme Hint

p64 Lecture 28. Exception

p65 Lecture 28. Q&A

p66 Lecture 29. Calculater

p67 Lecture 29. Q&A

p68 Homework 7. Scheme Lists Hint

p69 Lecture 30. Interpreters

p70 Lecture 30. Q&A

p71 Lab 11. Interpreters REPL

p72 Lecture 31. Declarative Programming

p73 Lecture 31. Q&A

p74 Homework 8. More Scheme Hint

p75 Lecture 32. Tables

p76 Lecture 32. Q&A

p77 Lecture 33. Aggregation

p78 Lecture 33. Q&A

p79 Lecture 34. Database

p80 Lecture 34. Q&A

p81 Homework 9. SQL Hint

p82 Lecture 35. Tail Calls

p83 Lecture 35. Q&A

p84 Lecture 36. Macros

p85 Lecture 36. Q&A

p86 Lecture 37. Final Example

p87 Lecture 37. Q&A

p88 Lecture 38, Conclusion

p89 Lecture 38, Q&A

p90 Final Review 1. Iterators Generators

p91 Final Review 2. Tree Recursion

p92 Final Review 3. Trees

p93 Final Review 4. OOP

p94 Final Review 5. SQL

p95 Final Review 6. Mutable Functions and Operators

p96 Final Review 7. Scheme

p97 Final Review 8. Linked Lists

p0 61A Fall 2022 Lecture 1-Computer Science

p1 61A Fall 2022 Lecture 2-Functions

p2 61A Fall 2022 Lecture 3-Control

p3 61A Fall 2022 Lecture 4-Higher-Order Functions

p4 Disc1-Control, Environment Diagrams

p5 Berkeley-CS61A-2022Fall p06 p1-Hog Problem #1 [BV1GK411Q7qp_p6]

p6 61A Fall 2022 Lecture 5-Environments

p7 61A Fall 2022 Lecture 6-Sound

p8 Berkeley-CS61A-2022Fall p09 61A Fall 2022 Lecture 7-Functional Abstraction [B

p9 Disc2-- Call Diagram [Sw7fFHLLpw0] 截取合并

p10 61A Fall 2022 Lecture 8-Function Examples

p11 61A Fall 2022 Lecture 9-Recursion

p12 Disc3-Recursion

p13 61A Fall 2022 Lecture 10-Tree Recursion

p14 61A Fall 2022 Lecture 11-Sequences

p15 61A Fall 2022 Lecture 12-Containers

p16 Disc4 Q1 - Count Stair Ways [-B0jnEHumEU] 截取合并

p17 p2-Cats Problem #1 Getting Started

p18 61A Fall 2022 Lecture 13-Data Abstraction

p19 61A Fall 2022 Lecture 14 Trees

p20 61A Fall 2022 Lecture 15 Mutability

p21 Disc 05 Sequences, Data Abstraction, Trees

p22 61A Fall 2022 Lecture 16 Syntax

p23 61A Fall 2022 Lecture 17 Iterators

p24 61A Fall 2022 Lecture 18 Generators

p25 Disc06

p26 61A Fall 2022 Lecture 19 Objects

p27 61A Fall 2022 Lecture 20 Inheritance

p28 Disc07

p29 p3-Ants Getting Started Intro

p30 61A Fall 2022 Lecture 21 Representation

p31 61A Fall 2022 Lecture 22 Announcements

p32 61A Fall 2022 Lecture 23 Announcements

p33 61A Fall 2022 Lecture 24

p34 61A Fall 2022 Lecture 25

p35 61A Fall 2022 Lecture 26 Announcements

p36 61A Fall 2022 Lecture 27

p37 61A Fall 2022 Lecture 28

p38 61A Fall 2022 Lecture 29

p39 61A Fall 2022 Lecture 30

p40 p4-Scheme Intro

p41 61A Fall 2022 Lecture 31

p42 61A Fall 2022 Lecture 32

p43 61A Fall 2022 Lecture 33 Macros

p44 61A Fall 2022 Lecture 34

p45 61A Fall 2022 Lecture 35

p46 61A Fall 2022 Lecture 36

p47 CS 61A Fall 2022 Lecture 37

p48 CS 61A Fall 2022 Lecture 38

p0 Lecture 01

p1 Lecture 02

p2 Lecture 03

p3 Lecture 04

p4 Lecture 05

p5 Lecture 06

p6 Lecture 07

p7 Lecture 08

p8 Lecture 09

p9 Lecture 10

p10 Lecture 11

p11 Lecture 12

p12 Lecture 13

p13 Lecture 14

p14 Lecture 15

p15 Lecture 16

p16 Lecture 17

p17 Lecture 18

p18 Lecture 19

p19 Lecture 20

p20 Lecture 21

p21 Lecture 22

p22 Lecture 23

p23 Lecture 24

p24 Lecture 25

p25 Lecture 26

p26 Lecture 27

p27 Lecture 28

p28 Lecture 29

p29 Lecture 30

p30 Lecture 31

p31 Lecture 32

p32 Lecture 33

p33 Lecture 34

p34 Lecture 35

p35 Lecture 36

p36 Lecture 37

p37 Lecture 38

p38 Lecture 39

p39 Lecture 40

p40 Lecture 41

p41 Lecture 42

p42 Lecture 43

p43 Lecture 44

p44 Lecture 45

p45 Lecture 46

p46 Lecture 47

p0 Counting I 2022 I Lecture 1

p1 Combinatorics I 2022 I Lecture 2

p2 What is Probability？ I 2022 I Lecture 3

p3 Conditional Probability and Bayes I 2022 I Lecture 4

p4 Independence I 2022 I Lecture 5

p5 Random Variables and Expectation I 2022 I Lecture 6

p6 Variance Bernoulli Binomial I 2022 I Lecture 7

p7 Poisson I 2022 I Lecture 8

p8 Continuous Random Variables I 2022 I Lecture 9

p9 Normal Distribution I 2022 I Lecture 10

p10 Joint Distributions I 2022 I Lecture 11

p11 Inference I 2022 I Lecture 12

p12 Inference II I 2022 I Lecture 13

p13 Modelling I 2022 I Lecture 14

p14 General Inference I 2022 I Lecture 15

p15 Beta I 2022 I Lecture 16

p16 Adding Random Variables I 2022 I Lecture 17

p17 Central Limit Theorem I 2022 I Lecture 18

p18 Bootstraping and P-Values I 2022 I Lecture 19

p19 Algorithmic Analysis I 2022 I Lecture 20

p20 M.L.E. I 2022 I Lecture 21

p21 M.A.P. I 2022 I Lecture 22

p22 Naive Bayes I 2022 I Lecture 23

p23 Logistic Regression I 2022 I Lecture 24

p24 Deep Learning I 2022 I Lecture 25

p25 Fairness I 2022 I Lecture 26

p26 Advanced Probability I 2022 I Lecture 27

p27 Future of Probability I 2022 I Lecture 28

p28 Counting I 2022 I Lecture 29

p0 Lec 1 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p1 Lec 2 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p2 Lec 3 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p3 Lec 4 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p4 Lec 5 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p5 Lec 6 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p6 Lec 7 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p7 Lec 8 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p8 Lec 9 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p9 Lec 10 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p10 Lec 11 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p11 Lec 12 ｜ MIT 6.042J Mathematics for Computer Science, Fall 2010

p0 1.1.1 Welcome to 6.042

p1 1.1.2 Intro to Proofs： Part 1

p2 1.1.3 Intro to Proofs： Part 2

p3 1.2.1 Proof by Contradiction

p4 1.2.3 Proof by Cases

p5 1.3.1 Well Ordering Principle 1： Video

p6 1.3.3 Well Ordering Principle 2： Video

p7 1.3.5 Well Ordering Principle 3： Video

p8 1.4.1 Propositional Operators： Video

p9 1.4.3 Digital Logic： Video

p10 1.4.4 Truth Tables： Video

p11 1.5.1 Predicate Logic 1： Video

p12 1.5.2 Predicate Logic 2： Video

p13 1.5.4 Predicate Logic 3： Video

p14 1.6.1 Sets Definitions： Video

p15 1.6.2 Sets Operations： Video

p16 1.7.1 Relations： Video

p17 1.7.3 Relational Mappings： Video

p18 1.7.5 Finite Cardinality： Video

p19 1.8.1 Induction： Video

p20 1.8.2 Bogus Induction： Video

p21 1.8.4 Strong Induction： Video

p22 1.8.6 WOP vs Induction： Video [optional]

p23 1.9.1 State Machines Invariants： Video

p24 1.9.3 Derived Variables： Video

p25 1.10.1 Recursive Data： Video

p26 1.10.4 Structural Induction： Video

p27 1.10.7 Recursive Functions： Video

p28 1.11.1 Cardinality： Video

p29 1.11.3 Countable Sets： Video

p30 1.11.4 Cantor's Theorem： Video

p31 1.11.7 The Halting Problem： Video [Optional]

p32 1.11.9 Russell's Paradox： Video

p33 1.11.11 Set Theory Axioms： Video [Optional]

p34 2.1.1 GCDs & Linear Combinations： Video

p35 2.1.2 Euclidean Algorithm： Video

p36 2.1.4 Pulverizer： Video

p37 2.1.6 Revisiting Die Hard： Video

p38 2.1.7 Prime Factorization： Video

p39 2.2.1 Congruence mod n： Video

p40 2.2.3 Inverses mod n： Video

p41 2.3.1 Modular Exponentiation Euler's Function： Video

p42 2.3.3 The Ring Z： Video

p43 2.4.1 RSA Public Key Encryption： Video

p44 2.4.3 Reducing Factoring To SAT： Video

p45 2.5.1 Digraphs： Walks & Paths： Video

p46 2.5.3 Digraphs： Connected Vertices： Video

p47 2.6.1 DAGs： Video

p48 2.6.3 Scheduling： Video

p49 2.6.5 Time versus Processors： Video

p50 2.7.1 Partial Orders： Video

p51 2.7.3 Representing Partial Orders As Subset Relations： Video

p52 2.7.4 Equivalence Relations： Video

p53 2.8.1 Degree： Video

p54 2.8.3 Isomorphism： Video

p55 2.9.1 Coloring： Video

p56 2.9.3 Connectivity： Video

p57 2.9.4 k-Connectivity： Video

p58 2.10.1 Trees： Video

p59 2.10.3 Tree Coloring： Video

p60 2.10.5 Spanning Trees： Video

p61 2.11.1 Stable Matching： Video

p62 2.11.2 Matching Ritual： Video

p63 2.11.5 Optimal Stable Matching： Video

p64 2.11.7 Bipartite Matching

p65 2.11.9 Hall's Theorem

p66 3.1.1 Arithmetic Sums： Video

p67 3.1.3 Geometric Sums： Video

p68 3.1.5 Book Stacking： Video

p69 3.1.7 Integral Method： Video

p70 3.1.9 Stirling's Formula： Video

p71 3.2.1 Asymptotic Notation： Video

p72 3.2.3 Asymptotic Properties： Video

p73 3.2.6 Asymptotic Blunders

p74 3.3.1 Sum And Product Rules： Video

p75 3.3.3 Counting with Bijections： Video

p76 3.4.1 Generalized Counting Rules： Video

p77 3.4.3 Two Pair Poker Hands： Video

p78 3.4.4 Binomial Theorem： Video

p79 3.4.5 Multinomial Theorem： Video

p80 3.5.1 The Pigeonhole Principle： Video

p81 3.5.3 Inclusion-Exclusion Example： Video

p82 3.5.4 Inclusion-Exclusion 2 Sets： Video

p83 4.1.1 Tree Model： Video

p84 4.1.3 Simplified Monty Hall Tree： Video

p85 4.1.5 Sample Spaces： Video

p86 4.2.1 Conditional Probability Definitions： Video

p87 4.2.3 Law of Total Probability： Video

p88 4.2.5 Bayes' Theorem： Video

p89 4.2.7 Monty Hall Problem： Video

p90 4.3.1 Independence： Video

p91 4.3.3 Mutual Independence： Video

p92 4.4.1 Bigger Number Game： Video

p93 4.4.2 Random Variables： Independence： Video

p94 4.4.4 Random Variables： Uniform & Binomial： Video

p95 4.5.1 Expectation： Video

p96 4.5.3 Expected Number Of Heads： Video

p97 4.5.5 Total Expectation： Video

p98 4.5.7 Mean Time to Failure： Video

p99 4.5.9 Linearity of Expectation： Video

p100 4.6.1 Deviation From The Mean： Video

p101 4.6.3 Markov Bounds： Video

p102 4.6.5 Chebyshev Bounds： Video

p103 4.6.7 Variance： Video

p104 4.7.1 Law Of Large Numbers： Video

p105 4.7.3 Independent Sampling Theorem： Video

p106 4.7.5 Birthday Matching： Video

p107 4.7.7 Sampling & Confidence： Video

p108 4.8.1 Random Walks： Video

p109 4.8.2 Stationary Distributions： Video

p110 4.8.3 Page Rank： Video

p0 1. Introduction to Computational and Systems Biology

p1 2. Local Alignment (BLAST) and Statistics

p2 3. Global Alignment of Protein Sequences (NW, SW, PAM, BLOSUM)

p3 4. Comparative Genomic Analysis of Gene Regulation

p4 5. Library Complexity and Short Read Alignment (Mapping)

p5 6. Genome Assembly

p6 7. ChIP-seq Analysis; DNA-protein Interactions

p7 8. RNA-sequence Analysis： Expression, Isoforms

p8 9. Modeling and Discovery of Sequence Motifs

p9 10. Markov and Hidden Markov Models of Genomic and Protein Features

p10 11. RNA Secondary Structure; Biological Functions and Predictions

p11 12. Introduction to Protein Structure; Structure Comparison and Classificati

p12 13. Predicting Protein Structure

p13 14. Predicting Protein Interactions

p14 15. Gene Regulatory Networks

p15 16. Protein Interaction Networks

p16 17. Logic Modeling of Cell Signaling Networks

p17 18. Analysis of Chromatin Structure

p18 19. Discovering Quantitative Trait Loci (QTLs)

p19 20. Human Genetics, SNPs, and Genome Wide Associate Studies

p20 21. Synthetic Biology： From Parts to Modules to Therapeutic Systems

p21 22. Causality, Natural Computing, and Engineering Genomes

Making a game in C from scratch! Ep 01： [Platform Layer and Softwar

Making a game in C from scratch! Ep 02： [Gameplay, Epic Collision F

Making a game in C from scratch! Ep 03： [Gameplay Programming, Begi

Making a game in C from scratch! Ep 04： [Programming Game Mechanics

Making a game in C from scratch! Ep 05： [Programming the Game Desig

Making a game in C from scratch! Ep 06： [Gameplay Debugging and Imp

Making a game in C from scratch! Ep 07： [Adding Juice to the Game (

Making a game in C from scratch! Ep 08： [Programming a Particle Sys

Making a game in C from scratch! Ep 09： [Graphics Programming： Rota

Making a game in C from scratch! Ep 10： [Bitmaps and Subpixel Rende

Making a game in C from scratch! Ep 11： [Audio System and Mixer]

Making a game in C from scratch! Ep 12： [Multithreaded Programming：

Making a game in C from scratch! Ep 13： [Main Menu, Save System, Im

Making a game in C from scratch! Ep 14： [Implementing Sound Effects

Making a game in C from scratch! Ep 15： [Better Menu, Gameplay HUD,

Making a game in C from scratch! Ep 16： [Optimizing the Game (5x fa

Making a game in C from scratch! Ep 17： [Gameplay Improvements： Ani

Making a game in C from scratch! Ep 18： [Level Design and Gameplay

Making a game in C from scratch! Ep 19： [Camera System, Screenshake

Making a game in C from scratch! Ep 20： [Animated Level Transitions

Making a game in C from scratch! Ep 21： [Asset System, Async Ogg Re

Making a game in C from scratch! Ep 22： [Game Polish, Config File P

Making a game in C from scratch! Ep 23： [The Game is DONE!]

Making a game in C from scratch! Ep 24： [Steam Release!]

Steam Game： Source Code Walkthrough [Break Arcade Games Out]

[COMPLETE] Every Step to develop a game from scratch and release it

[Tutorial] How to build a compiler with LLVM and MLIR - 01 Introduction

[Tutorial] How to build a compiler with LLVM and MLIR - 02 Basic Setup

How to build a compiler with LLVM and MLIR - 03 Overview

How to build a compiler with LLVM and MLIR - 04 The reader

How to build a compiler with LLVM and MLIR - 05 The Abstract Syntax Tree

How to build a compiler with LLVM and MLIR - 06 The Semantic Analyzer

How to build a compiler with LLVM and MLIR - 07 The Context and Namespace

How to build a compiler with LLVM and MLIR - 08 MLIR Basics

How to build a compiler with LLVM and MLIR - 09 IR (SLIR) generation

How to build a compiler with LLVM and MLIR - 10 Pass Infrastructure

How to build a compiler with LLVM and MLIR - 11 Lowering SLIR

How to build a compiler with LLVM and MLIR - 12 Target code generation

How to build a compiler with LLVM and MLIR - 13 Source Manager

How to build a compiler with LLVM and MLIR - 14 JIT Basics

How to build a compiler with LLVM and MLIR - 15 LLVM ORC JIT

How to build a compiler with LLVM and MLIR - 16 ORC Layers

How to build a compiler with LLVM and MLIR - 17 Custom ORC Layers

How to build a compiler with LLVM and MLIR - 18 JIT Engine part 1

How to build a compiler with LLVM and MLIR - 19 JIT Engine part 2

How to build a compiler with LLVM and MLIR - 20 Future Roadmap

p0_01_instructor-introduction

p1_02_course-introduction

p2_03_course-prerequisites

p3_01_lab-onboarding

p4_02_course-1-project-overview

p5_02_introduction-to-technical-discussions

p6_03_technical-discussions-with-markdown-github-and-jupyter-colab

p7_04_creating-technical-demo-videos

p8_05_effective-critical-thinking

p9_06_effective-technical-triple-threat

p10_02_introduction-to-effective-technical-teamwork

p11_03_effective-technical-teamwork

p12_02_introduction-to-technical-project-management

p13_03_effective-technical-project-management

p14_04_ticket-tracking-with-trello

p15_05_project-planning-with-spreadsheets

p16_06_project-management-anti-patterns

p17_01_introduction-to-aws-cloud-development

p18_04_introduction-to-continuous-integration

p19_05_cloud-development-with-aws-cloud9

p20_06_constructing-a-python-project-scaffold

p21_07_introduction-to-github-actions

p22_10_setup-amazon-codecatalyst

p23_11_codewhisperer-natural-language-to-bash-cli

p24_02_introduction-to-azure-cloud-development

p25_03_introduction-to-testing

p26_05_cloud-development-with-azure-cloud-shell

p27_06_azure-cloud-shell-continuous-integration-from-zero

p28_02_introduction-to-gcp-cloud-development

p29_03_development-onboarding-with-gcp

p30_05_introduction-to-continuous-delivery

p31_06_cloud-development-with-google-cloud-shell

p32_07_gcp-google-app-engine-continuous-delivery-from-zero

p33_08_microservices-with-gcp-cloud-run

p34_09_using-google-cloud-functions

p35_02_introduction-to-cloud-computing

p36_03_what-is-cloud-computing

p37_04_cloud-computing-service-models

p38_03_introduction-to-building-multiple-websites

p39_05_building-a-static-s3-website-on-aws

p40_06_using-aws-lambda-console-to-build-python-lambda-function

p41_07_building-a-serverless-website-on-aws-lambda

p42_08_building-a-website-on-an-ec2-virtual-machine

p43_09_building-a-website-using-paas-with-aws-beanstalk

p44_10_static-websites-with-zola

p45_11_customizing-zola-theme

p46_02_introduction-to-cloud-computing-economics

p47_03_cloud-computing-economics-a-story

p48_04_cloud-economics-deep-dive

p49_02_introduction-to-devops

p50_04_devops-in-the-real-world

p51_05_benefits-of-devops

p52_06_devops-best-practices

p53_02_introduction-to-managing-cloud-infrastructure-using-iac

p54_04_iac-in-the-real-world

p55_05_what-is-iac

p56_06_launching-a-vm-with-terraform-on-gcp

p57_08_hello-world-aws-cdk-for-python

p58_02_introduction-to-continuous-pipelines

p59_03_continuous-delivery-overview

p60_04_continuous-delivery-deep-dive

p61_05_continuously-deploy-flask-machine-learning-application-with-

p62_06_continuous-delivery-pipeline-with-a-lint-operation-using-azu

p63_08_initial-setup-of-aws-cloud9-and-github-for-hugo

p64_09_build-hugo-directory-in-aws-cloud9

p65_10_copy-hugo-data-into-aws-cloud9-s3-bucket

p66_11_automatic-updating-of-hugo-in-aws-cloud9

p0_01_instructor-introduction

p1_02_course-introduction

p2_04_course-prerequisites

p3_01_lab-onboarding

p4_02_course-2-project-overview

p5_02_introduction-to-virtual-machines

p6_03_containers-vs-virtual-machines

p7_06_how-do-spot-instances-work

p8_07_launch-an-aws-spot-instance

p9_08_create-a-gcp-virtual-machine-from-terminal

p10_10_create-compute-cluster-in-azure-ml-studio

p11_11_aws-cloud-shell

p12_12_google-cloud-shell

p13_02_introduction-to-containers

p14_03_using-containers

p15_04_what-is-docker

p16_05_run-a-container-from-docker-hub

p17_08_build-a-docker-container-project-from-scratch

p18_09_push-to-project-to-aws-ecr-registry

p19_11_what-is-distroless

p20_13_rust-distroless-pytorch-walkthrough

p21_14_rust-distroless-pytorch-running-demo

p22_02_introduction-to-kubernetes

p23_03_overview-of-kubernetes

p24_04_kubernetes-key-concepts

p25_05_kubernetes-pods-and-nodes

p26_06_kubernetes-cluster

p27_08_deploy-app-to-kubernetes-on-gke

p28_09_kubernetes-demo

p29_10_options-container-orchestration

p30_12_minikube-fastapi-demo

p31_02_introduction-to-microservices

p32_04_what-is-a-microservice

p33_07_running-microservices

p34_02_introduction-to-flask

p35_03_what-is-flask

p36_04_flask-change-microservice

p37_05_flask-azure-microservice

p38_02_introduction-to-serverless-microservices

p39_03_serverless-functions-overview

p40_04_build-marco-polo-aws-lambda

p41_05_build-marco-polo-step-function

p42_06_build-aws-s3-bucket-trigger

p43_09_cli-trigger-of-lambda

p44_10_google-cloud-function-change

p45_13_using-aws-lambda-console

p46_14_using-step-functions

p47_15_invoking-step-functions-cli

p48_16_building-rust-aws-lambda-add-function

p49_17_building-rust-aws-lambda-divide-by-two-function

p50_18_invoking-aws-step-functions-from-cli

p51_19_rust-aws-step-functions

p52_20_demo-app-engine-rust-deploy

p53_02_introduction-to-monitoring-and-alerts

p54_04_effective-monitoring-and-alerts

p55_05_monitoring-triggers-and-alerts-with-aws-cloudwatch

p56_06_building-an-alert-from-scratch

p57_07_monitoring-and-logging-with-google-app-engine-rust-microserv

p58_02_introduction-to-load-testing

p59_03_effective-load-testing

p60_04_flask-locust-load-test

p61_05_locust-load-test-in-github-codespaces

p62_07_prometheus-monitoring

p63_02_introduction-to-kaizen

p64_03_effective-continuous-improvement

p65_04_what-are-the-five-whys

p0_01_instructor-introduction

p1_03_course-introduction

p2_04_lab-onboarding

p3_06_course-3-project-overview

p4_02_introduction-to-the-end-of-moores-law

p5_03_the-problem-with-concurrency-in-python

p6_04_exploring-the-end-of-moores-law

p7_06_using-cuda-and-numba

p8_08_what-is-an-asic

p9_10_taking-advantage-of-colab-pro

p10_11_exploring-colab-ai

p11_02_introduction-to-distributed-systems

p12_03_logging-and-instrumentation-distributed-systems

p13_04_cap-theorem

p14_05_amdahls-law

p15_06_elasticity

p16_07_highly-available-nine-nine-s

p17_10_debugging-python-code

p18_03_exploring-google-bigquery

p19_04_what-is-big-data

p20_05_data-lakes

p21_06_big-data-processing

p22_07_introduction-to-aws-data-engineering-design-principles

p23_08_processing-big-data-with-aws

p24_10_transform-data-with-databricks-spark-sql

p25_02_introduction-to-data-engineering

p26_03_data-driven-organizations

p27_04_what-is-data-engineering

p28_05_batch-vs-streaming-vs-events

p29_06_ingesting-by-batch-or-stream

p30_02_building-cli-tools-with-click

p31_03_building-containerized-command-line-tools

p32_05_rust-and-python

p33_06_python-calculator-cli

p34_07_caesar-cipher-cli

p35_02_advanced-testing-with-amazon-codeguru

p36_03_advanced-testing-with-aws-codebuild

p37_04_mapping-functions-to-cli-part-1

p38_05_mapping-functions-to-cli-part-2

p39_07_aws-codewhisperer-cli

p40_08_aws-codewhisperer-sdk

p41_02_introduction-to-serverless-data-engineering

p42_04_automating-pipelines

p43_05_what-is-serverless

p44_06_serverless-concepts-service-model

p45_07_serverless-concepts-functions

p46_08_serverless-concepts-ecosystem

p47_09_aws-lambda-overview

p48_10_introduction-to-aws-cloud9

p49_11_aws-lambda-event-handling

p50_12_aws-lambda-hello-world

p51_13_aws-lambda-deploy-testing

p52_14_aws-lambda-wikipedia-example

p53_15_build-a-serverless-data-pipeline

p54_16_serverless-cookbook-with-aws

p55_17_serverless-cookbook-with-gcp

p56_02_introduction-to-data-governance

p57_03_what-is-data-governance

p58_04_the-principle-of-least-privilege

p59_05_cloud-security-with-iam-on-aws

p60_06_aws-shared-security-model

p61_07_aws-iam-service

p62_08_aws-cloud-security-operations

p63_09_encrypt-at-rest-and-transit

p64_02_introduction-to-extract-transform-load-etl

p65_03_what-is-etl

p66_04_ingesting-and-preparing-data-on-aws

p67_05_using-amazon-athena-with-aws-glue

p68_06_real-world-problems-in-etl

p69_02_introduction-to-cloud-databases

p70_03_one-size-does-not-fit-all-in-the-cloud

p71_05_mysql-overview

p72_06_mysql-from-terminal

p73_07_archive-and-drop-database

p74_08_import-external-database-sakila

p75_09_modify-database-sakila

p76_10_bash-pipelines-with-mysql

p77_11_mysql-to-python-standard-library-web-server

p78_12_big-query-with-prompt-engineering

p79_13_big-query-colab-pipeline

p80_02_introduction-to-cloud-storage

p81_03_why-cloud-storage

p82_05_cloud-storage-deep-dive

p83_06_using-amazon-s3

p0_01_instructor-introduction

p1_02_course-introduction

p2_03_lab-onboarding

p3_05_course-4-project-overview

p4_01_introduction-to-machine-learning-engineering

p5_02_machine-learning-engineering-overview

p6_03_machine-learning-engineering-architecture

p7_01_introduction-to-machine-learning-microservices

p8_02_machine-learning-microservices-overview

p9_03_monolithic-versus-microservice

p10_01_introduction-to-continuous-delivery-for-machine-learning

p11_02_continuous-delivery-for-machine-learning-overview

p12_03_what-is-data-drift

p13_04_continuously-deploy-flask-ml-application

p14_05_aws-app-runner-high-level-paas-continuous-delivery

p15_01_introduction-to-automl

p16_02_what-is-automl

p17_03_automl-computer-vision

p18_04_introduction-to-no-code-low-code

p19_05_no-code-low-code-automl-part-1

p20_06_no-code-low-code-automl-part-2

p21_07_apple-create-ml-automl

p22_01_introduction-to-ludwig-automl

p23_02_what-is-ludwig-automl

p24_03_ludwig-automl-deep-dive

p25_04_ludwig-automl-by-example

p26_01_introduction-to-cloud-automl

p27_02_what-is-cloud-automl

p28_03_cloud-automl-deep-dive

p29_04_guest-speaker-alfredo-deza

p30_05_introduction-to-azure-machine-learning-studio

p31_06_create-a-dataset-in-azure-machine-learning-studio

p32_07_automated-ml-run-in-azure-machine-learning-studio

p33_08_experiments-in-azure-machine-learning-studio

p34_09_deploy-a-module-in-azure-machine-learning-studio

p35_10_test-endpoints-in-azure-machine-learning-studio

p36_01_introduction-to-mlops

p37_02_what-is-mlops

p38_03_mlops-deep-dive

p39_01_introduction-to-edge-machine-learning

p40_02_what-is-edge-machine-learning

p41_03_edge-machine-learning-vision-in-action

p42_04_hardware-inference-model-solutions-in-edge-machine-learning

p43_05_edge-machine-learning-in-google

p44_06_edge-machine-learning-in-aws

p45_01_introduction-to-ai-apis

p46_02_how-to-use-ai-apis

p47_03_core-components-of-a-cloud-application

p48_04_aws-comprehend-for-natural-language-processing

p49_05_aws-rekognition-for-computer-vision

p50_06_gcp-automl-for-natural-language-processing

p51_07_gcp-automl-for-computer-vision

p52_08_azure-automl-for-ai-predictions

p53_09_azure-automl-for-computer-vision

p54_10_core-components-of-a-cloud-application-recap

p55_01_steps-to-developing-an-api

p56_02_flask-machine-learning-backend

p57_03_checklist-for-building-professional-web-services

【Lecture 01】CS107, Computer Organization & Systems [xuRkyNqqecc]

【Lecture 02】CS107, Computer Organization & Systems [2lI1Nvn5ad0]

【Lecture 03】CS107, Computer Organization & Systems [uFGnTtairxw]

【Lecture 04】CS107, Computer Organization & Systems [7hNhJj1zUyM]

【Lecture 05】CS107, Computer Organization & Systems [EdnEBjmOHmY]

【Lecture 06】CS107, Computer Organization & Systems [zrjMK_83b-8]

【Lecture 07】CS107, Computer Organization & Systems [3Om5pkvGLHo]

【Lecture 08】CS107, Computer Organization & Systems [tFSp53J0Fps]

【Lecture 09】CS107, Computer Organization & Systems [zrun2KpTwDk]

【Lecture 10】CS107, Computer Organization & Systems [YPC-P9lphqs]

【Lecture 11】CS107, Computer Organization & Systems [IMDIJALdf7I]

【Lecture 12】CS107, Computer Organization & Systems [ZmBJRMIzW_E]

【Lecture 13】CS107, Computer Organization & Systems [13upiQTl4R8]

【Lecture 14】CS107, Computer Organization & Systems [DZezonum9cw]

【Lecture 15】CS107, Computer Organization & Systems [nMLcqs3w2-E]

11.2.1 Iterpretation and Compilation

11.2.2 Compiling Expressions

11.2.3 Compiling Statements

11.2.4 Compiler Frontend

11.2.5 Optimization and Code Generation

11.2.6 Worked Examples

12.2.1 Procedures

12.2.2 Activation Records and Stacks

12.2.3 Stack Frame Organization

12.2.4 Compiling a Procedure

12.2.5 Stack Detective

12.2.6 Worked Examples： Procedures and Stacks

13.2.1 Building Blocks

13.2.2 ALU Instructions

13.2.3 Load and Store

13.2.4 Jumps and Branches

13.2.5 Exceptions

13.2.6 Summary

13.2.7 Worked Examples： A Better Beta

13.2.7 Worked Examples： Beta Control Signals

14.2.1 Memory Technologies

14.2.2 SRAM

14.2.3 DRAM

14.2.4 Non-volatile Storage; Using the Hierarchy

14.2.5 The Locality Principle

14.2.6 Caches

14.2.7 Direct-mapped Caches

14.2.8 Block Size; Cache Conflicts

14.2.9 Associative Caches

14.2.10 Write Strategies

14.2.11 Worked Examples： Cache Benefits

14.2.11 Worked Examples： Caches

15.2.1 Improving Beta Performance

15.2.2 Basic 5-Stage Pipeline

15.2.3 Data Hazards

15.2.4 Control Hazards

15.2.5 Exceptions and Interrupts

15.2.6 Pipelining Summary

15.2.7 Worked Examples： Pipelined Beta

15.2.7 Worked Examples： Beta Junkyard

16.2.1 Even More Memory Hierarchy

16.2.2 Basics of Virtual Memory

16.2.3 Page Faults

16.2.4 Building the MMU

16.2.5 Contexts

16.2.6 MMU Improvements

16.2.7 Worked Examples： Virtual Memory

17.2.1 Recap： Virtual Memory

17.2.2 Processes

17.2.3 Timesharing

17.2.4 Handling Illegal Instructions

17.2.5 Supevisor Calls

17.2.6 Worked Examples： Operating Systems

18.2.1 OS Device Handlers

18.2.2 SVCs for InputOutput

18.2.3 Example： Match Handler with OS

18.2.4 Real Time

18.2.5 Weak Priorities

18.2.6 Strong Priorities

18.2.7 Example： Priorities in Action!

18.2.8 Worked Examples： Devices and Interrupts

19.2.1 Interprocess Communication

19.2.2 Semaphores

19.2.3 Atomic Transactions

19.2.4 Semaphore Implementation

19.2.5 Deadlock

19.2.6 Worked Examples： Semaphores

20.2.1 System-level Interfaces

20.2.2 Wires

20.2.3 Buses

20.2.4 Point-to-point Communication

20.2.5 System-level Interconnect

20.2.6 Communication Topologies

21.2.1 Instruction-level Parallelism

21.2.2 Data-level Parallelism

21.2.3 Thread-level Parallelism

21.2.4 Shared Memory & Caches

21.2.5 Cache Coherence

21.2.6 6.004 Wrap-up

An Interview with Christopher Terman on Teaching Computation Structures

1.2.1 What is Information？

1.2.2 Quantifying Information

1.2.3 Entropy

1.2.4 Encoding

1.2.5 Fixed-length Encodings

1.2.6 Signed Integers： 2s complement

1.2.7 Variable-length Encoding

1.2.8 Huffmans Algorithm

1.2.9 Huffman Code

1.2.10 Error Detection and Correction

1.2.11 Error Correction

1.2.12 Worked Examples： Quantifying Information

1.2.12 Worked Examples： Twos Complement Representation

1.2.12 Worked Examples： Twos Complement Addition

1.2.12 Worked Examples： Huffman Encoding

1.2.12 Worked Examples： Error Correction

2.2.1 Concrete Encoding of Information

2.2.2 Analog Signaling

2.2.3 Using Voltages Digitally

2.2.4 Combinational Devices

2.2.5 Dealing with Noise

2.2.6 Voltage Transfer Characteristic

2.2.7 VTC Example

2.2.8 Worked Examples： The Static Discipline

3.2.1 MOSFET： Physical View

3.2.2 MOSFET： Electrical View

3.2.3 CMOS Recipe

3.2.4 Beyond Inverters

3.2.5 CMOS Gates

3.2.6 CMOS Timing

3.2.7 Lenient Gates

3.2.8 Worked Examples： CMOS Functions

3.2.8 Worked Examples： CMOS Logic Gates

4.2.1 Sum of Products

4.2.2 Useful Logic Gates

4.2.3 Inverting Logic

4.2.4 Logic Simplification

4.2.5 Karnaugh Maps

4.2.6 Multiplexers

4.2.7 Read-only Memories

4.2.8 Worked Examples： Truth Tables

4.2.8 Worked Examples： Gates and Boolean Logic

4.2.8 Worked Examples： Combinational Logic Timing

4.2.8 Worked Examples： Karnaugh Maps

5.2.1 Digital State

5.2.2 D Latch

5.2.3 D Register

5.2.4 D Register Timing

5.2.5 Sequential Circuit Timing

5.2.6 Timing Example

5.2.7 Worked Example 1

5.2.8 Worked Example 2

6.2.1 Finite State Machines

6.2.2 State Transition Diagrams

6.2.3 FSM States

6.2.4 Roboant Example

6.2.5 Equivalent States; Implementation

6.2.6 Synchronization and Metastability

6.2.7 Worked Examples： FSM States and Transitions

6.2.7 Worked Examples： FSM Implementation

7.2.1 Latency and Throughput

7.2.2 Pipelined Circuits

7.2.3 Pipelining Methodology

7.2.4 Circuit Interleaving

7.2.5 Self-timed Circuits

7.2.6 Control Structures

7.2.7 Worked Examples： Pipelining

7.2.7 Worked Examples： Pipelining 2

8.2.1 Power Dissipation

8.2.2 Carry-select Adders

8.2.3 Carry-lookahead Adders

8.2.4 Binary Multiplication

8.2.5 Multiplier Tradeoffs

8.2.6 Part 1 Wrap-up

9.2.1 Datapaths and FSMs

9.2.2 Programmable Datapaths

9.2.3 The von Neumann Model

9.2.4 Storage

9.2.5 ALU Instructions

9.2.6 Constant Operands

9.2.7 Memory Access

9.2.8 Branches

9.2.9 Jumps

9.2.10 Worked Examples： Programmable Architectures

10.2.1 Intro to Assembly Language

10.2.2 Symbols and Labels

10.2.3 Instruction Macros

10.2.4 Assembly Wrap-up

10.2.5 Models of Computation

10.2.6 Computability, Universality

10.2.7 Uncomputable Functions

10.2.8 Worked Examples： Beta Assembly

An Interview with Christopher Terman on Teaching Computation Structures

P1 Welcome

P2 Lecture 1 (Introduction to Congestion Games)

P3 Lecture 2 (Computing Equilibria in Congestion Games)

P4 Lecture 3 (Normal-Form Games and Mixed Nash Equlibria)

P5 Lecture 4 (Existence of Mixed Nash Equilibria)

P6 Lecture 5 (Complexity of Pure Nash Equilibria in Congestion Games)

P7 Lecture 6 (Correlated Equilibria)

P8 Lecture 7 (Minimizing External Regret)

P9 Lecture 8 (Price of Anarchy)

P10 Lecture 9 (Inefficiencies in Cost and Market Sharing Games)

P11 Lecture 10 (Introduction to Mechanism Design)

P12 Lecture 11 (Single-Parameter Mechanisms)

P13 Lecture 12 (Greedy Mechanisms for Combinatorial Auctions)

P14 Lecture 13 (VCG Mechanisms)

P15 Lecture 14 (Bayes-Nash Equilibria)

P16 Lecture 15 (Smooth Mechanisms)

P17 Lecture 16 (Simple Combinatorial Auctions)

P18 Lecture 17 (Walrasian Equilibria)

P19 Lecture 18 (Posted Prices with Incomplete Information)

P20 Lecture 19 (Revenue Maximization)

P21 Lecture 20 (Revenue Maximization with Identical Distributions)

P22 Lecture 21 (Allocations without Money)

P23 Lecture 22 (Stable Matching)

P24 Lecture 23 (Cake Cutting)

P25 Lecture 24 (Voting)

P26 Lecture 25 (Cost Sharing)

P1 thms (Lecture 1： Course Goals and Introduction to Maximum Flow)

P2 thms (Lecture 2： Augmenting Path Algorithms for Maximum Flow)

P3 thms (Lecture 3： The Push-Relabel Algorithm for Maximum Flow)

P4 thms (Lecture 4： Applications of Maximum Flows and Minimum Cuts)

P5 thms (Lecture 5： Minimum-Cost Bipartite Matching)

P6 thms (Lecture 6： Generalizations of Maximum Flow and Bipartite Matching)

P7 thms (Lecture 7： Linear Programming： Introduction and Applications)

P8 rthms (Lecture 8： Linear Programming Duality --- Part 1)

P9 thms (Lecture 9： Linear Programming Duality --- Part 2)

P10 thms (Lecture 10： The Minimax Theorem & Algorithms for Linear Programming)

P11 thms (Lecture 11： Online Learning and the Multiplicative Weights Algorithm)

P12 thms (Lecture 12： Applications of Multiplicative Weights to Games and LPs)

P13 thms (Lecture 13： Online Scheduling and Online Steiner Tree)

P14 thms (Lecture 14： Online Bipartite Matching)

P15 thms (Lecture 15： Introduction to Approximation Algorithms)

P16 thms (Lecture 16： The Traveling Salesman Problem)

P17 thms (Lecture 17： Linear Programming and Approximation Algorithms)

P18 thms (Lecture 18： Five Essential Tools for Analyzing Randomized Algorithms)

P19 thms (Lecture 19： Beating Brute-Force Search)

P20 thms (Lecture 20： Semidefinite Programming and the Maximum Cut Problem)

P1 01_讲座0-欢迎

P2 02_讲座1-引言材料

P3 03_讲座2-逻辑组合子

P4 01_作业1指导教程

P5 02_作业2指导教程

P6 03_习题集1指导教程

P7 01_讲座3-蕴涵

P8 02_讲座4-等价关系

P9 03_补充材料-课程评估量规使用指南

P10 01_作业3指导教程

P11 02_作业4指导教程

P12 03_习题集2指导教程

P13 01_讲座5-量词

P14 01_补充材料：如何阅读数学公式

P15 02_作业5指导教程

P16 03_习题集3指导教程

P17 01_讲座6a：量词运用1

P18 02_讲座6b：量词运用2

P19 01_作业6指导教程

P20 02_习题集4指导教程

P21 01_讲座7a：证明方法1

P22 02_讲座7b：证明方法2

P23 01_作业7指导教程

P24 02_习题集5指导教程

P25 01_讲座8a：带量词的证明方法1

P26 02_讲座8b：带量词的证明方法2

P27 01_作业8指导教程

P28 02_习题集6指导教程

P29 01_讲座9a：数论基础1

P30 02_讲座9b：数论进阶2

P31 01_作业9辅导课

P32 02_习题集7辅导教程

P33 01_讲座10a：实分析基础1

P34 02_讲座10b：实分析进阶2

P35 03_讲座10c：实分析深化3

P36 01_作业10辅导课

P37 02_习题集8辅导教程

P38 01_试飞简介

P39 01_试飞教程1

P40 02_试飞教程2

P41 03_试飞教程3

P42 01_《数学思维阅读：音障》

P1 01_课程介绍

P2 04_如何建立学习日志

P3 01_密码学导论

P4 04_物理世界安全服务

P5 02_核心服务

P6 06_第一周总结

P7 01_密码学应用导论

P8 02_六大技术导论

P9 01_Wi-Fi服务

P10 03_第二周总结

P11 01_密码系统导论

P12 03_算法与密钥

P13 02_不同类型密码系统的应用方式

P14 03_第三周总结

P15 01_密码系统攻击方法导论

P16 04_薄弱环节

P17 06_两个世界

P18 09_第四周总结

P19 01_课程总结

P1 01_课程概述

P2 01_概述

P3 01_什么是SQL

P4 02_什么是PROC SQL

P5 03_PROC SQL语法

P6 04_探索表

P7 05_演示：探索客户表

P8 06_SQL选项

P9 07_比较SQL与DATA步

P10 01_概述

P11 01_使用WHERE子句筛选行