### Programming and Computer Science Video Lectures

They include: algorithms, data structures, advanced data structures, java programming, programming methodology, programming abstractions, programming paradigms, natural language processing, machine learning and robotics. I also added some bonus videos: videos of Edsger Dijkstra, videos from Haskell conference 2008, interview with Simon Jones (creator of Haskell) and two fun videos from OSCON and Web 2.0 expo.

Edsger W. Dijkstra's Video Archive

Four videos by the famous computer scientist Edsger Dijkstra:

- A 25-minute visit with Dijkstra, filmed in Austin by Dutch public TV in autumn 2000.
- A 1992 lecture at the 25th Joint International Seminar on the Teaching of Computing Science (at the University of Newcastle-upon-Tyne).
- The Power of Counting Arguments (Cadence Labs Distinguished Speaker Series, 16 January 2001).
- Speeches at the Dijkstra retirement symposium's banquet.

Steven Skiena's Algorithms (Stony Brook University)

Course topics:

Introduction to Algorithms. Asymptotic Notation. Modeling / Logarithms. Elementary Data Structures. Dictionary data structures / Trees. Sorting. Heapsort/Priority Queues. Quicksort. Linear Sorting. Graph Data Structures. Breadth/Depth-First Search. Topological Sort / Connectivity. Minimum Spanning Trees. Shortest Path. All-Pairs Shortest Paths. Combinatorial Search. Program optimization. Introduction to Dynamic Programming. Examples of Dynamic Programming. Divide and Conquer. Recurrence Relations. Introduction to NP-completeness. Reductions. More Reductions. Cook's Theorem / Harder Reduction. The NP-completeness challenge. Approximation Algorithms. Heuristic Methods.

Data Structures, Algorithms, and Applications in Java (COP 3530, University of Florida)

Course topics:

Insertion sort. Insertion sort and practical complexities. Run-time measurement. Linear lists. Array representation and array resizing. Walk through of code for ArrayLinearList. Iterators. Linked representation of a linear list. Walk through of code for Chain. Head nodes, circular lists, doubly linked lists. Simulated pointers and available-space lists. Row-major and column-major indexing, and special matrices. Sparse matrices. Stacks--application to parentheses matching, towers-of-hanoi, railroad car rearrangement, and switchbox routing; array stacks. Array and linked stacks. Nonapplicability of queues for parantheses matching, towers-of-hanoi, railroad problem with LIFO tracks, and switchbox routing. Application of queues to railroad problem with FIFO tracks, wire routing, and component labeling. Array and linked queues. Dictionaries, linear list representation, and hashing. Hashing and hash table design. LZW compression. Trees, binary trees, and properties. Binary tree representation and operations. Binary tree traversal methods-- preorder, inorder, postorder, level order. Reconstruction from two orders. Online equivalence classes. Application of priority queues to heap sort and machine scheduling. Min and max heaps. Initialization of min and max heaps. Height- and weight-biased leftist trees. Winner and loser trees and application to k-way merging, run generation, and first-fit bin packing. Binary search trees and indexed binary search trees. Definition of AVL trees. Graph applications and properties. Graph operations and representation. Breadth-first and depth-first search. Application to path finding, connected components, and spanning trees. Greedy method and application to bin packing, loading, and knapsack problems. Single source all destinations shortest paths algorithm. Kruskal's and Prim's minimum-cost spanning tree algorithms. Divide and conquer, and application to defective chessboard and min-max problem. Iterative min-max implementation. Merge sort, natural merge sort, and quick sort. Selection and closest pair of points. Dynamic programming, 0/1 knapsack problem, recursive and iterative solutions. Matrix multiplication chains, dynamic programming recurrence, recursive solution. Iterative solution to matrix multiplication chains. All pairs shortest paths. Single source shortest paths with negative edge weights. Solution space trees and backtracking. Branch and bound.

Advanced Data Structures (COP 5536/AD 711R, University of Florida)

Video lectures are available by replacing last two 'xx' with numbers 01, 02, ... 40 in this address:

http://128.227.245.34/ramgen/perpetual/COP5536/RealMedia/COP5536_xx.rm

For example:

Lecture 01: http://128.227.245.34/ramgen/perpetual/COP5536/RealMedia/COP5536_01.rm

Course topics:

01 and 02. Amortized complexity. 03. Introduction to external sorting. 04. Introduction to external sorting. 05. Selection trees & k-way merging. 06. Run generation. 07. Optimal merging of runs. 08. Buffering. 09. Double-ended priority queues. General methods. 10. Double-ended priority queues. Interval heaps. 11. Leftist trees. 12 and 13. Binomial heaps. 14. Fibonacci heaps. 15. Pairing heaps. 16. Dictionaries. 17. Optimal binary search trees. 18 and 19. AVL trees. 20 and 21. Red-black trees. 22 and 23. B-Trees. 24. B+ and B*-trees. 25 and 26. Splay Trees. 27. Binary Tries. 28. Compressed Binary Tries. 29. High-order Tries. 30. Tries and Packet Forwarding. 31. Suffix Trees. 32. Bloom Filters. 33. Segment Trees. 34. Interval Trees. 35 and 36. Priority Search Trees. 37. Multidimensional Search Trees. 38. Quad Trees. 39. BSP Trees. 40. R-trees.

Programming Methodology (Stanford University)

Videos are available in Silverlight, YouTube, iTunes, Vyew, WMV Torrent and MP4 Torrent formats.

Course topics:

