Programming Abstractions

Video Lectures

Displaying all 27 video lectures.
Lecture 1
The Significance of Programming
Play Video
The Significance of Programming
Julie Zelenski gives an introduction to the course, recursion, algorithms, dynamic data structures and data abstraction; she also introduced the significance of programming and gives her opinion of what makes 106B "great;" C++ is introduced, too.
Lecture 2
General Syntax
Play Video
General Syntax
Julie describes the similarities between C++ and Java, which include general syntax, primitive variable types, operators and control structures; she proceeds to go through the code of a basic C++ program and explains each individual piece of code, headers, global constants, global data types, and calling functions. She also proceeds to write a simple program during the lecture that gets input from the user and prints a statement to the screen.
Lecture 3
Introduction to C++ Basics
Play Video
Introduction to C++ Basics
Julie goes over C++ libraries and explains what they are and how they are useful. She continues to introduce C++ basics, including strings, various operators on strings and comparing two strings and takes special note that C++ is an 'industrial language' and does not guarantee anything and that the programmer has to be more attentive to finding his/her own bugs.
Lecture 4
Stream Operations
Play Video
Stream Operations
Julie continues to cover the console input/output in C++ and discusses the file I/O and changing between an old style string to a C++ string format. She also begins to go over stream operations and their basic use as well as object oriented programming, and the use of scanner function and containers.
Lecture 5
Template Specialization
Play Video
Template Specialization
Julie discusses the use of templates, vectors and template specialization. She then goes through an example of code line by line explaining each part in detail. Finally, she goes on to explain what grid interfaces are and briefly goes over how you can use them in programming different games.
Lecture 6
Sequential Containers
Play Video
Sequential Containers
In the sixth lecture, Julie discusses sequential containers, associative containers, map classes/interfaces, iteration over maps and set classes. She explains why set classes are different and sometimes better to use.
Lecture 7
Functions
Play Video
Functions
Julie explains the idea of functions as data and specific plot functions and continues onto client feedback functions and ADTs. She then delves into recursion and solving problems using recursion.
Lecture 8
Recursions
Play Video
Recursions
Julie talks about solving problems recursively. She covers functional recursion with the simple example of writing an exponential function using recursion. From the simple program performing as an exponential function Julie continues to show a more efficient recursion code. The next example she covers is that of binary search and how recursion is used in this instance.
Lecture 9
Recursions (continued)
Play Video
Recursions (continued)
Julie goes over recursion and the proper ways to solve problems recursively. She continues with the example of a program that draws a fractal image and explains a Mandarin code to illustrate the different possibilities of drawing different pictures. She then discusses the problem of moving a stack of disks from one peg to the other peg. Later, she demonstrates the basic principle necessary to solve the problem with a child's toy and goes through how to solve the problem with a program.
Lecture 10
Permute Code
Play Video
Permute Code
Julie explains procedural recursion and introduces permute code. She goes through another example of recursive code line by line, explaining each component. Recursive backtracking and it's usefulness are discussed. The example of placing several queen chess pieces on a board where none of them can attack the other is then demonstrated.
Lecture 11
Pointers
Play Video
Pointers
Julie continues with recursive backtracking and introduces pointers and recursive data. Following, she focuses on solving the problems rather than the exact code and later uses the example of a program that will solve a Sudoku puzzle. She explains that recognizing and looking for patterns between all of the different recursive examples is an important component to learning recursion.
Lecture 12
Pointers (continued)
Play Video
Pointers (continued)
Julie continues to go over pointers and moves on to recursive data and linked lists. She starts off explaining the basics of pointers and have two variables pointing to the same address then explains that it is better to not delete the same address more than once, as something not wanted might happen. Julie then explains the interaction between pointers and dynamic arrays.
Lecture 13
Linked Lists
Play Video
Linked Lists
Julie introduces linked lists and continues to discuss recursive data. She goes line by line through an example code she writes during the lecture. She then inserts variables in an order; she uses the example of an address book to explain this. Algorithm analysis are also introduced.
Lecture 14
Algorithm Analysis
Play Video
Algorithm Analysis
Julie starts off with algorithm analysis, the big-O notation and introduces sorting. She begins off with a brief overview of what algorithm analysis is and how to utilize it. Later, she continues to go through recursive algorithms and their uses.
Lecture 15
Sorting
Play Video
Sorting
Julie continues to cover sorting. She begins with an example of a selection sorting code and a graphic demo of the code in progress. Thereafter, she explains the different methods available to sort different kinds of data; she also explains the pros and cons of using quadratic sorting versus linearithmic sorting.
Lecture 16
Sorting (continued)
Play Video
Sorting (continued)
Julie continues with sorting, specifically quadratic and linearithmic sorting methods, and then explains how to reasonably partition data sets for quicksort. Thereafter, she proceeds to go over different functional templates for sorting algorithms and also briefly goes over instantiation errors and how to fix them.
Lecture 17
Sorting Templates
Play Video
Sorting Templates
Julie continues to go over sort templates and callback functions, then shows a final version of the sort template, one that will be extremely useful in the next homework assignment. She also goes over class implementation and its uses as well as time constructors.
Lecture 18
Vectors
Play Video
Vectors
Julie introduces the 'implement vector' and discusses ADTs (abstract data types) in more detail. She then develops a Vector from the ground up, explaining each step as she goes.
Lecture 19
Template Implementers
Play Video
Template Implementers
Julie reiterates the rules for template implementers and continues by coding live with the class explaining each line of code in detail after writing it. Throughout the process of writing the code, she encounters several errors and debugs the code every several minutes. She continues to demonstrate how to write code involving stack.
Lecture 20
Stack and Queue
Play Video
Stack and Queue
Julie continues discussing Vector and moves on to stack and queue, covering chapter ten in the course textbook. She goes over several rules for templates again to reinforce how important they are.
Lecture 21
Linked Link Instertion and Deletion
Play Video
Linked Link Instertion and Deletion
Julie talks about the buffer version of vector vs. stack and follows this with an example of cursor design. She also talks about linked list insertion and deletion. Cursor movement is the next topic covered; she illustrates how the cursor points from one cell to the next.
Lecture 22
Map as a Vector
Play Video
Map as a Vector
Julie discusses map as a vector and describes a different, possibly better, strategy. The basics of trees and their usefulness and how they can be used with binary search is then introduced.
Lecture 23
Solving Problems with Sorting
Play Video
Solving Problems with Sorting
Julie shows a YouTube video of Barack Obama answering a question about what kind of sorting algorithm he would use to sort a list of data. She also gives several examples of problems that are capable of being solved with sorting. She goes on to say that if you think about certain problems as graphs, finding the solution is sometimes easier as well as easier to understand. To be able to do this, she explains how to represent graphs in C++.
Lecture 24
Hashing
Play Video
Hashing
Julie introduces hashing and it's uses in search and retrieval; map implementations and the different kinds of search algorithms are then discussed. Thereafter she explains that logarithmic searches are relatively fast and often finish the search in an immeasurable amount of time. She introduces a different approach to search that works in a faster manner than linear search.
Lecture 25
DAWG Data Structure
Play Video
DAWG Data Structure
Julie examines a case study and opening up the lexicon file, which is complicated; she walks the students through the code and explains why she wrote it as she did as opposed to a sorted vector or binary search tree. She then introduces the DAWG data structure.
Lecture 26
General Review
Play Video
General Review
Julie ties up the "loose ends" of the course: after a general review of the concepts covered in the course, she asks which of two examples is the better. She then covers manipulation of dynamic data structures (lists, trees, graphs) as well as reviews code from similar assignments. Then she touches on design and efficiency of code. Lastly, she goes over the next courses one might take if continuing in computer science and the different paths possible.
Lecture 27
C++
Play Video
C++
In the final lecture, Keith talks about the C++ programming language. He starts of with C++ history, C++ without CS 106 and what comes next.