var i = 0

println(i)

i++

println(i)

var j = 10

i = i + j

j = i - j

println("$i $j")

Next we’ll continue introducing the basic building blocks of our computer programs.
We’ll show how you can *manipulate* the data stored by your variables through simple mathematical operations.

Reminder: Variables

In the last lesson we introduced variables, which allow us to store changing values as our program runs.
We looked at how to *declare* and *initialize* those variables.
The declaration tells Kotlin the name and type of the variable we are going to use, and the initialization sets the variable’s first value:

// Dear Kotlin: I'm going to use a variable named catsAge to store integer values

// And I'd like its initial value to be 6

var catsAge: Int = 6

And, normally we don’t need to include a type when we initialize the variable, since Kotlin can figure it out on its own:

// Dear Kotlin: I'm going to use a variable named catsAge

// I'd like its initial value to be 6

// Based on that value, you can guess that I'm using it to store integer values!

var catsAge = 6

If you’re having any trouble understanding variables, please review the previous lesson.

Comments

Before we continue, we need to introduce one new piece of Kotlin syntax: *comments*.
Comments allow us to include descriptive text in our programs.
Comments are *completely* ignored by the computer!
They are entirely for the humans who write, read, and maintain the code.

Kotlin supports two types of comment:

// This is a single line comment. It starts with //

/*

This is a multi-line comment. It starts with the two-character symbol on the line above.

And it ends with the two-character symbol on the line below.

*/

Single-line comments are good when you have something short to say about something in your code.
Multi-line comments that start with `/*`

and end with `*/`

are better when you have more to say and need to write one or more paragraphs.

**Even though comments are ignored by the computer, they are essential to writing good computer code.**
We’ll use comments frequently in our examples, and show you how you can use them to outline a plan for completing more complex programming tasks.

Computers can do basic math, quickly and with near-perfect accuracy. This is one of the many things that makes them so useful.

Your friend wrote a simple function intended to save the area of a room in a variable called area given its width and height stored in int variables width and height. Unfortunately, their code has a small error. Go ahead and fix it for them! (Note that you do not need to declare or modify width and height. But you should declare and set area.)

var area = width + height

Modifying Variables

Now that we can store data in our programs we can harness the next fundamental computer superpower: *math*.
Computers can do math, quickly and with (near) perfect accuracy.
Many of the operations that we can perform on variables are mathematical in nature:

var i = 10 * 20

Variables can also be set based on the value of *other* variables:

var i = 10

var j = 20

var k = i + j

Understanding Variable Assignment

Some of you, particularly those with a mathematical bent, may be alarmed by certain lines of Kotlin code. Like this one:

var i = 10

i = i + 1

println(i)

In math, the statement on the second line is non-sensical.
Regardless of the value of `i`

, it can never *equal* itself plus one—nonsense!

The source of the confusion here is the `=`

symbol.
In Kotlin, a *single* `=`

does *not* indicate or test equality.
It indicates **assignment**.
We use it when we want to *assign* a value to a variable.

To further the confusion, assignments in Kotlin are evaluated from *right* to *left*.
So they are neither math nor English!
That’s why the example above works.

Let’s examine this assignment carefully together:

var i = 1

i = i + 1

println(i)

Computers can do basic math, quickly and with near-perfect accuracy. This is one of the many things that makes them so useful. Particularly when computing something important, like your grade!

Your grade in CS 124 is based on three components, which are already stored in `Double`

variables: `quizScore`

,
`homeworkScore`

, and `mpScore`

, each as numbers between 0 and 1.
Quizzes, homework, and the MP are worth 40%, 30%, and 30% of your grade, respectively.
A course staff member wrote the following method to calculate your grade as a percentage between 0 and 100.
However, it has a small mistake which you will want to correct!

val grade = 30 * quizScore + 30 * homeworkScore + 30 * mpScore

Self-Modification Shortcuts

It’s fairly common in our programs to want to modify the value of a variable but start with its current value. For example:

var dollars = 0

// Call parents

dollars = dollars + 100

// Phew...

println(dollars)

These types of operations are common enough that there are a few shortcuts that you can use:

var dollars = 0

// Call parents

dollars += 100

// Phew...

println(dollars)

Similarly you can use `-=`

, `*=`