1. Karel programming language. 2. Karel Commands, An Algorithm vs Program, Syntax of a Karel Program, Running a Karel Program, Creating Methods, SuperKarel, A for Loop, A While Loop, Karel Conditions, If Statement. 3. Karel and Java, Common Errors, Comments, Pre-conditions and Post-conditions, Decomposition, The DoubleBeepers Example, Importance of Good Software Engineering, The Right Decomposition, The CleanUpKarel Example. 4. The History of Computing, Computer Science vs Programming, What Does the Computer Understand?, The Compilation Process, Java is an Object Oriented Language, Inheritance, Instance of a Class, The acm.program Hierarchy, Your First Java Program, A ConsoleProgram Example, The Graphics Window, The Sending-Messages-to-a-GLabel Example. 5. Variables, Data Types for Variables, Syntax for Using Variables, Classes as Types, Objects as Variables, Invoking Methods on Objects, Graphics Coordinates, Operations on the GObject Class and its Subclasses, Drawing Geometrical Objects, A FunGraphics Example, Expressions and Operators. 6. readInt() and readDouble(), The Division Operator with respect to ints and Doubles, Order of Precedence for Operators, Type Casting, Shorthands, Constants, The Boolean Data Type, Value Comparisons, Boolean Expressions, Short Circuit Evaluation, Statement Blocks, Scope of Variables, Cascading if, The Switch Statement, The For Loop, The While Loop. 7. The Loop and a Half Problem, For Versus While Loop, The CheckerBoard Program Example, Methods in Java, Examples of Methods, The FactorialExample Program, Returning Objects from Methods. 8. Information Hiding, The Void Return Type, Parameter Passing Between Methods, Bad Times with Methods, Using Classes, Instance variables vs Local Variables, The RandomGenerator Program Example, The RollDice Program Example, The setSeed() Method. 9. Strings, Writing Your Own Class, Public and Private Visibility, Creating a New Class, The Constructor Method, Shadowing of Variables and the 'this' Keyword, Using the Created Class, Objects are Called by Reference not Called by Value, Class Variables, The JavaDoc, The Student Program Example. 10. Importance of Private Variables, Extending the Student Class, Overriding Methods, The acm.graphics Package, GCanvas, Methods Common to All GObjects, Interfaces and Methods Defined by Them, The BouncingBall Program Example, The Geometry of the GLabel Class, The GArc Class. 11. The GImage Class, The GPolygon Class, The GCompound Class, Event Driven Programs, The ClickForFace Program Example, Responding to Mouse Events, Responding to Keyboard Events, The UFO program Example. 12. Enumeration, Characters, The ASCII Subset of Unicode, Reading Characters, Math on Characters, char as a Primitive Type; the Character Class, Strings and Their Manipulations. 13. String Processing, Tokenizers, Encryption. 14. Memory, Different Sections of Memory for Different Types of Variables, Memory Allocation Mechanics, The Pointer Viewpoint, The Binky Pointer Fun Video. 15. Pointer Recap, Why are Objects 'Call by Reference' Instead of 'Call of Value'?, Wrapper Classes for Primitive Types, Files, Code for Opening, Reading and Closing Files, Exceptions, Code for Writing Files. 16. Array, Creating a New Array, The ++ Operator, Actual Size / Effective Size of the Array, An Array as a Parameter, Initialize an Array During Creation, An ArrayList. 17. Multi-dimensional Arrays, An ArrayList, The Template Class, Methods in the ArrayList Class, An Example Program Using ArrayList, ArrayLists Hold Objects, An Example Program with an ArrayList of Glabels, The GrayImage Example Program. 18. A Wrap Up of Multi-dimensional Arrays, The ArrayList Way, Pros and Cons : ArrayList vs. Array, Debugging, Approaches to Debugging, The Debugger in Eclipse. 19. An Interface, How are Interfaces Implemented, A Map, The HashMap Class, Methods of the HashMap, The Collection Hierarchy, The Map Hierarchy, An Iterator, A HashMap Example. 20. GUI, Interactors in the Context of a Java Program, The Swing Interactor Hierarchy, Window Regions, Creating Interactors, Example Programs, Exploring More Interactors, The InteractiveDrawFace Program Example. 21. Review of Interactors and Listeners, Example Programs, The Use of the Two Ways Shown in the Examples - Using getSouce and getActionCommand, TextField Example, Layouts, The Temperature Conversion Example, The TextAndGraphics Example. 22. Overview of NameSurfer - The Next Assignment, Components and Containers, Listeners for Components, Create a Program Which Extends Program, The ComponentListener Interface, The MusicShop Example Program, The MusicShopDisplay Example Program. 23. Searching, Sorting and Algorithmic Efficiency, Searching, Linear Search, Efficiency of Linear Search, Binary Search, Efficiency of Binary Search, Comparing Search Efficiencies, Sorting, The Selection Sort Algorithm, Efficiency of Selection Sort, The Radix Sort Algorithm. 24. Principles of Good Software Engineering for Managing Large Amounts of Data, Principles of Design, The Collection Hierarchy, Useful Methods of Collection, The FlyTunes Example Program - An Online Music Store, Defining the Song Class, Defining the Album Class, Seeing the Program Run, Considering the Data Structures Needed, Reusing Data - Shallow Copy vs. Deep Copy, The FlyTunesStore Program Code. 25. Defining a Social Network for Our Purposes, See What the Program Needs to Do, The Six Degrees of Separation Phenomenon, Concurrency, A Thread, The Runnable Interface, Creating a Thread, Example Program, Having Shared Data Between Your Threads. 26. Introduction to the Standard Java Libraries, A JAR File, Creating a JAR File, Creating an Applet, Standard Java Programs Without Using the ACM Libraries, Other Resources - Learning More Java.

Programming Abstractions (Stanford University)

Course topics:

