Project structure and build basics in Kotlin - Step-by-Step Execution

Concept Flow - Project structure and build basics

Start Project

↓

Create folders

↓

Add source files

↓

Configure build file

↓

Run build tool

↓

Compile and package

↓

Build output created

↓

End

This flow shows how a Kotlin project is structured and built step-by-step from folders to build output.

Execution Sample

Kotlin

src/
  main/
    kotlin/
      App.kt
build.gradle.kts

// Build compiles and packages the project

This shows a simple Kotlin project folder with source code and a Gradle build file.

Execution Table

Step	Action	Details	Result
1	Create project folders	src/main/kotlin	Folders ready for source code
2	Add Kotlin file	App.kt with main function	Source code ready
3	Write build script	build.gradle.kts with plugins and dependencies	Build config ready
4	Run build command	./gradlew build	Build process starts
5	Compile source	Kotlin files compiled to bytecode	Class files generated
6	Package output	Create JAR file	Executable JAR created
7	Build finished	No errors	Project ready to run
8	Exit	Build complete	Stop execution

💡 Build completes successfully with compiled and packaged output

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
Project folders	null	src/main/kotlin created	Same	Same	Same
Source files	null	App.kt added	Same	Compiled to class files	Same
Build config	null	null	build.gradle.kts created	Same	Same
Build output	null	null	null	Class files generated	JAR file created

Key Moments - 3 Insights

Why do we need the src/main/kotlin folder?

This folder is the standard place where Kotlin source files go. The build tool looks here to find code to compile, as shown in steps 1 and 2 of the execution table.

What does the build.gradle.kts file do?

It tells the build tool how to compile and package the project. Without it (step 3), the build cannot run properly.

Why is the build output a JAR file?

The JAR file packages compiled code so it can be run or shared easily. Step 6 shows this packaging after compilation.

Visual Quiz - 3 Questions

Look at the execution table, at which step are Kotlin files compiled to bytecode?

A Step 5

B Step 4

C Step 6

D Step 3

💡 Hint

Check the 'Details' column for 'compiled to bytecode' in the execution table.

According to the variable tracker, when is the build.gradle.kts file created?

A After Step 2

B After Step 5

C After Step 3

D At Start

💡 Hint

Look at the 'Build config' row and see when it changes from null.

If the src/main/kotlin folder was missing, what would happen during the build?

A Build would succeed with no source files

B Build would fail because no source code found

C Build would skip compilation

D Build would create an empty JAR

💡 Hint

Refer to the importance of 'src/main/kotlin' in the key moments and execution table steps 1 and 2.

Concept Snapshot

Project structure basics:
- src/main/kotlin holds Kotlin source files
- build.gradle.kts configures the build
- Run './gradlew build' to compile and package
- Output is a JAR file ready to run
- Proper folders and files are essential for build success

Full Transcript

This visual trace shows how a Kotlin project is structured and built. First, folders like src/main/kotlin are created to hold source code. Then, Kotlin files such as App.kt are added. The build.gradle.kts file configures the build process. Running the build command compiles the Kotlin files into bytecode and packages them into a JAR file. The variable tracker shows how project folders, source files, build config, and build output change step-by-step. Key moments clarify why folders and build files are needed. The quiz tests understanding of build steps and project structure. This helps beginners see how a Kotlin project goes from code to runnable output.

Practice

1. Which folder in a typical Kotlin project contains the main source code files?

easy

A. resources/main

B. src/test/kotlin

C. build/libs

D. src/main/kotlin

Solution

1. Step 1: Understand standard Kotlin project folders

   The src/main/kotlin folder is where the main Kotlin source files are placed.

2. Step 2: Differentiate from other folders

   src/test/kotlin is for test code, build/libs is for compiled output, and resources/main is for resource files.

3. Final Answer:

   src/main/kotlin -> Option D

4. Quick Check:

   Main source code folder = src/main/kotlin [OK]

