Kotlin is the programming language used to make Android apps. This course is 
the easiest way to learn Kotlin even if you have never coded before.

In this section you will learn the following:
 - What is Kotlin
 - Your first lines of code
 - Basic knowledge about variables
 - How to use this course


Learn what programming is all about in this super fast introduction!

Hello and welcome to our free online course "Introduction to programming".
In this course you will learn the basics of programming with `Kotlin`.

### What is kotlin?

**Kotlin** is the main programming language used to create most **Android** apps.
Once you have learned the basics of Kotlin you can **start** with Android **app development**.
Also all these basic concepts can be applied to any other programming language.

It's especially similar to `Swift`, the language used to make iOS apps.
This makes it easy to switch later on!

### Learning by doing

During this course each lesson will consist of some explanation,
we try to keep it as short and sweet as possible. And then
a lot of **practical exercises**.

We believe it's best to learn coding by **doing**. So lets **start**
with your first program!

Welcome

Every programming instruction starts with a "Hello world" program.
The purpose of this program is to make the computer say: `Hello world`

Take a look at the code. If you press the **"Run code"** button
the program will be executed. After a successful execution
the output is displayed underneath the code.

Run the code to see the output!


Hello world

Let's take a closer look at the program we just ran. It's a very simple
program. Only 3 lines!

![A simple program](/course-assets/3416582587636046.jpg?width=1600&height=880)

No need to worry about `fun main` yet. We'll explain that later in
the course. For now just remember that all code you write has to 
be within the curly braces `{}`

### println

This program writes `"Hello world"` to the output. It's doing so using
the `println()` function. `println()` is short for **print line**
As you might expect given the name, it will print 1 line of text 
to the output followed by a return/enter. 
The text to print is given between the brackets `()`

After the program is executed, everything 
written to the output will be displayed underneath the code.


Hello world explained

In the code you see the `Hello world` program again. For this
exercise you will have to **modify it** to give the correct output.

To edit the program simply select the text you want to change
and start typing.

### Assignment
Change the **output** of the program by changing the text between
the **double quotes ("...")**. Can you make it say:

```
Hello kotlin!
```

### Tips
 - Programs are **case sensitive** so make sure the **output** 
matches exactly.


Your turn

The **println** function can be used as much as you want. Everytime
you use it, it will print a new line to the output.

Can you make a program that writes 2 lines?
The output should look like this:
```
first
second
```
### Tips
 - Use the **println** function multiple times for each line you want to print.
Scroll back up to the previous exercise if you forgot the **syntax**.
 - Make sure you didn't forget any quotes `"` or brackets `()`. In this case all outputs should be lowercase.


Printing multiple lines

Programming can be confusing. Sometimes adding some 
extra information to the code can really help to 
understand what's happening.

We can add extra text like that with **code comments**.
Code comments can be extremely useful. In this course we'll
be using them to add extra explanations to the code.
Comments are only for the programmer and are completely 
ignored by the computer.

There are two ways to add a comment:
```
// this is a single line comment

/*
This is a multiline comment
everything between /* */ is a comment.
*/
```

See the code for some examples. As you can see
comments are displayed in green (In this course).

Code comments

You wrote your first lines of code and learned how
to write output! You also learned how to add comments to your code.
Continue to the next lesson to get started with variables.

### Summary
- **Kotlin** is the main programming language used for making Android apps.
- If we want to see the results of a program we have to **run** or **execute** it.
  Both terms can be used interchangeably.
- Every program has a text output channel.
- `println()` is used to write text to the output channel.
- **Code comments** are used to explain programmers what a piece
  of code is for. **Comments** are not executed and the computer ignores them.


Well done

Coding Introduction

Variables are the most basic building blocks of any program.
Learn what variables are and how to create them.