1. Introducing C++. 2. Similarity between C++ & Java: - syntax - variable types - operators - control structures, Looking at an Example C++ code: - comment, #include Statements, Global Declarations (constant), Declaring a Function Prototype, The main() Function, Decomposed Function Definition, Example Live Coding: To Calculate the Average, for loop -> a while : Another Purpose of the Same Code, C++ User Defined Data Types: -enums – records, C++ Parameters Passing: - pass by value - pass by reference. 3. C++ Libraries - Standard Libraries, CS106 Libraries, CS106 random.h Library, C++ String Type, Operations on String Type, String Class' Member Functions, C++ string vs Java String, Live Example Code : Working on Strings, CS106 strutils.h Library, C++ String vs C String, Concatenation Pitfall (C++ vs C string cont.), C++ Console I/O. 4. C++ Console I/O, C++ File I/O, Stream Operations, Live Example Coding : Working with Files, Live Coding Continuation: Function to Operate on the Opened File Stream, Passing the File Stream by Reference, Error Function, Class Libraries OO Features, Why OO is So Successful, CS106 Class Library, CS106: Scanner Library, Scanner Client Interface, Client Use of Scanner, Container Classes, Template Containers, Vector Interface. 5. Client Use of Templates, Vector Class, Vector Client Interface, Client Use of Vector, Type-safety in Templates, Grid Class, Grid Client Interface, Client Use of Grid, Stack Class, Stack Client Interface, Queue Class, Queue Client Interface, Client Use of Queue, Nested Templates, Learning a New API, CS106B Library Documentation. 6. More Containers, Map Class, Uses of Map, Map Client Interface, Live Coding Example: Use of Map, More information on Maps, What’s Missing? Iterator Operation Through the Map, Iterating Over the Map, Set Class, Set Client Interface, Live Coding Example : Use of Set, Set Higher-level Operations, Why Set is Different. 7. Seeing Functions as Data: Specific Plot Functions, Generic Plot Function, Back to the Set, Live Coding Example: Use of Set with User Defined Data Types, Client Callback Function, Review of the Classes Seen,5 Using Nested ADTs (Abstract Data Types), Live Coding Example, Recursion, Recursive Decomposition. 8. Common Mistakes Stumbled Upon: 'I'terator, Common Mistakes Stumbled Upon: Concatenating Strings, Solving Problems Recursively, Functional Recursion, Example of Recursion: Calculating Raise to Power, Demo of "Raise to the Power Example" Through Live Coding, Mechanics of What’s Going to Happen in Recursion, More Efficient Recursion, Being Wary of Too Many Base Cases, Recursion & Efficiency, Example: Palindromes, Example: Binary Search, Binary Search Code Walk Through, Choosing a Subset; Choose Code. 9. Thinking Recursively, Procedural vs Functional – Recursion, Fractal Code, Live Demo: Fractal Example, Another Recursive Graphic: Mondrian Art, Random Pseudo-Mondrian and the Code, Hanois Towers : Classic Recursion Example, Tower Code, Live Demo, Permutations, Permute Code, Tree of Recursive Calls. 10. Refresh: Permute Code, Tree of Recursive Calls, Live Demo: Testing with Different Cases, Eliminating Duplicates, Subsets, Subset Strategy, Subset Code, Tree of RecursiveCalls: Subset, Exhaustive Recursion, Recursive Backtracking, Turning Recursive Permute to Backtracking, Permute -> Anagram Finder Code, Decision Problems: 8 Queens, Extension to N Queens. 11. Backtracking Pseudocode, Sudoku Solver, Sudoku Code, Cryptarithmetic, Dumb Solver, Smarter Solver, Looking for Patterns, Introduction to Pointers, Single Pointer Operations. 12. Pointer Movie, Pointer Operations: Code & Pointer Memory Diagrams, Pointer Basics, Pointer and Dynamic Arrays, Use of Pointers, Recursive Data, A Recursive Structure, Live Demo: Working with Linked List, Building the List. 13. Coding with Linked List, Printing the List, Using Recursion to Print List, De-allocating the Memory Used for the Linked List, Watch the Pointers: Prepend Function, Passing Pointers by Reference, Array vs Linked List, Insert in Sorted (order) Linked List, Insert in Sorted Order: Code, Recursive Insert. 14. Algorithm Analysis, Evaluating the Performance, Analysis of Codes: Statement Counts, Another Example (Statement Count Contd.), Comparing Algorithm, Big-O Notation, Big-O to Predict the Time of Execution, Best/Worst/Average Case, Analysis of Recursive Algorithms, Another Example : Towers of Hanoi, A Tabulation for Different Algorithms, Growth Patterns, Application of Algorithm Analysis to Sorting, Selection Sort, Selection Sort Code. 15. Selection Sort, Live Demo: Working/execution of the Code, Selection Sort Analysis, Insertion Sort Algorithm, Live Demo: Working/execution of Insertion Sort, Insertion Sort Analysis, Insertion vs Selection, Quadratic Growth of the Algorithm, Merge Sort, Merge Sort: Working/execution Demo, Merge Sort Code Explanation, Merge Sort Analysis, Quadratic vs Linear Arithmetic, Sort 'Race', Quick Sort Idea. 16. Partitioning for Quicksort, Quicksort Code Working/execution, Quicksort Code, Live Demo: Running Quicksort vs Merge Sort, Bad Split Example, Worst Case Split, What Input has Worst Case for Quick Sort, Live Demo: Running Quicksort vs Merge Sort, Different Input Scenarios, Strategy to Avoid Worst Case Split, Execution Time Tabulation, Towards Generic Functions: Swap, Function Template, Example Live Code, Template Instantiation and its Errors, Sort Template, Client Use of Sort Template. 17. Sort Template with Callback, Supplying the Callback Function, One Last Convenience: Default Callback Function, Why Object Oriented Programming, Class Division, Class Interface in ".h" File, Storage for Objects, Accessing Members of a Class, Class Implementation, Implementing Member Functions, Maintaining Object Consistency, Constructors of a Class, Destructors of a Class, Basic Thoughts on Object Design, Internal vs External Representation: Idea of Encapsulation, Better Representation, ADTs (Abstract Data Types). 18. Abstract Data Types, Wall of Abstraction, Why ADTs?, Live Coding Example: Creating the Vector Class, Private Data Members, Growing Dynamically: Making Space at Runtime, Insert and Remove Functions, Templatizing the Class Created, Including the "template.cpp" - Why? 19. Rules of Template Implementation, Explanation of the Working, Not Allow Member Wise Copy, InsertAt Function, Consequences of Contiguous Memory Being a Disadvantage, Stack Class, The Member Function Definitions, Midterm Post Mortem. 20. Live Coding: Recap of the Vector-based Implementation for Stack, Linked List Implementation for Stack, Live Coding: Linked List Implementation for Stack, Analyzing Push/pop Functions, Queue Implementation, Live Coding: Queue Implementation, Alternative Implementation, Text Editor Case Study, Buffered Class Interface and Buffer Layered on Vector, Live Coding: Text Editor, Evaluate Vector Buffer, Buffer Layered on Stack, Live Demo, Compare Implementations, Buffer as Linked List. 21. Buffer: Vector vs Stack, Buffer as Linked List, Cursor Design, Use of Dummy Cell, Linked List Insert/delete, Linked List Cursor Movement, Compare Implementation, Doubly Linked List, Compare Implementation, Space Time Trade Off, Implementing Map, Simple Map Implementation: Vector, Map as Vector : Performance Implication, A Different Strategy. 22. Map as Vector, A different Strategy: Binary Search Tree, Trees in General, Binary Search Tree for Numbers, Operating on Trees, Tree Traversals at Work, Implementing Map as Tree, Map - getValue(), Important Syntactical Advice, Adding to a BST, Trace treeEnter(), Passing Nodes by Reference, Evaluate Map as a Tree, Impact of the Height of the Tree, Degenerate Trees, What to do About Unbalanced Trees? 23. Pathfinder Demo, Graphs: Examples, Graphs: Explanation, Implementation Strategies, Graph Representation in C++, Nodes and Arcs in C++, Graph Traversals, DFS - (Depth First Search), Trace DfS, BFS - (Breadth First Search), Trace BFS, Graph Search Algorithms, Weighted arcs. 24. Compare Map Implementations, Hashtable Idea, Hash Functions, Hash Collisions, Live Demo: Hashing, Live Coding: Hashing, Hashing Idea : Example in Real World, Hash Table Performance, Compare Map Implementations, Hashing Generic Types, Implementing Set. 25. Lexicon Case Study, Lexicon as Sorted Vector, Lexicon as BST, Lexicon as Hash Table, Summary so Far, Noticing Patterns/repetitions in the Words, Letter Trie, Lexicon as Trie, Dynamic Array of Children, Flatten Tree into Array, Exploiting Prefixes and Suffixes, DAWG: Directed Acyclic Word Graph, Lexicon as DAWG, The Final Result, Cool Facts about the DAWG. 26. Thinking About Design, Runtime Performance, Memory Used, Code Complexity, Making Tradeoffs, Array vs Vector, Stack/Queue vs Vector, Set vs Sorted Vector, Pointer-based vs. Contiguous Memory, CS106B MVPs, Pointers, To Remember Years from Now, After CS106B, considering.cs. 27. Guest Lecturer: Keith Schwarz, About the C++ Language, Quick History of C++, C++ Philosophy, C++ Without genlib.h, A Working genlib.h Replacement, Other CS106 Headers, strutils.h, simpio.h, random.h, graphics.h/extrgraph.h, What about ADTs?, Standard Template Library, STL Algorithms, Language Features, Operator Overloading, What Next?

Programming Paradigms (Stanford University)

Course topics:

