CS 106B: Programming Abstractions

This course (CS 106B) is the successor to CS 106A and covers more advanced programming topics such as recursion, algorit
Instructed by Stanford University
  • Lectures 18
  • Video 14 Hours
  • Skill level all level
  • Languages English
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android

How taking a course works

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

Learn and practice real-world skills and achieve your goals.

Course Description

This course (CS 106B) is the successor to CS 106A and covers more advanced programming topics such as recursion, algorithmic analysis, and data abstraction. It is taught using the C++ programming language, which is similar to both C and Java. In the past when both CS 106A and CS106B were taught in C/C++, the coupling between the two classes was very tight and it was unheard for students to take CS106B without having completed our CS 106A (we recommended CS 106X instead). Nowadays, some students do go straight into CS106B, this is typically appropriate for a student who done well in an intro programming course (e.g., scored 4 or 5 on the CS AP exam or earned a good grade in a college course) and has sufficient familiarity with good programming style and software engineering issues (at the level of CS 106A) to use this understanding as a foundation on which to tackle advanced topics.

What am I going to get from this course?

  • Over 18 lectures and 14 hours of content!

Curriculum

43:03
The first lecture by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department.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.
43:48
Lecture two by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
44:40
Lecture 3 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
50:27
Lecture 4 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
45:30
Lecture 5 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. In the fifth lecture, 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.
43:01
Lecture 6 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
47:32
Lecture 7 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
42:37
Lecture 8 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
47:48
Lecture 11 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
41:45
Lecture 12 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
51:35
Lecture 13 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
49:33
Lecture 14 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department.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.
47:20
Lecture 15 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
47:35
Lecture 16 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
44:31
Lecture 17 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
50:54
Lecture 18 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department.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.
41:27
Lecture 19 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department. 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.
51:00
Lecture 20 by Julie Zelenski for the Programming Abstractions Course (CS106B) in the Stanford Computer Science Department.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.

Instructor Biography

Reviews

Average Rating
5.0
Details
  1. 5 Stars
    3
  2. 4 Stars
    0
  3. 3 Stars
    0
  4. 2 Stars
    0
  5. 1 Stars
    0

What you get with this course

30 day money back guarantee

Lifetime access

Available on desktop, iOS and Android

Certificate of completion

Join the biggest student community

5,400,000

Hours of video content

21,000,000

Course enrollment

6,300,000

Students

Ready to start learning?
Enroll for free now