Lessons
CS 124 daily lessons mix text, interactive walkthroughs, video content, and small practice and homework problems.
Each one brings you one step closer to mastering the basics of computer science and programming. And the course staff will accompany you every step of the way, to ensure that you are not alone.
Fall 2023
11/29/2023: Hashing
This lesson explores hashing, a mysterious and yet incredibly useful idea that is even included directly in our programming language!
11/28/2023: MP Debugging Part 1
As we continue with the MP, let's review additional debugging strategies that may come in handy.
11/17/2023: GET /course/ Redux
Let's return to our MP2 GET /course/ method and discuss some improvements.
11/16/2023: Binary Search
Let's apply some of the same ideas we've developing sorting to a new problem, search.
11/15/2023: Quicksort
Next we'll continue on to examine Quicksort, a new sorting algorithm with some very interesting characteristics. Then we'll review the sorting algorithms that we've learned together.
11/14/2023: Merge Sort
We'll continue in this lesson by examining Merge Sort, an interesting and efficient sorting algorithm.
11/13/2023: Sorting Algorithms
This lesson begins our examination of sorting algorithms, which represent both a conceptual and an implementation challenge.
11/10/2023: MP2: Course Activity
To wrap up MP2, we'll add support for viewing details about a single course to our app.
11/09/2023: Practice with Recursion
Let's get some additional practice with trees and recursion!
11/08/2023: MP Debugging Part 0
Before continuing with MP2, let's stop for some targeting MP debugging practice. We'll talk about some strategies for fixing common mistakes with your project that we'll begin expecting you to have completed before coming to the help site.
11/07/2023: MP2: API Client
Continuing with our work on MP2, we'll add support for our new course route to our API client.
11/06/2023: MP2: API Server
To begin MP2, we'll extend our data model and add a route to our API server.
11/02/2023: Trees
This lesson introduce trees, which are both a commonly-used data structure and a great way to get practice with recursion.
11/01/2023: Recursion
This lesson introduces recursion, a powerful new problem-solving strategy.
10/31/2023: MP1: Filtering and Search
As we continue work on MP1, we'll complete a search method and use it to update the UI appropriately.
10/30/2023: MP1: Loading and Sorting
To begin MP1, we'll install the test suites, trace how data flows through our app, and fix how the courses are sorted in the UI.
10/27/2023: Lists Review and Performance
Next we'll continue discussing linked lists and implement a few list methods together.
10/26/2023: Linked Lists
Now for a different take on lists, we'll examine lists that store the position of items using reference linking.
10/25/2023: Algorithms and Lists
This lesson starts the third half of the class, our exploration of data structures, algorithms, and algorithm analysis.
10/23/2023: Getting Started with MP0
Today we'll begin work together on the machine project!
10/20/2023: Lambda Expressions
This lesson explores lambda expressions, a terse way of implementing interfaces using anonymous classes.
10/17/2023: Implementing Interfaces
Next we'll examine how to implement interfaces on our own classes.
10/12/2023: Throwing Exceptions
Let's continue to learn about exceptions by finding out how and when to generate our own errors.
10/11/2023: Catching Exceptions
Next we'll begin learning how to work with exceptions by understanding how to handle them when they occur.
10/10/2023: References and Polymorphism
Let's combine what we know about polymorphism and references to deepen our understanding even further.
10/09/2023: References
Our focus in this lesson is on references, both generally and specifically.
10/06/2023: Data Modeling 2
Next we'll complete another data modeling exercise that pulls together everything that we've learned.
10/05/2023: Equality and Object Copying
What does it mean for two objects to be equal? And how do we copy them? In this lesson we'll find out.
10/04/2023: Polymorphism
This lesson introduces a big new word and a big new idea: polymorphism.
10/03/2023: Inheritance
Our next lesson explores the relationships between classes established through inheritance.
10/02/2023: Data Modeling 1
This lesson puts our new abilities with objects to use modeling a real-world system.
09/29/2023
Next we'll continue understanding Kotlin objects by exploring companion objects.
Next we'll continue understanding Java objects by exploring the static keyword and its implications.
09/28/2023: Encapsulation
In this lesson we'll investigate how to enable encapsulation through visibility modifiers and setters and getters.
09/26/2023: Objects, Continued
Let's continue our discussion of objects by examining object methods.
09/22/2023
Let's explore a bit of programming internals, specifically your code is tranformed before it is executed in a process known as compilation.
Let's explore a bit of programming internals, specifically your code is tranformed before it is executed in a process known as compilation.
09/21/2023: Practice with Collections
Let's get a bit more practice with collections, those basic data structures that are so useful.
09/19/2023: Lists and Type Parameters
Next we'll learn how to use lists, a linear data structure but one that is a bit more useful than the arrays that we've been working with so far.
09/18/2023: Imports and Libraries
This lesson may be the most important of the entire semester, since it shows you how to use other people's code!
09/15/2023: Multidimensional Arrays
This lesson expands our ability to work with sequential data into multiple dimensions!
09/14/2023: Practice with Strings
Let's reinforce what we know about strings by working with a few more problems together!
09/13/2023: null
How many problems can nothing cause? Quite a few! We'll learn more about the nothing that is a huge problem in this lesson.
09/12/2023: Algorithms and Strings
Our next lesson is on algorithms and strings, and gives us a bit more practice with both.
09/08/2023: Functions and Algorithms
In this lesson we'll explore the connections between functions and algorithms.
09/07/2023: Practice with Functions
Let's pause for a bit more practice with functions before we continue our journey together.
09/06/2023: More About Functions
Next we'll continue discussing functions and introduce several common algorithm patterns.
09/05/2023: Errors and Debugging
Let's examine errors, debugging, and maintaining a healthy mindset as you learn to work with computers.
09/01/2023: Functions
As we begin writing algorithms, let's stop and discuss how to organize our code into reusable units called functions.
08/31/2023: Practice with Loops and Algorithms
In this lesson we'll pause for more practice with loops and algorithms, including several chances to get practice solving real problems.
08/30/2023: Algorithms
Next we'll pull together everything we've learned so far and use our new skills to start solving real problems. Or, put another way, we'll start designing algorithms.
08/29/2023: Loops
In this lesson we'll cover our last core computer capability: the ability to repeat something multiple times, very quickly.
08/28/2023: Arrays
Let's learn about our first data structure: arrays, which put data values in order.
08/25/2023: Compound Conditionals
Next we'll examine how to make our conditional statements a bit more complex, allowing us to make more interesting decisions based on data in our programs.
08/24/2023: Conditional Expressions and Statements
One of the things that makes computers so powerful is their ability to make decisions. We'll explore that capability in our programs in this lesson.
08/23/2023: Operations on Variables
Our journey continues as we examine how we can manipulate the data stored by variables in our programs.
08/22/2023: Variables and Types
Let's begin our journey in computer science by presenting two of the basic building blocks of computer programs: variables and data types.