1. Languages and Paradigms Taught - C++ vs. Pure C, Procedural Paradigm vs. Object-Oriented Paradigm, Assembly, Concurrent Programming Overview, Example of Data Sharing Issues with Concurrent Programming, Scheme, Functional Paradigm Overview, Python Overview, Benefits and Common Uses. 2. C/C++ Data Types - Interpretations, Sizes, Bits- How Bytes are Broken Up into Bits, Breaking Up a Character's Decimal Value into its Underlying Bit Structure, Shorts - Interpreting Data that Consists of More Than One Byte, Representations of Negative Numbers, The Sign Bit, Two's Complement Addition, Converting Between Chars and Shorts, How the Bit Representation is Transferred, Converting Between ints and shorts, Sign Extending During Conversion, Floats, Converting Between Integers and Floats. 3. Converting Between Types of Different Sizes and Bit Representations Using Pointers, Little Endian vs. Big Endian, Structs: How the Data of a Struct is Stored, Accessing the Data of a Struct, Arrays, Pointer Arithmetic on Arrays, Result of Casting Arrays to Different Types, Layout in Memory of Structs, Dynamically Allocated Strings in C vs. Arrays of Characters, Modifying Internal Data of Structs Using strcpy, Character Arrays and cout, Generic Functions in C Using Memory and Pointers. 4. Creating a Generic Swap Function for Data Types of Arbitrary Size, Void* Type for Generic Pointers, Implementation of Swap Function Using memcpy, Client Interface to Generic Swap Function, Pros and Cons of C Generics vs. C++ Generics, Errors Resulting from Improper Use of C Generic Swap Function that Compile, Swapping Pointers, Pitfalls when Swapping Pointers Using Generics, Implementing a Generic Linear Search, Implementing a Generic Linear Search, Using Casts and Pointer Arithmetic, Comparing Memory Blocks Using memcmp or a Comparison Function. 5. Generic Lsearch - Prototype, Comparison Function, Implementation, Casting Void*S to Char*S to Compute Byte Offsets, Client Use of Generic Lsearch, Example of a Comparison Function for Integers, More Complicated Data Types and Lsearch- Example Using C-Strings, Comparison Function for Two C-Strings, With Arguments that Represent Char**S, Comparison Functions Where the Key is a Different Type than the Second Argument, Using a Pointer to a Struct as a Key in Order to Access Additional Data in a Comparison Function, Functions Vs. Methods, C Data Structures - Implementing a Non-Generic Stack of Integers, C Stack Interface, Implementation, Preallocating Memory, Client Use of C Stack, State of Internal Memory of the Stack, Growth of Memory when Stack Becomes Too Large, Implementation of Stacknew, Asserts. 6. Integer Stack Implementation - Constructor and Destructor, Stackpush Implementation, Reallocation of Memory when Stack Grows Too Big Using Realloc, How Memory is Copied Using Realloc, Stackpop Implementation, Reimplementing the Stack Interface as a Generic Data Structure, Generic Implementation of StackNew, Generic Implentation of Stackpush Using Memcpy, Stackgrow Implementation, Static (Internal) Functions, Generic Stackpop Implementation Using Memcpy, Where it is the Responsibility of the Caller to Allocate the Memory Where the Popped Element is Stored. 7. Problems with Ownership of Memory, How Default Implementation of Stackdispose Does Not Free Dynamically Allocated Data, Adding a Free Function to the Stack Implementation, Rewriting Stackdispose to Incorporate It, Writing a Free Function for a Stack of C-Strings, Pitfalls When Writing Such Functions, C Library Functions for Assignment 3 - Memmove (Memcpy That Can Copy Using Two Regions That Overlap), Example of Rotate Function, C Qsort Function, Global Layout of Memory - Stack Segment, Heap Segment, How the Heap Manager Allocates And Frees Memory on the Heap, Underlying Linked List of Free Node Information. 8. Heap Management - How Information about Allocations are Stored in the Heap, Result of Freeing Memory Improperly, Actual Sizes of Heap Allocations - Nearest Power of 2, Management of Free Blocks on the Heap by Storing Addresses in the Blocks of Free Memory, Algorithms for Choosing Which Free Block to Allocate, How the Heap's Free List Can Be Updated When Memory is Freed, How Adjacent Free Blocks Are Combined To Avoid Fragmentation, Compacting the Heap By Using Handles, Stack Segment Layout, Allocation of Local Variables on the Stack by Decrementing the Stack Pointer, Activation Records and State of the Stack Pointer During Nested Function Calls, Assembly Code and the Code Segment, RAM, Registers, and the ALU, Example That Demonstrates How an Arithmetic Expression is Translated Into Register Operations. 9. How a Code Snippet is Translated into Assembly Instructions, Store, Load, and ALU Operations, Assembly Optimizations for 4-Byte Addresses, Context-Insensitive Code Translation, Overriding the 4-Byte Default in Assembly Instructions, Translating a For Loop into Assembly, Using Branch Instructions and the PC Register, Pointer/Array Arithmetic in Assembly, Unconditional Branch Instructions (Jumps), How a 4-Byte Assembly Instruction is Encoded in Memory. 10. More Detail about Activation Records - Layout of Memory During a Function Call, How the Return Address of a Function is Stored on the Stack, Example Showing How an Activation Record is Constructed on the Stack, Setting Up Function Parameters on the Stack, Using the Call Instruction to Jump to the Function, Cleaning Up at the End of a Function and Using the RET Instruction and the Saved Return Address to Return to the Original Function, General Layout of an Activation Record, Who Sets Up Each Part of the Activation Record, Assembly Code Translation of the Factorial Function, How Recursion Translates into Assembly, Why Registers Need to be Reloaded After Other Functions Are Called, Animation Demonstrating the Assembly Execution for the Factorial Function. 11. Moving from C Code Generation to C++ Code Generation: Basic Swap Example, Code Generation for the Pointer Swap Function, Code Generation for the C++ Version Of Swap Using References, Which Are Treated as Automatically Dereferenced Pointers, Local Variables Declared as References, Difference Between References and Pointers, Effect Of Declaring a Class on Memory in the Stack, Class Methods, Which Take a "This" Pointer as An invisible First Parameter, Effect Of the "This" Pointer on the Activation Record for a Class Method, Static Class Methods (Standalone Functions), Which Don't Contain a "This" Pointer, Compilation and Linking - #Define and the Preprocessor. 12. Preprocessing Commands - #Define as a Glorified Find and Replace, Preprocessing Macros - Preprocessor Commands With Arguments, Example of Macro Usage in the Vector assignment to Calculate the Address of the Nth Element, Assert Macro Implementation, How Asserts are Stripped Out for the Final Product Using #Ifdef and #Define, C Macro Drawbacks When Given More Complex Arguments, #Include as a Search and Replace Operation, < > Vs. " ", Output to the Compiler After Preprocessing, How to View the Output of the Preprocessor Using Gcc, How to Avoid Circular #Include Loops Using #Ifndef, #Define, and #Endif, Visual Representation of the Result of Preprocessing (The Translation Unit) that Is Passed to the Compiler to Create a .O File, An Example Illustrating the Preprocessing and Compilation of a Simple Program. 13. Review of Compilation Process of a Simple Program Into a .O File, Effect of Commenting Out a C Standard Library .H File on the Resulting Translation Unit, How Gcc Infers a Prototype When None Is Found and the .O File Remains the Same, How the Gcc Linker Is Able to Link Standard Library Files Without a #Include, The (Similar) Result When the .H File with Malloc's Prototype Is Not Included, How Commenting Out Assert.H Creates Different Results, Failing In the Linker Since Assert Is a Macro, As Opposed to a Function In the Standard Libraries, Effect of Calling Strlen with the Wrong Number of Arguments on the Compilation/Linking Process, Effect of Calling Memcmp with too Few Arguments on the Compilation/Linking Process, How C++ Disambiguates Between Different Function Prototypes to Avoid the Problems Posed By the Previous Two Examples, Debugging Information - Seg Faults (Usually Dereferencing a Bad Pointer) Vs. Bus Errors (Dereferencing Data that Isn't Correctly Aligned), Debugging Example Where Overflowing an Integer Array Leads to an Infinite Loop, Similar Example with a Short Array that Works Differently on Big-Endian Systems Vs. Little-Endian Systems, Example Where an Array Overflow Overwrites the Saved PC and Leads to an Infinite Loop. 14. xample in Which Writing Past the End of Array Causes the Return Address of the Function to be Overwritten, Leading to An Infinite Loop, Example in Which Data Is Incorrectly Shared between Two Different Functions, But Can Still be Printed Out Due to the Structure of the Activation Record (Channelling), How Printf's Prototype Uses "...", Which Allows It to Take A Variable Number of Arguments, Why Parameters Are Pushed Onto the Stack From Right to Left, in the Context of Printf Crawling Up the Stack And Functions With A Variable Number of Arguments, Justification For Structs' Fields being Laid Out Sequentially in Memory, in Terms of Casting between Different Structs With Similar Internal Structures, Sequential Programming Vs. Concurrent Programming, Example of Many Different Processes Running in Separate Virtual Address Spaces, Each Mapped to Physical Addresses by A Central Memory Management Unit, How Concurrent Programming (Multiprocessing) Allows Mutiple Processes to Seemingly Run At the Same Time, How Multithreading Allows Multiple Functions in Run 'Simultaneously' Within One Process (E.G. the office Assistant in Microsoft office Or Downloading Songs in Itunes), Real-World Situation that Can be Modeled Using Threads (10 Ticket Agents Simultaneously Selling 150 Tickets). 15. Transitioning from Sequential Programming to Concurrent Programming in the Ticket Sale Example, Problems with the Sequential Model, Threading Interface, Rewriting the Ticket Example to Use It, Adding a Randomized Threadsleep Call to the Threads to Make the Time Slices Used by the Different Threads Less Uniform, Sample Output of Our Ticket Threads, How a Thread Can be Interrupted in the Middle of a Nonatomic Operation, How Multithreading Can Drastically Speed Up the RSS News Reader by Allowing Some Feeds to be Loaded While the Other Feeds Are Blocked, Allowing Each of the Ticket Threads to Access A Global Pool of Tickets, Rather than Allocating 15 Tickets to Each Agent, How This Can Lead to Problems When Threads Attempt to Access the Shared Data Simultaneously, How We Can Prevent This from Happening By Enclosing the Critical Region within A Semaphore, the Semaphorewait And Semaphoresignal Functions, Modifying the Selltickets Function to Use the Semaphore to Protect the Shared Data, How Changing the initial Value of the Semaphore Can Create Deadlock or Allow Too Many Threads to Access the Shared Data At Once. 16. Review of Semaphore Syntax, Semaphoresignal and Semaphorewait, Semaphore Usage in the Multithreaded Selltickets Function (Protecting a Critical Region), Example of a Race Conditions Where Two Ticket agents Sell the Same Ticket, How the Stack and Various Registers are Saved When the Currently Running Thread Is Swapped, Another Example Using Semaphores that Models the internet, Implementations of a Reader and Writer Thread, Potential Dangers When the Two Threads Run Without Protection, Using a Fullbuffer Semaphore and an Emptybuffer Semaphore To Ensure that Neither Thread Outpaces the Other, Different Semaphore Patterns - Binary Lock Vs. Rendezvous, Effect of Changing the Starting Values of the Emptybuffers and Fullbuffers Semaphore, How To Detect Deadlock, Changes in the Thread Synchornization When Using Multiple Readers and Writers, Dining Philosopher Problem - Modeling Each Philosopher as a Thread, How Deadlock Can Result, How the Deadlock Can be Eliminated by Limiting the Number of Philosophers that Can Eat at Once. 17. Review of the Dining Philosopher Problem, Modeling Each Philosopher as a Thread, How Deadlock Can Result, How Deadlock Can be Eliminated By Limiting the Number of Philosophers That Can Eat at Once Using a Semaphore, Using a Global Variable and a Binary Lock to Track a Resource Vs. Using a Semaphore, Another Threading Example Involving FTP Downloads of Multiple Files at Once, Where Each File Is Assigned to a Thread and the Total Number of Bytes Is Returned, Implementing a Downloadhelper Function That Downloads a File and then Uses a Binary Lock to Safely Update the Total Number of Bytes Downloaded, Ensuring that the Downloadallfiles Function Does Not Return Before All the Files Have Been Downloaded by the Threads Which It Spawns by Using a Childrendone Semaphore, Ensuring that the Downloadallfiles Function Does Not Return Before All the Files Have Been Downloaded by the Threads Which It Spawns by Using a Childrendone Semaphore, How the Childrendone Semaphore Ensures that the Function Returns at the Correct Time, No Matter How the Various Threads Are Interleaved, Setting Up the Ice Cream Store Concurrency Example for Next Week. 18. Guest Lecturer, Setup of the Ice Cream Store Problem, with Customer, Cashier, Clerk, and Manager Threads, The Different Constraints on the Various Types of Threads, Writing the Main Function, Spawning the Various Threads, Handling the Manager-Clerk Interaction Using the Inspection Struct, Which Uses a Semaphore to Signal to the Manager That the Clerk Is Ready for Inspection, As Well as a Semaphore that Ensures that the Clerk Will Wait for the Inspection to Finish, Writing the Manager Function, Which Performs Each of the Inspections and Signals When Each one Is Finished, Writing the Clerk Function, Which Makes Cones Until the Manager Inspects and Approves One; Why an Additional Semaphore Must Be Added That Protects the Manager Function, Why Each of the Semaphores Introduced So Far Is Needed, Writing the Customer Thread's Function, Which Spawns Clerk Threads to Deliver its Ice Cream Cones and Then Waits Until They Are All Finished, Creating and Protecting the Line Struct, Which Is Used to Keep Track of the Customers Waiting for the Cashier in Order, Writing the Cashier Thread's Function, Which Checks Out Each Person Waiting in Line in Order, Waiting if Needed. 19. Imperative/Procedural Paradigms (C) and Object-Oriented Paradigm(C++), Introduction to the Functional Paradigm (Scheme), Which Is Based on Synthesizing the Return Values of Functions, Example of a Scheme Function Definition that Converts Celsius to Fahrenheit, Scheme Environment (Kawa) Details, Scheme Primitives, Scheme Lists, Expressing Functions and Function Calls as Lists, Function Examples: <, >, and, Scheme List Operations: Car and Cdr, Distinguishing Between Lists and Functions with ', Origin of the Names "Car" and "Cdr", The Cons Function, Which Constructs a New List by Prepending the First Argument to the Second Element (Which Must Be a List), The Append Function, Which Concatenates Two Or More Lists, Defining Our Own Add Function, "Define" as an Operation in Scheme with Side Effects, Run-Time Error Checking in Scheme, Writing a Recursive Function that Sums All of the Numbers in a List. 20. Car-Cdr Recursion Problem that Returns the Sum of Every Element in a List of Integers, How Scheme Checks Type During Run-Time Rather than Compilation, Recursive Implementation of the Fibonacci Function in Scheme, Example that Illustrates Runtime Error/Type Checking Vs. Compile-Time Error/Type Checking, Writing a Recursive Flatten Function that Removes All the Intervening Parentheses from a List, Using a Cond Structure to Branch Over the Various Recursive Cases in the Flatten Function, Using the Else Statement to Make Sure that Cond Always Returns Something, Writing the Sorted? Function for a List of Integers, Using the Or Function to Handle the Base Case Logic And Cadr As Shorthand for the Second Element, Using < And <= With Multiple Arguments in Scheme, Function Pointers in Scheme, How Function Data Is Stored Like a Linked List in Scheme And Function Names Are Linked to Code in a Symbol Table, Generalizing the Sorted? Function By Passing in a Comparison Function as the Second Parameter. 21. Introduction to the Kawa Development Environment: Evaluation of Expressions, Loading Function Definitions From a .Scm File, Mapping Arbitrary Unary Functions Over Lists in Scheme Using the Map Operation, Mapping List Functions (Car, Cdr) Over Lists of Lists, Using Mapping Functions with More than One Input by Passing Multiple Lists into Map, Implementing the Unary Version of Map Using Recursion, Apply, Which Allows You to Specify a Function to Be Prepended to a List of Arguments and Be Evaluated, and Eval, Which Evaluates a List as Though it Were Typed into the Commandline, Using Apply to Implement an Average Function Wihtout Recursion, How Eval Can Be Used to Apply Non-Functions Like 'And' and 'Define' to a List, or to Evaluate a Complicated Expression Created While the Program Is Running, Revisiting Flatten Using Map and Apply, Writing a Flatten Implementation That Maps Itself Over Each of its Elements and Appends Each of the Results Together Using Apply, Implementing a Translate Function, Which Shifts Each Point in a List of Points by a Certain Delta, How a Typical Mapping Function Is Not Usable Because of its Need for Client Data, Using the Lambda Function to Define a Nameless Function On the Fly, Which Can Access the Delta Value Since it Is Constructed within the Translate Function, Defining Functions within Functions as an Alternative to Using Lambda, How the Define Keyword Implicitly Uses the Lambda Keyword to Associate a Name with a Function. 22. Writing a Recursive Power Set Function in Scheme, Using a Lambda Mapping Function that Cons-Es the Car to Every Element in the Power-Set of the Cdr to Make the Recursive Step in the Power-Set Function, Using a Let Binding to Cause Power-Set to Only Make One Recursive Call Rather than Two, Structure of a Let Binding, How Expressions Within a Let Binding Cannot Depend On Each Other Unless the Let* Keyword Is Used, How a Let Binding Is Compiled to the Evaluation of a Lambda Expression, Writing a Permute Function, Which Prints Out a List of All Permutations of a Given List, Writing a Permute Function, Which Prints Out a List of All Permutations of a Given List, Writing the Overall Algorithm For the Permutation Function, Which Maps a Function Over Each Element in the List that Produces Each Permutation Starting With that Element, then Appends the Results Together, Writing the Mapping Function For the Permute Function, Which Maps Another Function (That Simply Conses the Current Element) to Each Permutation of the List of Elements when the Current Element Is Removed, Coding Without Side Effects and Immutability of Lists in Scheme, Memory Allocation in Scheme and the Read-Eval-Print Loop, How Integers, Strings, and Lists Are Laid Out in Memory when They Are Typed into the Scheme Command Line. 23. Scheme Memory Model - How Scheme Instructions Synthesize Linked Lists Behind the Scenes and Perform Operations on Them, Two Different Ways of Laying Out A List In Memory, One With Memory Aliasing and One Without, The Scheme Equivalent of "..." (Functions With Multiple Arguments), Writing A Generic Map Function, Modifying the Unary-Map Function to Handle Multiple Arguments By Adding A . to the List of Arguments, Extending Unary-Map to An N-Ary Map Implementation Using ., Sample Trace of the N-Ary Map Function, Garbage Collection In Scheme, How Care Must Be Taken When Reclaiming Global Variables to Ensure That They Won't Be Needed Later, High-Level Mechanics of Garbage Collection: Reference Counts, or Sweeping Through the Data and Marking All Reachable Data, Then Freeing the Rest, Other Functional Languages: Scheme, ML, Haskell, Erlang. 24. Overarching Features of Python: Scripting Language, Imperative, Object-Oriented, Functional, More Python Overview - Dynamic Typing, Use of Whitespace and Tabs, Python Environment, Execution of Basic Statements, Calling Methods Using Objects (And Anonymous Objects Like String Literals), Evaluating Assignments, Python Strings, String Methods, and Lists/Sublists (Including Index Wrapping), Strings as Lists of Characters in Python, Replacing Characters Within a List, Mutable Lists Vs. Immutable Lists, Writing the Gatherdivisors Function, Which Lists All the Divisors of the inputted Numbers: Function/Line Syntax (Incl. Tabs), for Loop Syntax and Iterables, Using and Importing Python Modules, Python Dictionaries, Adding and Retrieving Data from Dictionaries, How Heterogeneous Data Is Allowed inside Dictionaries, Look Ahead: Python Libraries, More About Dictionaries. 25. Rewriting RSG to Illustrate all Three Paradigms and Lambdas in Python, How Objects Are Implemented in Python, Python Dictionary Implementation, Writing an RSG Grammar in Python Using A Dictionary and Lists, Expanding the Start Terminal Using all Three Paradigms at Once, Changing the Expand Function to A Binary Function, Modifying the Map to Use A Python Lambda Function As A Result, Python Object Model From A Memory Standpoint, How Objects Are Passed By Reference and How Lists Are Copied, How to Make A Deeper Copy of an Object in Python Using Copy or Deepcopy, Objects and Classes in Python, How They Are Stored As Dictionaries, Example of A Class Constructor and How it Creates Initializes the Class's Data, Rest of the Python Lexicon Implementation, Python Object Interface, Accessing the Underlying Dictionay of an Object, Inserting New Values into an Object's Underlying Dictionary. 26. XML Processing and Python - Two Different XML Processing Models, Example XML Fragment, How an XML Parser Uses Tag Handlers to Break Up an XML Stream, How Python Can Parse XML Streams Using Urlopen, Make_Parser, and Contenthandler, Defining a Listfeedtitles Function that Takes in a URL and Parses it Using a Parser and an Rsshandler, Contenthandler Interface, Implementing The Rsshandler Class, Which Subclasses Contenthandler, to Fit The Specific Goals of The RSS Feed Reader, Implements The Rsshandler So that it Only Prints Data that Lies Within a Title Tag, Looking at an Actual RSS Feed in Firefox and Through Telnet, Looking at an XML Document with a Tree-Based XML Renderer Rather Than a Stream-Based Parser, Advantages of this Approach. 27. Guest Lecturer: Sasha Rush, Haskell History, Safeguards in Haskell that Avoid Runtime Errors, Expressive Functions in Haskell, Speed of Haskell, Haskell Fibonacci Sequence in One Line Using Lazy Evaluation, How Lazy Evaluation Allows if Statements, Haskell Types, User-defined Data Types, Representing the Null Type in Haskell, List Types, Strings as Lists and Recursive Type Definitions, List Functions and Pattern Matching, Type Variables and Functions, Recursive Map Function, Reasons for the Lack of Object-oriented Code in Haskell, How to Get a Job Using Haskell, Three Functions that are Easier to Write in Haskell.

