Read-Eval-Print-Loop (REPL)

To interact with the Kotlin system, type “kotlinc” at the command prompt.

The Kotlin system should print out a greeting message and the prompt “>>> ”

$ kotlinc
Welcome to Kotlin version 1.3.50 (JRE 1.8.0_152-b16)
Type :help for help, :quit for quit
>>>

You can now type at the prompt an expression or a statement.
If you type in an expression, the system evaluates the expression.
If it is valid, it prints out the value of the expression.
Otherwise, it prints out an error message.
It then prints out the prompt.
If you type in a statement, the system will try to execute it.
If the statement is valid, the system executes the statement
and possibly prints something out as a side-effect.
If the statement is invalid, the system prints out an error message.
It then prints out the prompt.

Scripting

A script is a text file containing commands to the Kotlin language processor.
A Kotlin script must end in the file extension ‘.kts’
Statements in the script can also be expressions, but unlike in REPL mode the values of the expressions won’t be printed out automatically. If you want to see the values, you have to call the print() or println() function.
Steps to create and run a script:
- use a text editor to edit the script, say named “file.kts”
- run the script by typing
```
$ kotlinc -script file.kts
```

Compilation

Here are the classic steps to develop a Kotlin compiled program:
1. Use a text editor to edit a source file, say named “file.kt”
2. Compile the source file by typing
```
$ kotlinc file.kt
```
  This produces a class file “FileKt.class”.
3. Run the class file by typing
```
$ kotlin FileKt
```
If the compile step (Step 2) or run step (Step 3) above produces an error, you’ll have to go back to the edit step (Step 1) to fix the problem. This edit-compile-run loop is repeated as many times as necessary.
For deployment, you can compile the source to a “.jar” file by typing
```
$ kotlinc -include-runtime -d FileKt.jar file.kt
```
This will produce a jar file named “FileKt.jar” which can be executed by the command
```
$ java -jar FileKt.jar
```

Terms

The name of a source file must end in the ‘.kt’ file extension. It is usually known as the “Kotlin program”. It contains your instructions written in the Kotlin programming language.
Kotlin programs have to be compiled, i.e., translated, to a language for a fictitious machine named the Java Virtual Machine (JVM). The result of the translation is written to a class file.
The name of a class file ends in the ‘.class’ file extension. It contains the ‘bytecode’ instructions, i.e., strings of 0’s and 1’s that are instructions for the JVM, and are equivalent to the Kotlin source program.
A compiler translates a program written in a high-level language into an equivalent machine language program.
The compiler that translates a Kotlin program into the JVM machine language is named kotlinc.
A JVM is usually implemented in software. Though rarely done, it can also be implemented in hardware.
An interpreter takes a program in the JVM machine language and executes it on a real processor.
The interpreter that executes a JVM language program on your processor is named java. When you execute the command “kotlin FileKt” as described in the previous slide, the ‘kotlin’ program sets up some environment variables, then delegates the interpretation of the commands in the file ‘FileKt.class’ to ‘java’.

Anatomy of a Kotlin source file

Here is the standard first Kotlin program.

/* Prints "Hello, World" to standard output. */
fun main() {
    // This is line comment
    println("Hello, World")
}

Each Kotlin statement may optionally be terminated by a semicolon.
In contrast to python programs where indentation matters semantically, a Kotlin program is “free format” except that each statement must end in a newline.
A line comment starts with //. The double slash and everything that follows till the end of the line are ignored by the compiler.
A multi-line comment can span more than one line. It starts with /* and ends with */ and can nest.

Command line arguments

This program shows how to process command line arguments.

/*
 *  Prints "Hi, Bob. How are you?" where "Bob" is replaced by the
 *  command-line argument.
 */
fun main(args: Array<String>) {
    print("Hi, ")
    print(args[0])
    println(". How are you?")
}

Program starts execution with an automatic call to the main function.
The parameter args is an array of strings corresponding to the command line arguments typed in by the user when they invoke the program.

Program errors (bugs)

A mistake in your Kotlin program, called a program error (or bug),
- disrupts the normal progress in the classic program development steps, or
- causes an early or unexpected termination of program execution, or
- causes an incorrect behavior during program execution.
A error can occur during
- compile time
- run time
A special kind of compile-time error is called syntax error. It occurs when your Kotlin program violates some rules of how a Kotlin program should be written. Another kind of compile-time error is called type error. It occurs when a program statement violates some rules of type usage.
A special kind of run-time error is called logic error. It is caused by a mistake in the algorithm and is usually the nastiest kind of bug.

Error examples

Examples of syntax errors:
- using the wrong letter case for a keyword, e.g., writing ‘While’ instead of ‘while’
- unmatched parenthesis, braces, etc.
Example of type error:
- writing
```
"Ho" * 3
```
  thinking it would work like Python.
Examples of run-time errors:
- failing to provide a command line argument when the program expects one
- calling ‘print()’ when a ‘println()’ is needed

Input/Output

An executing program can get its input in two ways.
1. Through the command line arguments
2. Interactively by the user typing at the keyboard
An executing program normally writes its output to the computer screen by calling the print(), or println() function.
Both input and output are in the form of text streams.

Introduction to Kotlin

San Skulrattanakulchai

February 24, 2020

Topics

Running Kotlin

Read-Eval-Print-Loop (REPL)

Scripting

Compilation

Terms

Anatomy of a Kotlin source file

Command line arguments

Program errors (bugs)

Error examples

Input/Output