Lessons

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.

11: More About Functions

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 semester, 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.

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.

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.

45: Linked Lists

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.

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.