Natural Language Processing (Stanford University)

Course topics:

1. Why NLP Is Difficult? The Hidden Structure Of Language, Why NLP Is Difficult: Newspaper Headlines, Machine Translation, Machine Translation History, Centauri/Arcturan Example. 2. Questions That Linguistics Should Answer, Machine Translation (MT), Probabilistic Language Models, Evaluation, Sparsity, Smoothing, How Much Mass To Withhold? 3. Finish Smoothing From Last Lecture, Kneser-Ney Smoothing, Practical Considerations, Machine Translation (Lecture 3), Tokenization (Or Segmentation), Statistical MT Systems, IBM Translation Models. 4. Review Statistical Mt, Model 1, The Em Algorithm, Em And Hidden Structure, Em Algorithm Demonstration In Excel Spreadsheet, Assignment 1. 5. IBM Model 1-2 (Review), IBM Model 3, IBM Model 4, IBM Model 5, Mt Evaluation, Bleu Evaluation Metric, A Complete Translation System, Flaws Of Word-Based Mt, Phrased-Based Stat-Mt. 6. Continue Of Machine Translation, Syntax-Based Model, Information Extraction & Named Entity Recognition, Information Extraction, Named Entity Extraction, Precision And Recall, Naive Bayes Classifiers. 7. Continue Of Naive Bayes Classifier, Joint V.S. Conditional Models, Features, Examples, Feature-Based Classifiers, Comparison To Naïve-Bayes, Building A Maxent Model. 8. Details Of Maxent Model, Maxent Examples, Convexity, Feature Interaction, Classification, Smoothing, Inference In Systems. 9. MEMM, Hmm Pos Tagging Model, Summary Of Tagging, NER, Information Extraction And Integration, Landscape Of IE Tasks, Machine Learning Methods, Relation Extraction, Clustering. 10. Parsing, Classical NLP Parsing, Two Views Of Linguistic Structure, Attachment Ambiguities, A Simple Prediction, What Is Parsing?, Top-Down Parsing, Bottom-Up Parsing, Parsing Of PCFGs. 11. Chomsky Normal Form, Cocke-Kasami-Younger (CKY) Constituency Parsing, Extended CKY Parsing, Efficient CKY Parsing, Evaluating Parsing Accuracy, How Good Are PCFGs?, Improve PCFG Parsing Via Unlexicalized Parsing, Markovization. 12. Guest Lecturer: Dan Jurafsky, Syntactic Variations Versus Semantic Roles, Some Typical Semantic Roles, Two Solutions To The Difficulty Of Defining Semantic Roles, PropBank, FrameNet, Information Extraction Versus Semantic Role Labeling, Evaluation Measures, Parsing Algorithm, Combining Identification And Classification Models, Summary. 13. Lexicalized Parsing, Parsing Via Classification Decisions: Charniak (1997), Sparseness & The Penn Treebank, Complexity Of Lexicalized PCFG Parsing, Complexity Of Lexicalized PCFG Parsing, Overview Of Collins’ Model, Choice Of Heads, The Latest Parsing Results, Parsing And Search Algorithms. 14. Parsing As Search, Agenda-Based Parsing, What Can Go Wrong?, Search In Modern Lexicalized Statistical Parsers, Dependency Parsing, Naïve Recognition/Parsing, Discriminative Parsing, Discriminative Models. 15. Why Study Computational Semantics?, Precise Semantics. An Early Example: Chat-80, Programming Language Interpreter, Logic: Some Preliminaries, Compositional Semantics, A Simple DCG Grammar With Semantics, Augmented CFG Rules, Semantic Grammars. 16. An Introduction To Formal Computational Semantics, Database/ Knowledgebase Interfaces, Typed Lambda Calculus, Types Of Major Syntactic Categories, Adjective And PP Modification, Why Things Get More Complex, Generalized Quantifiers, Representing Proper Nouns With Quantifiers, Questions With Answers!, How Could We Learn Such Representations? 17. Lexical Semantics, Lexical Information And NL Applications, Polysemy Vs Homonymy, WordNet, Word Sense Disambiguation, Corpora Used For WSD Work, Evaluation, Lexical Acquisition, Vector-Based Lexical Semantics, Measures Of Semantic Similarity. 18. uestion Answering Systems And Textual Inference, A Brief (Academic) History, Top Performing Systems, Answer Types In State-Of-The-Art QA Systems, Semantics And Reasoning For QA, The Textual Inference Task, Why We Need Sloppy Matching, QA Beyond TREC.