, and `/=`

.

Finally, adding and subtracting *by one* are so common that they even have an additional set of shortcuts:

var dollars = 0

// Call parents

dollars += 1

// WTF?

println(dollars)

// Call parents again

dollars++

println(dollars)

// ...

Similarly you can use `++`

and `--`

.

Binary Negation

What we’ve been covering in this lesson are known as *operators*.
(We’ve covered at least a few of the ones listed in the linked reference. We’ll
get to more soon!)
Many of them are for working with numbers, since, to a computer, everything *is* a number.

But there is one operator that we use to work with `boolean`

values:

var isCS124Awesome = false

println(isCS124Awesome)

// Extra credit?

isCS124Awesome = !isCS124Awesome

println(isCS124Awesome)

Computers can do basic math, quickly and with near-perfect accuracy. This is one of the many things that makes them so useful. Particularly when computing something important, like your grade!

Your grade in CS 124 is based on three components, which are already stored in `Double`

variables: `quizScore`

,
`homeworkScore`

, and `mpScore`

, each as numbers between 0 and 1.
We also add a few points of extra credit, stored in an `Int`

variable `extraCredit`

.
Quizzes, homework, and the MP are worth 40%, 30%, and 30% of your grade, respectively.
A course staff member wrote the following method to calculate your grade as a percentage between 0 and 100.
However, it has a few small mistakes which you will want to correct!
(Don't forget to include the extra credit!)

val grade = 30 * quizScore + 30 * homeworkScore + 30 * mpScore

Course Design: Frequent Assessment

CS 124 is designed to give every student a chance to succeed. Below we explain one unusual aspect of the course. You can find more information on the syllabus.

**CS 124 does not hold a final exam.**
Or a midterm.
Or any high-stakes assessments.

High-stakes assessments like midterms and final exams encourage and reward cramming, which does not lead to knowledge retention. Infrequent assessment also allows students to go long periods of time without engaging with the content. We want you studying a small amount every day. So we assign a daily homework problem, and have you take a weekly quiz.

Frequent small assessment may be *the* most important component of student success in CS 124.
We could fill pages about all of the benefits of this approach^{(1)}.
When you study, you learn.
Preparing for CS 124 quizzes will solidify your knowledge.
Taking the quizzes will test your understanding, and provides important feedback for both you and us about what you know.

When you do poorly on a quiz, you have time to catch up, and should expect us to reach out to help as well. Many small quizzes means that each is less stressful, and allows you to recover from a bad assessment. It also allows us to implement learning-focused grading policies, including dropping low scores and catch-up grading.

Homework Problem

As a reminder, CS 124 now allows students to collaborate freely on the homework problems. Please see the syllabus for more details.

Computers can do basic math, quickly and with near-perfect accuracy. This is one of the many things that makes them so useful. Particularly when computing something important, like your grade!

Your grade in CS 124 is based on four components, which are already stored in `Double`

variables: `quizScore`

,
`homeworkScore`

, `mpScore`

, and `extraCredit`

.
`quizScore`

, `homeworkScore`

, and `mpScore`

will be between 0 and 1.
`extraCredit`

will be between 0 and 0.1.
Quizzes, homework, and the MP are worth 50%, 20%, and 30% of your grade, respectively.
Extra credit should be added directly to the result.
A course staff member wrote the following method to calculate your grade as a percentage.
However, it has a few small mistakes which you will want to correct!

val grade = 60 * quizScore + 10 * homeworkScore + 30 * mpScore

CS People: Alan Turing

As we teach you the basics of computer science and programming, we’re also going introduce you to computer science *people*—the humans behind technology’s remarkable achievements.
Note that we include a few questions on each quiz on these short videos, so don’t skip them!

The name Turing comes up a lot in computer science.
There’s the *Turing machine*, an abstract model of a machine that, despite its simplicity, can compute any algorithm^{(2)}
There’s the *Turing test* to determine whether a machine can be distinguished from a human.
And there’s the Turing Award—computer science’s highest honor, and its equivalent of the Nobel Prize.

But who was Alan Turing, and why did his life end tragically at the age of only 41? Watch the video below to find out more.

Note that the British Government formally apologized to Alan Turing—but not until 2009, 55 years after his death.

Need more practice? Head over to the practice page.