# Lessons

learncs.online lessons mix text, interactive walkthroughs, video content, programming exercises, and debugging challenges.

Each one brings you one step closer to understanding the fundamentals of computer science and programming.

## Lessons

### 0:Hello, world!

Welcome to learncs.online! We're excited to join you as you start your journey in computer science and programming. Today!

### 1: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.

### 2:Operations on Variables

Our journey continues as we examine how we can manipulate the data stored by variables in our programs.

### 3: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.

### 4: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.

### 5:Arrays

Let's learn about our first data structure: arrays, which put data values in order.

### 6:Loops

This lesson covers our last core computer capability: the ability to repeat something multiple times, very quickly.

### 7:Algorithms I

Now 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.

### 8:Practice with Loops and Algorithms

Let's pause for more practice with loops and algorithms, including several chances to get practice solving real problems.

### 9:Functions

As we begin writing algorithms, let's stop and discuss how to organize our code into reusable units called functions.

### 10:Errors and Debugging

Let's examine errors, debugging, and maintaining a healthy mindset as you learn to work with computers.

Next we'll continue discussing functions and introduce several common algorithm patterns.

### 12:Practice with Functions

Let's pause for a bit more practice with functions before we continue our journey together.

### 13:Functions and Algorithms

In this lesson we'll explore the connections between functions and algorithms.

### 14:Strings

Let's meet a new type of data and our first example of an object.

### 15:Algorithms and Strings

This lesson is on algorithms and strings, and gives us a bit more practice with both.

### 16: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.

### 17:Practice with Strings

Let's reinforce what we know about strings by working with a few more problems together!

### 18:Multidimensional Arrays

Our next lesson expands our ability to work with sequential data into multiple dimensions!

### 19:Imports and Libraries

This lesson may be the most important of the entire course, since it shows you how to use other people's code!

### 20: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.

### 21:Maps and Sets

Let's look at two more very useful collections: maps and sets.

### 22:Practice with Collections

Let's get a bit more practice with collections, those basic data structures that are so useful.

### 23

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.

### 24:Introduction to Objects

This lesson begins a new topic: objects.

### 25:Objects, Continued

Let's continue our discussion of objects by examining object methods.

### 26:Constructors

Our next lesson examines what happens when objects are created.

### 27:Encapsulation

Next we'll investigate how to enable encapsulation through visibility modifiers and setters and getters.

### 28

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.

### 29:Data Modeling 1

This lesson puts our new abilities with objects to use modeling a real-world system.

### 30:Inheritance

Our next lesson explores the relationships between classes established through inheritance.

### 31:Polymorphism

This lesson introduces a big new word and a big new idea: polymorphism.

### 32: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.

### 33:Data Modeling 2

Next we'll complete another data modeling exercise that pulls together everything that we've learned.

### 34:References

Our focus in this lesson is on references, both generally and specifically.

### 35:References and Polymorphism

Let's combine what we know about polymorphism and references to deepen our understanding even further.

### 36:Catching Exceptions

Next we'll begin learning how to work with exceptions by understanding how to handle them when they occur.

### 37:Throwing Exceptions

Let's continue to learn about exceptions by finding out how and when to generate our own errors.

### 38:Working with Exceptions

This lesson continues our practice with exceptions.

### 39:Using Interfaces

Let's take the first step to understanding interfaces.

### 40:Implementing Interfaces

Next we'll examine how to implement interfaces on our own classes.

### 41:Practice with Interfaces

This lesson continues our practice with interfaces.

### 42:Anonymous Classes

Let's dive in to the world of anonymous classes.

### 43:Lambda Expressions

This lesson explores lambda expressions, a terse way of implementing interfaces using anonymous classes.

### 44:Algorithms and Lists

Our next lesson starts the third half of the class, our exploration of data structures, algorithms, and algorithm analysis.

Now for a different take on lists, we'll examine lists that store the position of items using reference linking.

### 46:Lists Review and Performance

This lesson continues discussing linked lists and implement a few list methods together.

### 47:Recursion

This lesson introduces recursion, a powerful new problem-solving strategy.

### 48:Trees

Next we'll introduce trees, which are both a commonly-used data structure and a great way to get practice with recursion.

### 49:Trees and Recursion

Let's continue practicing with trees and recursion!

### 50:Practice with Recursion

Let's get some additional practice with trees and recursion!

### 51:Sorting Algorithms

This lesson begins our examination of sorting algorithms, which represent both a conceptual and an implementation challenge.

### 52:Merge Sort

We'll continue in this lesson by examining Merge Sort, an interesting and efficient sorting algorithm.

### 53: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.

### 54:Binary Search

Let's apply some of the same ideas we've developing sorting to a new problem, search.

### 55:Hashing

This lesson explores hashing, a mysterious and yet incredibly useful idea that is even included directly in our programming language!

### 56:Implementing a Map

This lesson is short and fun. Let's combine what we know about hashing, arrays, and linked lists to implement our own map.

### 57:Generics

Next we introduce a language feature that allows us to write both general and type-safe code.

### 58

This lesson explores map-reduce-filter collection processing patterns, which are well-supported by Kotlin and useful for performing transformations on data.

This lesson explores streams, an advanced programming pattern useful for performing transformations on data.

### 59:Graphs

In this lesson we'll introduce graphs, another commonly-used data structure and another great way to practice with recursion.

### 60:Graph Algorithms

Let's continue our exploration of graphs by exploring algorithms that operate on them.