Every program uses information. For example: the name of a user, 
the speed of a car, the altitude of a plane or the result of a 
calculation. Computers store all information of a running program 
in memory. The memory can be seen as a warehouse full of information.
Every piece of information has an address so the computer can quickly
find and access the data it contains. This data can be of various 
types; e.g. a piece of text (or a string in technical terms), a 
number (Integer) or even an image or a video. Computer programs can 
reference the data in memory by using variables.


Variables

To help wrap your head around the concept of variables I'll be using a real world metaphore.
Lets say our computer is a Cocktail bar and we want to pour some drinks!
To pour our drinks we'll need something to hold them. We can see a variable in a program as a kind of glass.
But instead of holding a drink it will hold some kind of data.

### Creating a glass:
So before we can pour a drink we'll need to create a glass.
In code that looks like this:

```
val ginTonicGlass: Cocktail
```

Let's break it down:


![Creating a variable](/course-assets/4772459099611450.jpg?width=1600&height=752)


In programming the **type** (The part after the colon `:`) is very important.
It indicates what **type** of drink the glass can hold. A cocktail glass cannot hold beers or whiskey.
The **type is not** the actual drink, we didn't pour any drinks yet, the **type** just **describes** the glass.
Once we create a glass for cocktails it cannot be used to drink beer.
If we wanted to pour some Beer we need to create a new glass that can hold beer:

```
val beerGlass: Beer
```


What is a variable?

Can you create a **whiskeyGlass** that can hold **Whiskey**?

**Tip:** Make sure you have the capital letters exactly as specified.

Create a variable

In the previous exercise we created some drink glasses (variables). However we didn't
put any drinks in them. Now it's time to pour some actual drinks!

The code to fill a glass looks like this:

```
ginTonicGlass = ginTonic
```

Lets break it down:

![Creating a variable](/course-assets/752787444742335.jpg?width=1600&height=752)

### Values and operators
Programming languages perform simple actions using **operators**. In this case we
use the **assignment `=`** operator to **assign** a **value** to the ginTonicGlass **variable**.
You can think of this as filling the glass with a nice alcoholic beverage.

### The full code:
```
val ginTonicGlass: Cocktail
ginTonicGlass = ginTonic
``` 
On the first line we created a **variable** (Using the `val` keyword). We **named** the 
variable ginTonicGlass (Because it will hold our gin tonic). Since a gin tonic is
cocktail we made sure the **type** of the variable is Cocktail.

On the second line we **assigned** the **value** ginTonic to the **variable**. 
In other words, we poured a nice refreshing G&T in our ginTonicGlass.


Values

Now it's your turn to pour a drink!

- Create a variable **mojitoGlass**. Mojitos are also cocktails so the type should be **Cocktail**.
Or in programming terms: Create a **variable** named **mojitoGlass** with type **Cocktail**.
- On the next line, pour a **mojito** in the glass? 
Or in programming terms: assign the value **mojito** to the **mojitoGlass** variable.
- Use `println()` to print the variable to the output. Example: `println(mojitoGlass)`


Pouring a drink

Check this piece of code and pay attention to the **uppercase** and **lowercase** letters.
```kotlin
val beerGlass: Beer
beerGlass = draftBeer
```
The type of the glass in this code is **Beer**. Notice how it's written with
**uppercase B**. But the name of our variable **beerGlass** started **lowercase b**

This is to make a clear distinction between **variable** names and **type** names.
In kotlin we always write **type** names with the first letter uppercase.
We always write a **variable** name first letter lowercase. If a name
consists of multiple words the words after the first word always start with a capital.
Like `beerGlass` in our example.

So now you know if you see a word with the first letter uppercase it is a type name.
And lower case is a variable name. It's very important to follow this naming convention because it makes your code
easier to read and understand.

### Variable naming
A variable name can be anything you want. But to make it clear it's best to use
descriptive names. 
#### A few examples:

With the name `favoriteDrink` we know that this variable will hold my favorite drink.
```kotlin
val favoriteDrink: Cocktail
```