Hint: Main code is always under src/main/kotlin folder [OK]

Common Mistakes:

• Confusing test folder with main source folder
• Thinking build output folders contain source code
• Mixing resource folders with source code folders

2. Which file is commonly used to define build instructions in a Kotlin project using Gradle?

easy

A. settings.gradle

B. build.gradle.kts

C. gradle.properties

D. manifest.xml

Solution

1. Step 1: Identify Gradle build script files

   Gradle uses build.gradle.kts (Kotlin DSL) or build.gradle (Groovy DSL) to define build instructions.

2. Step 2: Differentiate from other Gradle-related files

   settings.gradle configures multi-project builds, gradle.properties holds properties, and manifest.xml is unrelated.

3. Final Answer:

   build.gradle.kts -> Option B

4. Quick Check:

   Build instructions file = build.gradle.kts [OK]

Hint: Build scripts are named build.gradle.kts for Kotlin DSL [OK]

Common Mistakes:

• Confusing settings.gradle with build.gradle.kts
• Thinking gradle.properties contains build logic
• Mixing XML files with Gradle scripts

3. Given this Gradle build snippet, what will be the output directory for compiled Kotlin classes?

kotlin {
    jvmToolchain(17)
}

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
    kotlinOptions.jvmTarget = "17"
}

medium

A. build/classes/kotlin/main

B. src/main/kotlin

C. build/libs

D. out/production

Solution

1. Step 1: Understand Gradle default output folders

   By default, Kotlin compiled classes go to build/classes/kotlin/main for the main source set.

2. Step 2: Differentiate source and output folders

   src/main/kotlin is source code, build/libs holds packaged jars, and out/production is not standard for Gradle Kotlin projects.

3. Final Answer:

   build/classes/kotlin/main -> Option A

4. Quick Check:

   Compiled classes output = build/classes/kotlin/main [OK]

Hint: Compiled classes go under build/classes/kotlin/main by default [OK]

Common Mistakes:

• Confusing source folder with output folder
• Thinking build/libs holds class files instead of jars
• Assuming non-standard output folders

4. You see this error when running Gradle: Could not find method kotlin() for arguments. What is the likely cause?

medium

A. The Kotlin plugin is not applied in build.gradle.kts

B. The source folder is missing

C. The JVM target version is invalid

D. The Gradle wrapper is outdated

Solution

1. Step 1: Understand the error message context

   The error means Gradle does not recognize the kotlin {} block, usually because the Kotlin plugin is missing.

2. Step 2: Check common causes

   Missing plugins { kotlin("jvm") version "x.y.z" } causes this error. Source folder or JVM target issues cause different errors. Outdated Gradle wrapper usually causes version incompatibility errors.

3. Final Answer:

   The Kotlin plugin is not applied in build.gradle.kts -> Option A

4. Quick Check:

   Missing Kotlin plugin causes kotlin() method error [OK]

Hint: Check if Kotlin plugin is applied when kotlin() method errors occur [OK]

Common Mistakes:

• Assuming source folder missing causes this error
• Blaming JVM target version without checking plugin
• Ignoring plugin application in build script

5. You want to add a new resource folder to your Kotlin project for configuration files. Where should you place it to follow standard Gradle project structure?

hard

A. src/resources/main

B. resources/config

C. src/main/resources

D. config/resources

Solution

1. Step 1: Recall standard resource folder location

   Gradle expects resource files in src/main/resources to include them in the build output.

2. Step 2: Differentiate from incorrect folder structures

   Folders like resources/config, src/resources/main, or config/resources are not standard and won't be automatically included.

3. Final Answer:

   src/main/resources -> Option C

4. Quick Check:

   Resource files go under src/main/resources [OK]

Hint: Put resource files in src/main/resources for Gradle to find them [OK]

Common Mistakes:

• Placing resources outside src/main folder
• Using non-standard folder names
• Not including resources in build output