Machine Learning (Stanford University)

Course topics:

1. The Definition of Machine Learning, The Overview of Supervised Learning, The Overview of Learning Theory, The Overview of Unsupervised Learning, The Overview of Reinforcement Learning. 2. An Application of Supervised Learning - Autonomous Deriving, ALVINN, Linear Regression, Gradient Descent, Batch Gradient Descent, Stochastic Gradient Descent (Incremental Descent), Matrix Derivative Notation for Deriving Normal Equations, Derivation of Normal Equations. 3. The Concept of Underfitting and Overfitting, The Concept of Parametric Algorithms and Non-parametric Algorithms, Locally Weighted Regression, The Probabilistic Interpretation of Linear Regression, The motivation of Logistic Regression, Logistic Regression, Perceptron. 4. Newton's Method, Exponential Family, Bernoulli Example, Gaussian Example, General Linear Models (GLMs), Multinomial Example, Softmax Regression. 5. Discriminative Algorithms, Generative Algorithms, Gaussian Discriminant Analysis (GDA), GDA and Logistic Regression, Naive Bayes, Laplace Smoothing. 6. Multinomial Event Model, Non-linear Classifiers, Neural Network, Applications of Neural Network, Intuitions about Support Vector Machine (SVM), Notation for SVM, Functional and Geometric Margins. 7. Optimal Margin Classifier, Lagrange Duality, Karush-Kuhn-Tucker (KKT) Conditions, SVM Dual, The Concept of Kernels. 8. Kernels, Mercer's Theorem, Non-linear Decision Boundaries and Soft Margin SVM, Coordinate Ascent Algorithm, The Sequential Minimization Optimization (SMO) Algorithm, Applications of SVM. 9. Bias/variance Tradeoff, Empirical Risk Minimization (ERM), The Union Bound, Hoeffding Inequality, Uniform Convergence - The Case of Finite H, Sample Complexity Bound, Error Bound, Uniform Convergence Theorem & Corollary. 10. Uniform Convergence - The Case of Infinite H, The Concept of 'Shatter' and VC Dimension, SVM Example, Model Selection, Cross Validation, Feature Selection. 11. Bayesian Statistics and Regularization, Online Learning, Advice for Applying Machine Learning Algorithms, Debugging/fixing Learning Algorithms, Diagnostics for Bias & Variance, Optimization Algorithm Diagnostics, Diagnostic Example - Autonomous Helicopter, Error Analysis, Getting Started on a Learning Problem. 12. The Concept of Unsupervised Learning, K-means Clustering Algorithm, K-means Algorithm, Mixtures of Gaussians and the EM Algorithm, Jensen's Inequality, The EM Algorithm, Summary. 13. Mixture of Gaussian, Mixture of Naive Bayes - Text clustering (EM Application), Factor Analysis, Restrictions on a Covariance Matrix, The Factor Analysis Model, EM for Factor Analysis. 14. The Factor Analysis Model,0 EM for Factor Analysis, Principal Component Analysis (PCA), PCA as a Dimensionality Reduction Algorithm, Applications of PCA, Face Recognition by Using PCA. 15. Latent Semantic Indexing (LSI), Singular Value Decomposition (SVD) Implementation, Independent Component Analysis (ICA), The Application of ICA, Cumulative Distribution Function (CDF), ICA Algorithm, The Applications of ICA. 16. Applications of Reinforcement Learning, Markov Decision Process (MDP), Defining Value & Policy Functions, Value Function, Optimal Value Function, Value Iteration, Policy Iteration. 17. Generalization to Continuous States, Discretization & Curse of Dimensionality, Models/Simulators, Fitted Value Iteration, Finding Optimal Policy. 18. State-action Rewards, Finite Horizon MDPs, The Concept of Dynamical Systems, Examples of Dynamical Models, Linear Quadratic Regulation (LQR), Linearizing a Non-Linear Model, Computing Rewards, Riccati Equation. 19. Advice for Applying Machine Learning, Debugging Reinforcement Learning (RL) Algorithm, Linear Quadratic Regularization (LQR), Differential Dynamic Programming (DDP), Kalman Filter & Linear Quadratic Gaussian (LQG), Predict/update Steps of Kalman Filter, Linear Quadratic Gaussian (LQG). 20. Partially Observable MDPs (POMDPs), Policy Search, Reinforce Algorithm, Pegasus Algorithm, Pegasus Policy Search, Applications of Reinforcement Learning.

