String concatenation vs templates in Kotlin - Visual Side-by-Side Comparison

Concept Flow - String concatenation vs templates

Start

↓

Define variables

↓

Choose method

↓

Concatenate

↓

Create final string

↓

Print or use string

↓

End

This flow shows how Kotlin creates strings either by joining pieces manually (concatenation) or by embedding variables directly inside a template.

Execution Sample

Kotlin

val name = "Anna"
val age = 30
val concat = "Name: " + name + ", Age: " + age
val template = "Name: $name, Age: $age"
println(concat)
println(template)

This code shows two ways to make a string with variables: joining parts with + and using a template with $.

Execution Table

Step	Action	Expression Evaluated	Result	Output
1	Define name	name = "Anna"	name = "Anna"
2	Define age	age = 30	age = 30
3	Concatenate strings	"Name: " + name + ", Age: " + age	"Name: Anna, Age: 30"
4	Create template string	"Name: $name, Age: $age"	"Name: Anna, Age: 30"
5	Print concatenated string	println(concat)		Name: Anna, Age: 30
6	Print template string	println(template)		Name: Anna, Age: 30

💡 All steps complete, both strings created and printed.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
name	undefined	"Anna"	"Anna"	"Anna"	"Anna"	"Anna"
age	undefined	undefined	30	30	30	30
concat	undefined	undefined	undefined	"Name: Anna, Age: 30"	"Name: Anna, Age: 30"	"Name: Anna, Age: 30"
template	undefined	undefined	undefined	undefined	"Name: Anna, Age: 30"	"Name: Anna, Age: 30"

Key Moments - 2 Insights

Why do both concat and template have the same final string even though they look different?

Both methods combine the variable values with text. Concatenation joins pieces with +, while templates insert variables directly. Execution table rows 3 and 4 show both produce the same string.

What happens if you forget to use $ in the template string?

Without $, the variable name is treated as plain text, not replaced. So the output would show "name" literally. This is shown in step 4 where $name is replaced correctly.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'concat' after step 3?

A "Name: Anna, Age: $age"

B "Name: $name, Age: $age"

C "Name: Anna, Age: 30"

D "Name: $name, Age: 30"

💡 Hint

Check the 'Result' column in row 3 of the execution table.

At which step is the template string created with variables replaced?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the 'Action' and 'Expression Evaluated' columns in the execution table.

If you change 'age' to 31, which variable's value changes in variable_tracker after step 2?

A age

B name

C concat

D template

💡 Hint

Check the 'age' row in variable_tracker after step 2.

Concept Snapshot

Kotlin strings can be made by concatenation or templates.
Concatenation uses + to join strings and variables.
Templates use $variable inside quotes to insert values.
Templates are cleaner and easier to read.
Both produce the same final string output.

Full Transcript

This visual trace shows how Kotlin creates strings using two methods: concatenation and templates. First, variables 'name' and 'age' are defined. Then, 'concat' is made by joining strings and variables with +. Next, 'template' is created by embedding variables directly inside a string using $ syntax. Both strings end up the same. The execution table shows each step, including printing the strings. The variable tracker shows how values change after each step. Key moments clarify why both methods produce the same result and the importance of $ in templates. The quiz tests understanding of variable values and steps.