Diagram showing the flow of code evaluation from the editor to the compiler (kotlinc) to the JVM. The box is read at the compiler phase to demonstrate an error

The bytecode is never generated, the JVM is never reached, and finally, our code’s output is not displayed. Assuming we have an error such as this one:

Error.kt:2:25: error: expecting ')'
  println("Hello, World"
                        ^

Until we resolve this error by adding a)and rerunning our code, we will not be able to see any output.

No Kotlin supported IDE? No problem!

In the case that we’re off the Codecademy platform and writing our Kotlin code locally in anIDEwithout a built-in converter between Kotlin and Java code, we can rely on the bash terminal.

The bash terminal is a command language interpreter that has the ability to execute a series of commands contained in a script or program. With Kotlin installed, we can run a series of commands which will manually compile our code, execute it, and display its output. Take a look at how it’s done manually.

Assume we have the following program in aHelloWorld.ktfile:

fun main() {  println("Hello, World!")}
Copy to clipboard

fun main() {  println("Hello, World!")}

In the bash terminal, we can enter the first command to compile our code and save it in a.jarfile:

$ kotlinc HelloWorld.kt -include-runtime -d HelloWorld.jar
Copy to clipboard

$ kotlinc HelloWorld.kt -include-runtime -d HelloWorld.jar

• kotlincrepresents the compiler.
• HelloWorld.ktrepresents the source code file that we need to compile into Java bytecode.
• The-include-runtimeoption results in the.jarfile being runnable by including the Kotlin runtime library within it.
• The.jarextension represents a file format that indicates many Java files zipped into one. When executed, Java can extract and use its information.
• The-dflag specifies the output path for the newly generated class files.

After we’ve hit enter, we can then run our program with the following command:

java -jar HelloWorld.jar

• Thejavacommand launches an application written in Java. It does this by starting the JVM, loading the.classfile, and executing the code within themain()function.
• By specifying the-jarflag, we are instructing Java to execute a program within a.jarfile.

Both commands are used in the Bash terminal and the result, Hello, World!, is outputted.

Note: If we make changes to our code, we’d need to recompile our program and run the above two commands again.

You’ve reached the end of the article - great job! We covered a vast majority of information that gives us insight into what happens after we run our Kotlin code.

We now understand that our Kotlin code needs to be compiled into bytecode before it can be passed on to the Java Virtual Machine which executes the code as instructions. IDEs often automatically compile our code, but if we don’t have that luxury, we can use a bash terminal to manually compile and execute our program. Next time you’re running your code, you’ll know what’s happening from editor to output. And if you want to learn more about how to use your bash terminal, check out ourBash courses.

'The Codecademy Team, composed of experienced educators and tech experts, is dedicated to making tech skills accessible to all. We empower learners worldwide with expert-reviewed content that develops and enhances the technical skills needed to advance and succeed in their careers.'