Introduction to Robotics (Stanford University)

Course topics:

1. History of Robotics Video, Robotics Applications, Related Stanford Robotics Courses, Lecture and Reading Schedule, Manipulator Kinematics, Manipulator Dynamics, Manipulator Control, Manipulator Force Control, Advanced Topics. 2. Spatial Descriptions, Generalized Coordinates, Operational Coordinates, Rotation Matrix, Example - Rotation Matrix, Translations, Example - Homogeneous Transform, Operators, General Operators. 3. Homogeneous Transform Interpretations, Compound Transformations, Spatial Descriptions, Rotation Representations, Euler Angles, Fixed Angles, Example - Singularities, Euler Parameters, Example - Rotations. 4. Manipulator Kinematics, Link Description, Link Connections, Denavit-Hartenberg Parameteres, Summary - DH Parameters, Example - DH Table, Forward Kinematics. 5. Summary - Frame Attachment, Example - RPRR Manipulator, Stanford Scheinman Arm, Stanford Scheinman Arm - DH Table, Forward Kinematics, Stanford Scheinman Arm - T-Matrices, Stanford Scheinman Arm - Final Results. 6. Instantaneous Kinematics, Jacobian, Jacobians - Direct Differentiation, Example 1, Scheinman Arm, Basic Jacobian, Position Representations, Cross Product Operator, Velocity Propagation, Example 2. 7. Jacobian - Explicit Form, Jacobian Jv / Jw, Jacobian in a Frame, Jacobian in Frame {0}, Scheinman Arm, Scheinman Arm - Jacobian, Kinematic Singularity. 8. Scheinman Arm - Demo, Kinematic Singularity, Example - Kinematic Singularity, Puma Simulation, Resolved Rate Motion Control, Angular/Linear - Velocities/Forces, Velocity/Force Duality, Virtual Work, Example. 9. Intro - Guest Lecturer: Gregory Hager, Overview - Computer Vision, Computational Stereo, Stereo-Based Reconstruction, Disparity Maps, SIFT Feature Selection, Tracking Cycle, Face Stabilization Video, Future Challenges. 10. Guest Lecturer: Krasimir Kolarov, Trajectory Generation - Basic Problem, Cartesian Planning, Cubic Polynomial, Finding Via Point Velocities, Linear Interpolation, Higher Order Polynomials, Trajectory Planning with Obstacles. 11. Joint Space Dynamics, Newton-Euler Algorithm, Inertia Tensor, Example, Newton-Euler Equations, Lagrange Equations, Equations of Motion. 12. Lagrange Equations, Equations of Motion, Kinetic Energy, Equations of Motion - Explicit Form, Centrifugal and Coriolis Forces, Christoffel Symbols, Mass Matrix, V Matrix, Final Equation of Motion. 13. Control - Overview, Joint Space Control, Resolved Motion Rate Control, Natural Systems, Dissipative Systems, Example, Passive System Stability. 14. PD Control, Control Partitioning, Motion Control, Disturbance Rejection, Steady-State Error, PID Control, Effective Inertia. 15. Manipulator Control, PD Control Stability, Task Oriented Control, Task Oriented Equations of Motion, Operational Space Dynamics, Example, Nonlinear Dynamic Decoupling, Trajectory Tracking. 16. Compliance, Force Control, Dynamics, Task Description, Historical Robotics, Stanford Human-Safe Robot, Task Posture and Control, Multi-Contact Whole-Body Control.