With this example we know this variable contains the client's drink.
```kotlin
val clientDrink: Cocktail
```

This is bad! We know `a` is of type Cocktail but the name `a` does not tell us anything about what it's for.
```kotlin
val a: Cocktail
```


Capitals and variable names

To get more familiar with what we just learned we're gonna pour some more drinks!
I have some friends coming over and they all want a drink.

- The first one, lets call him friend 1, wants a **draftBeer**
- The second one (friend 2) wants a **mojito**
- Friend 3 wants some **scotch**
- Friend 4 wants a **ginTonic**

Make a glass for each person and fill it with the drinks they want.
Make sure the drinks are served in the correct type of glass! **Cocktail** glasses for the **ginTonic** and the **mojito**.
**Beer** glass for the **draftBeer** and of course a **Whiskey** glass for the **scotch**.

In technical terms: Make 4 variables with the types and values as specified above.

For example:
```
// This beer is for friend 1 so I'm 
// naming the variable accordingly.
val friend1Glass: Beer
// Set the value on friend 1 glass.
friend1Glass = draftBeer
// Make the next glass
val friend2Glass: // etc...
```
After you made the drinks serve them by using **println**
For example:
```kotlin
println(friend1Glass)
println(friend2Glass)
// etc...
```

Some more drinks please

In the previous exercises we learned the most basic concepts around variables.

- Programs use **variables** to store data. We can think of a variable as a glass and the data as the drink inside the glass.
- A **new** variable is created using the `val` keyword.
- The name of a **variable** always starts with a **lowercase** letter.
- We can interact with a variable using the **name** 
- Use **descriptive** variable names
- The **type** of the variable is important because it tells us what type of drinks can be in the glass.
- The name of a **type** always starts with an **uppercase** letter.
- The **value** of a variable is the actual data. Or in other words, the actual drink.
- To set a **value** on a variable we can use assignment `=`. We can think of this as pouring a drink in the glass.
- `=` is an **operator**. Operators perform simple tasks in a program.

Summary

Here are some examples of creating and assigning variables.

Can you tell what's the **value** of ginTonicGlass?

Question 1

Can you tell what the **type** is of the **myGlass** variable?

Question 2

What is the **name** of the variable that can hold a value of type **Beer**

Question 3

Now you know the basics of variables. Continue with the next lesson
to learn some interesting things you can do with them.

All done

Creating variables

Get more familiar with variables, learn another way to create them
and learn how to use numbers to perform basic math. There are also 
some more challenging exercises.


Most programs are not about drinks. This unfortunately means the our
Cocktail data **type** is not very useful... So let's introduce 
a new basic data type that is used in every program:

### Integers

Integers or **Int** can store a **whole numbers without decimals**. 
You know numbers like 1, 2, 3, 10, 56474982, etc. There is also 
functionality to do math but we'll get to that later. For now all 
you need to know is that the data **type** of a number is **Int**.


Basic data types