Haskell Symposium 2008 Videos

- Lightweight monadic regions by Oleg Kiselyov and Chung-chieh Shan
- A Library for Light-weight Information-Flow Security in Haskell by Alejandro Russo, Koen Claessen and John Hughes
- Haskell Session Types with (Almost) No Class by Riccardo Pucella and Jesse Tov
- SmallCheck and Lazy SmallCheck: automatic exhaustive testing for small values by Colin Runciman, Matthew Naylor and Fredrik Lindblad
- Not All Patterns, But Enough - an automatic verifier for partial but sufficient pattern matching by Neil Mitchell and Colin Runciman
- Yi - An Editor in Haskell for Haskell (Demo) by Jean-Philippe Bernardy
- Haskell, Do You Read Me? Constructing and composing effcient top-down parsers at run-time by Marcos Viera, Doaitse Swierstra and Eelco Lempsink
- Shared Subtypes: Subtyping recursive parametrized algebraic data types by Ki Yung Ahn and Tim Sheard
- Language and Program Design for Functional Dependencies by Mark Jones and Iavor Diatchki
- Making Monads First-class with Template Haskell by Pericles Kariotis, Adam Procter and William Harrison
- Comparing Libraries for Generic Programming in Haskell by Alexey Rodriguez, Johan Jeuring, Patrik Jansson, Alex Gerdes, Oleg Kiselyov and Bruno C. d. S. Oliveira
- CLASE: Cursor Library for A Structured Editor by Tristan O. R. Allwood, Susan Eisenbach
- Haskell Status Report by Simon Marlow

Interview with Simon Peyton Jones on Programming Languages and Research Work

O'Reilly's Open Source Convention - OSCON - in 37 minutes

Here is everyone shown in the video:

Larry Wall, Randal Schwartz, Chris DiBona, Adam Keys, Kevin Scaldeferri, Akkana Peck, John Goerzen, David 'Lefty' Schlesing, Clinton Nixon, Chris Messina, Brian Sam-Bodden, Rod Cope, Jesse Vincent, Darren Hoch, Joey Stanford, Nick Barcet, Gavin Doughtie, Jim Brandt, Ben Bleything, Theo Schlossnagle, Wen Huang, Robert 'r0ml' Lefkowitz, Ryan Briones, Matt Raible, Doug Judd, Vik Olliver, Steve Souders, Clint Talbert, Tim O'Reilly, Leslie Hawthorn, Nathan Torkington, Jacob Kaplan-Moss, Damian Conway, Simon Willison, Dan Mosedale, Jason Hunter, Tim Bray, David Recordon, Scott Kveton, Stephen Lau, Danese Cooper, Anthony Baxter, ongallery, Maker Media, and Edd Dumbill.

What is Cloud Computing?

Video info:

At the Web 2.0 Expo, "What is Cloud Computing?" was asked to Tim O'Reilly, Dan Farber, Matt Mullenweg, Jay Cross, Brian Solis, Kevin Marks, Steve Gillmor, Jeremy Tanner, Maggie Fox, Tom McGovern, Sam Lawrence, Stowe Boyd, David Tebbutt, Dave McClure, Chris Carfi, Vamshi Krishna and Rod Boothby.

Have fun watching all these programming videos! Until next time.

Don't forget to check out the right menu bar for more lectures!

Related Posts

- Free Computer Science Video Lecture Courses

(Courses include web application development, lisp/scheme programming, data structures, algorithms, machine structures, programming languages, principles of software engineering, object oriented programming in java, systems, computer system engineering, computer architecture, operating systems, database management systems, performance analysis, cryptography, artificial intelligence) - Computer Science Lectures

(Courses include higher computing (intro to theory of computation), intro to computer science, data structures, compiler optimization, computers and internet, intro to clojure, the akamai story, cryptography, EECS colloquium videos at Case Western Reserve University) - Programming Lectures and Tutorials

(Lectures include topics such as software engineering, javascript programming, overview of firefox's firebug extension, document object model, python programming, design patterns in python, java programming, delphi programming, vim editor and sqlite database design) - Programming, Networking Free Video Lectures and Other Interesting Ones

(Includes lectures on Python programming language, Common Lisp, Debugging, HTML and Web, BGP networking, Building scalable systems, and as a bonus lecture History of Google) - More Mathematics and Theoretical Computer Science Video Lectures

(Includes algebra, elementary statistics, applied probability, finite mathematics, trigonometry with calculus, mathematical computation, pre-calculus, analytic geometry, first year calculus, business calculus, mathematical writing (by Knuth), computer science problem seminar (by Knuth), dynamic systems and chaos, computer musings (by Knuth) and other Donald E. Knuth lectures) - More Mathematics and Theoretical Computer Science Video Lectures

(Includes algebra, elementary statistics, applied probability, finite mathematics, trigonometry with calculus, mathematical computation, pre-calculus, analytic geometry, first year calculus, business calculus, mathematical writing (by Knuth), computer science problem seminar (by Knuth), dynamic systems and chaos, computer musings (by Knuth) and other Donald E. Knuth lectures) - Computer Science Courses

(Includes introduction to computer science and computing systems, computational complexity and quantum computing, the c programming language, multicore programming, statistics and data mining, combinatorics, software testing, evolutionary computation, deep learning, data structures and algorithms and computational origami.)

## 5 Comments:

Thank you very much from me and my family for all the time and effort you put in this site.

- Vasili from Athens, Greece

By Anonymous, at Sun Oct 05, 08:43:00 PM 2008

Thank you for your monthly posts.

It could be nicer to have the course topics in numerical oredered lists.

Great Job anyway

Marco

(from Italy)

By Anonymous, at Mon Oct 06, 06:03:00 PM 2008

Thank you for creating this blog, thanks for all your advice, your blog and Woopra and positive comments keeps me motivated. Thank you once again.

By Joon Kang, at Thu Oct 23, 10:31:00 AM 2008

wow ! this page is a favorite on my browser. Thank you so much for your efforts. its really ppl like you who confirm my belief in the usability of internet. thanx.

By vaib, at Wed Mar 04, 04:39:00 PM 2009

Many many thanks for this posts. This will help a lot of programmer like me.

By Anonymous, at Tue Mar 24, 12:14:00 PM 2009

Post a Comment

<< Home