Remember how we created our Cocktail glass with the type Cocktail?
If not check back to [the lesson on variables](course://day1-variables/creating-variables/what-is-a-variable).

- So you know how to create a **variable** and you know the data 
**type** for numbers is `Int`. Can you put that knowledge 
together and create a new variable called `numberOfDrinksConsumed`?
Make sure you have the upper case letters in the right place!
- Use `println()` to print the `numberOfDrinksConsumed` variable.
Check [here](course://day1-variables/introduction/lets-break-it-down)
if you need a reminder on println.

During this course we already made 12 drinks. So set the **value** of 
our new variable to `12`. If you forgot how to set a value check back
to [the lesson on setting values](course://day1-variables/creating-variables/what-is-a-value).

Counting our drinks

To make some things shorter and easier. Kotlin can also create a 
variable and assign it's value in one go. Like creating a glass and pouring a drink in one go.

For example:
```kotlin
val mojitoGlass: Cocktail
mojitoGlass = mojito
```
Can be written shorter like this:
```kotlin
val mojitoGlass: Cocktail = mojito
```
Both codes have the exact same effect but the second one is shorter.

In fact it can be even shorter because Kotlin is very smart and already knows that a **mojito** is a **value** of **type Cocktail**.
I'll explain later how it knows so much about Cocktails. For now it's enough to know that every **value** has a **type**.

Since Kotlin already knows the **type** of the **value** we want to assign we 
can skip writing it and simply do this:
```kotlin
val mojitoGlass = mojito
```
This will do exactly the same as the earlier examples but it's a lot shorter to write.
In this case kotlin will **infer** the **type** of mojitoGlass by looking at the **type** of mojito.

The same goes for every data type including the **Int** from last exercise.


Create and assign on one line

Use the short version to repeat the previous exercise.
Create new variable named `numberOfDrinksConsumed` using the
`val` keyword and assign the value `12`. Use 1 line and don't specify the type.

Print the variable with `println`


Lets put this into practice

My friends want another round of drinks. Since we now know how to
create and assign in one go we can write the code for that much
faster than last time!

- Friend 1 wants a `scotch`
- Friend 2 wants a `ginTonic`
- Friend 3 wants some `draftBeer`
- Friend 4 wants a `ginTonic`

Make glasses for everyone and fill them with drinks.
Use the one line assignment version this time.

For example:
```
val friend1Glass = scotch
val friend2Glass = // etc...
```
After you made the drinks serve them by using `println`
For example:
```kotlin
println(friend1Glass)
println(friend2Glass)
// etc...
```


Next round of drinks please

Lets explore some new **operators**. We already used the assignment operator
`=` to set a **value** on a variable. Now that we know how to make numbers
we can use the basic math operators to perform sums!

```kotlin
val added = 5 + 7
val subtracted = 6 - 3
val multiplied = 3 * 3
val divided = 8 / 4
```

Every line above performs a simple sum and stores the **result** of that sum in a
variable. I'm assuming you know how to add, subtract, multiply and divide
so these operators should explain themselves.

It's also allowed to use other variables in a sum like this:
```kotlin
val friend1Drinks = 5
val friend2Drinks = 6

// the value of total drinks will be 5 + 6 (The variables added together)
val totalDrinks = friend1Drinks + friend2Drinks
```

We can be creative and mix and match these to create more complicated math:

```kotlin
val friend1Drinks = 5
val friend2Drinks = 2
val friend3Drinks = 12

val average = (friend1Drinks + friend2Drinks + friend3Drinks) / 3
```

The above code calculates the average amount of drinks my friends consume
by adding them together and then dividing by the number of friends.
As you can see you can use the brackets () to specify how the result is calculated.
This works exactly the same as in regular mathematics.

As you can see you can create any kind of complicated math formula 
you want using these basic operators. This is useful if you’re a 
math genius but don’t worry, in most programs the math is not 
much more complex than the examples above.




Some simple math

Now try for yourself. Add `mojitoPrice` and `beerPrice` 
together. Save the result of the calculation in a new variable.

Print the new variable using `println`.

Adding up

Practice your math skills by splitting the bill.
We have 6 friends and a bill of 130.68. Can you make a program that
calculates how much each person has to pay? In other words: Divide 
totalPrice by totalPeople. 

Use `println` to show the result of the calculation.


Split the bill

Lets try a bit more complicated exersice. Calculate the tax
of our bill. The sales tax is 21% of the total price.

Create a new variable named `salesTax` that holds the result of 
the tax calculation and should be 21% of the subTotal. The tax
percentage is already availabe as variable `vatPercent`.
If you forgot your high school math, this is the calculation to get
a percentage: `(number / 100) * percent`

Use println to show the `salesTax`.

Create another variable named `total`. Add `subTotal` and
`salesTax` together to calculate the final price.

Use println to print `total` as well.

If you run the code you will now see the results of the calculations
in the output.

Calculate tax

One more exercise and you're done with this lesson. Calculate the
price of the bill. You already have some variables for the drinks
price and the amount of each drink. To get to total price you'll
have to multiple each drink amount with the drink price and then
add the totals together.

Use println to print the result.

Calculate the total price

In this lesson we learned what a variable is and how to create one.

- We can also create a variable and set a value in one line.
- Kotlin can figure out the type of the variable by looking at the
  value. Because of that, in this case, we don't need to specify the type.
  The variable will still have the type.
- The **Int** data type can be used to store whole numbers.
- We can do math with numbers.
- We can use other variables in sums.

The code contains some examples.

It is recommended to write this down so you can reference this easily later.

Working with variables

Learn four of the basic data types and what you can do with them.
Integers, Doubles, Strings and Booleans.

Kotlin comes with a bunch of handy basic data types out of the 
box. You will use these types in every program you will make.

- Integers
- Doubles
- Strings
- Booleans

There are more basic data types and also a lot to learn about how
each one works. But for now we will keep it to the absolute basics.
Just enough knowledge for you to make something interesting. No worries
we'll go into more detail in future lessons.


About data types

There are a few data types that can hold numbers. Which one you use
depends on how big the number is going to be and if you need Decimals.
For this chapter we will only use 2 of them: Integers, We already
introduced them in the last chapter, and Doubles.

Integers hold whole numbers. Meaning they don't have Decimals.
### Examples:
`1`, `2`, `3`, `10`, `56474982`, etc.
### In code:
```kotlin
val number: Int
number = 200
val otherNumber = 12
```

Integers

- Create a new integer variable using the `val` keyword.
- Assign the value `42`.
- Print the variable using `println()`

Assignment

Doubles hold numbers with decimals.
### Examples:
`1.5`, `3.0`, `456.9948827`, etc.
### In code:
```kotlin
val number: Double
number = 5.0
val otherNumber = 23.734
```

Both integers and doubles function in a similar way and both types can be used
with the basic math operators from the previous exercise.

By the way, you can add a minus `-` sign in front if you want a negative
number. This works for all number types!
```kotlin
val negativeNumber = -200
```



Doubles

- Create a new double variable using the `val` keyword.
- Assign the value `5.0`.
- Print the variable using `println()`

A Boolean has only 2 possible values, `true` and `false`.

### Examples:
`true`, `false`

We can create a boolean in the same way as any other variable
```kotlin
val isTrue: Boolean
isTrue = true
val isFalse = false 
```

You may think, What's the use of this? but this data type is 
actually used a lot in every program! We'll show you how in the 
next chapter.


Booleans

- Create a new boolean variable using the `val` keyword.
- Assign the value `true`.
- Print the variable using `println()`

Pretty much every program uses text. So the next common
data type is called `String`. Strings are simply pieces of text.
It can store everything from a users name, address to very long
things like a whole book. We've already used strings when we
introduced `println()`. That's right, Anything between double
quotes (`"..."`) is a string.

### In code:
```kotlin
val someText: String
someText = "This is a string"
val someOtherText = "Some other string"
```

Strings

- Create a new string variable using the `val` keyword.
- Assign the value `"this is a string"`.
- Print the variable using `println()`

In this lesson we learned about 4 basic data types.
 - Strings `String` are used to hold text.
 - Integers `Int` are used to hold numbers without decimals
 - Doubles `Double` are used to hold numbers with decimals
 - Booleans `Boolean` are used for things that can either be true or false

Day 1. Variables

This chapter is still under development. If you have an account
we will let you know the second it is released!

Day 2. Coming soon

This is an introductory Kotlin course.
- The course will be most beneficial for beginner-level Kotlin learners.
- The course covers core Kotlin features.
- It contains hands-on examples of Kotlin code implementation and exercises to practice new skills.
- The course is based on the author's personal experience in Kotlin development.

Coding with kotlin

Coding Introduction

Day 1. Variables

Day 2. Coming soon