Forem: Gamya

Understanding Data Types in Python

Gamya — Fri, 01 May 2026 05:46:00 +0000

Python Basics #2 🐍🔥

In the previous article of this Python Basics series, we learned about variables and how Python stores information in memory.

But here’s the thing:

Python doesn’t just store one kind of information.

Sometimes you want to store:

Numbers
Decimal values
Text
True/False conditions
Collections of data
And much more

To handle all of this properly, Python uses something called data types.

Understanding data types is one of the most important steps in becoming comfortable with programming.

And once you truly understand them, writing code becomes way less confusing.

So today, let’s break down Python data types in the simplest way possible — with examples ⚔️

What Is a Data Type?

A data type tells Python what kind of information a variable is storing.

Think of it like character classes in an RPG game.

Different characters have different abilities:

A swordsman attacks differently
A mage uses magic
A healer restores health

Similarly, different data types behave differently in Python.

For example:

power_level = 9000

Python understands this is a number.

But here:

anime_name = "Dragon Ball"

Python understands this is text.

The data type helps Python decide:

What operations are allowed
How memory should be used
How the data should behave

The Main Data Types Beginners Should Know

Today we’ll focus on three important beginner-friendly data types:

Integers (int)
Floating-point numbers (float)
Boolean values (bool)

These are used everywhere in Python projects.

1. Integers (`int`) 🔢

An integer is a whole number with no decimal point.

Examples:

episodes = 1000
score = 95
age = 17

All of these are integers.

Integers can be:

Positive
Negative
Zero

Example:

health = 100
enemy_damage = -25
coins = 0

Example 🎌

Imagine you're creating an anime fighting game.

naruto_clones = 2000

Since shadow clones are counted as whole numbers, Python stores this as an integer.

You can perform calculations with integers too.

goku_power = 9000
goku_power = goku_power + 5000

print(goku_power)

Output:

This is how games and apps constantly update values internally.

Why Integers Matter

Integers are commonly used for:

Scores
Health points
Ages
Inventory counts
Likes on social media
Followers
Levels in games

Basically, whenever you need whole numbers, integers are usually the answer.

2. Floating-Point Numbers (`float`) 🌊

A floating-point number (or simply a float) is a number that contains a decimal point.

Examples:

pi = 3.14
rating = 9.8
temperature = 36.5

Unlike integers, floats can store fractional values.

Why Are They Called “Floating-Point”?

The decimal point can “float” to different positions.

For example:

The decimal point moves around depending on the number.

That’s why they’re called floating-point numbers.

Example ⚡

Imagine tracking a character’s speed multiplier.

speed_multiplier = 1.75

Or maybe an anime rating app:

demon_slayer_rating = 9.4

Floats are perfect for precise values.

Integer vs Float

Let’s compare them side-by-side.

Integer	Float
`7`	`7.0`
`100`	`100.5`
`-3`	`-3.14`

Even though 7 and 7.0 look similar, Python treats them differently.

Checking Data Types in Python

Python provides a very useful function called type().

Example:

power_level = 9000
print(type(power_level))

Output:

<class 'int'>

Now with a float:

rating = 9.7
print(type(rating))

Output:

<class 'float'>

This is extremely useful when debugging programs.

3. Boolean Values (`bool`) ✅❌

A Boolean variable can only store one of two values:

True
False

That’s it.

Nothing in between.

Real-Life Example

Think about simple yes/no situations:

Is the player alive?
Has the mission been completed?
Is the villain defeated?
Is the account verified?

All of these can be represented using Booleans.

Example 🎭

is_hokage = True

Or:

is_akatsuki_member = False

Booleans are heavily used in decision-making systems.

Why Booleans Are So Important

Booleans power the logic behind applications.

For example:

is_logged_in = True

if is_logged_in:
    print("Welcome back!")

Output:

Welcome back!

This is how apps decide what should happen next.

Important Note About Boolean Values

In Python:

True
False

must start with capital letters.

Wrong:

true
false

Correct:

True
False

Python is case-sensitive.

Combining Data Types Together

Real programs usually use multiple data types together.

Example:

character_name = "Luffy"
bounty = 3000000000
pirate_king_candidate = True
power_multiplier = 1.8

Here we have:

Variable	Data Type
`character_name`	String
`bounty`	Integer
`pirate_king_candidate`	Boolean
`power_multiplier`	Float

This is how real applications organize information.

Beginner Mistakes to Avoid 🚨

1. Mixing Up Strings and Numbers

Wrong:

power = "9000" + 1000

This causes an error because "9000" is text, not a number.

Correct:

power = 9000 + 1000

2. Forgetting Decimal Points

rating = 9

This is an integer.

But:

rating = 9.0

This is a float.

Tiny difference.

Big meaning.

3. Using Quotes Around Boolean Values

Wrong:

is_alive = "True"

This becomes text, not a Boolean.

Correct:

is_alive = True

Fun Mini Project 🎮

Let’s create a tiny anime character profile.

character_name = "Gojo"
age = 28
power_level = 9999
cursed_energy_multiplier = 2.5
is_strongest_sorcerer = True

print(character_name)
print(age)
print(power_level)
print(cursed_energy_multiplier)
print(is_strongest_sorcerer)

Output:

Gojo
28
9999
2.5
True

Simple.

But this is already how real applications begin.

Quick Summary 🧠

Data Type	Example	Purpose
Integer (`int`)	`100`	Whole numbers
Float (`float`)	`9.5`	Decimal numbers
Boolean (`bool`)	`True`	True/False logic

Final Thoughts

Understanding data types is a huge step in learning Python.

At first, they may seem small and unimportant.

But almost every Python program depends on them.

Games.
Web apps.
AI systems.
Automation scripts.
Data science projects.

Everything uses data types.

So spend time practicing them.

Create weird variables.
Experiment with anime examples.
Break things.
Fix things.

That’s how real learning happens.

Practice Challenge ⚔️

Try creating variables for:

Your favorite anime
Its rating
Number of episodes
Whether it is completed or ongoing

Example:

anime_name = "Attack on Titan"
rating = 9.9
episodes = 89
is_completed = True

Then use type() on each variable to see what Python says.

Wrapping Up

This is article #2 in the Python Basics series.

In the next article, we’ll explore:

👉 Strings in Python
👉 String operations
👉 Concatenation
👉 Useful string methods
👉 Common beginner mistakes

Stay tuned 🐍✨

Happy coding!

Understanding Variables

Gamya — Thu, 30 Apr 2026 05:03:09 +0000

If you're starting your Python journey, one of the very first things you'll encounter is variables.

And honestly?

Variables are everywhere in programming.

Whether you're building web apps, automating boring tasks, analyzing data, or creating games, you'll constantly use variables to store and manage information.

In this article, we'll break down variables in the simplest way possible—with some anime-inspired examples to make things fun and memorable.

So grab your ramen 🍜, and let's begin.

What Exactly Is a Variable?

A variable is simply a named storage location in a computer’s memory.

Sounds technical?

Let’s simplify it.

Imagine you’re watching an anime where every character carries a special scroll or inventory box.

Each box has:

A label (the variable name)
Something stored inside it (the value)

For example:

power_level = 9000

Here:

power_level → variable name
9000 → value stored inside it

Python remembers this value so your program can use it later.

Think of it like this:

Variable	Stored Value
`hero_name`	`"Naruto"`
`chakra_level`	`500`
`is_hokage`	`False`

Creating Variables in Python

Creating a variable is super easy in Python.

You simply assign a value using the = operator.

anime_name = "One Piece"
episodes = 1000
rating = 9.8

This process is called assignment.

You are basically telling Python:

“Hey Python, store this information for me.”

Variables Can Change (And That’s Their Superpower)

Variables are called variables because their values can change.

chakra = 50
chakra = 100

Initially, chakra was 50.

Later, we changed it to 100.

Python always keeps the latest assigned value.

Example 🎌

Imagine a character leveling up during battle.

goku_power = 5000

# After training
goku_power = 9000

# After Ultra Instinct
goku_power = 1000000

The variable stays the same.

Only the value changes.

That’s exactly how variables behave.

Why Variables Matter So Much

Without variables, programming would be chaos.

Variables help us:

Store user information
Track scores in games
Save data from APIs
Count items
Build logic
Make applications dynamic

For example:

player_health = 100
enemy_damage = 30

player_health = player_health - enemy_damage

print(player_health)

Output:

This is how games calculate damage internally.

Pretty cool, right?

Rules for Naming Variables in Python

Python has some rules for variable names.

Let’s go through them one by one.

1. Variable Names Cannot Start With Numbers ❌

Wrong:

1piece = "Luffy"

Correct:

one_piece = "Luffy"
piece1 = "Luffy"

2. Spaces Are Not Allowed ❌

Wrong:

anime hero = "Zoro"

Correct:

anime_hero = "Zoro"

3. Special Characters Are Not Allowed ❌

Wrong:

power-level = 9000
hero$name = "Naruto"

Correct:

power_level = 9000
hero_name = "Naruto"

You can only use:

Letters
Numbers
Underscores

Good Variable Names vs Bad Variable Names

Bad:

x = 100

Good:

player_health = 100

Why?

Because descriptive names make your code easier to read.

Imagine working on a project after 6 months.

You’ll thank your past self for writing meaningful variable names.

Snake Case vs Camel Case 🐍🐫

There are two popular naming styles.

Snake Case (Most Common in Python)

Words are separated using underscores.

player_power_level = 9000

Python developers mostly use this style.

Camel Case

Each new word starts with a capital letter.

playerPowerLevel = 9000

Camel case is common in languages like JavaScript and Java.

But in Python?

Snake case wins almost every time.

Variables Can Store Different Types of Data

Variables are not limited to numbers.

Python can store many types of information.

Strings (Text)

anime = "Attack on Titan"

Integers (Whole Numbers)

titans_defeated = 50

Floats (Decimal Numbers)

rating = 9.7

Booleans (True/False)

is_alive = True

Fun Mini Example 🎮

Let’s create a tiny anime character system.

character_name = "Ichigo"
health = 100
bankai_unlocked = True

print(character_name)
print(health)
print(bankai_unlocked)

Output:

Ichigo
100
True

Simple.

But this tiny concept is the foundation of huge applications.

Even massive apps like Netflix, Instagram, and Spotify rely heavily on variables behind the scenes.

Beginner Mistakes to Avoid 🚨

1. Forgetting Quotes Around Text

Wrong:

anime = Naruto

Correct:

anime = "Naruto"

2. Using Confusing Names

Avoid:

a = 10
b = 20

Prefer:

player_score = 10
enemy_score = 20

3. Accidentally Overwriting Variables

coins = 100
coins = 0

Be careful when reassigning values.

Python only remembers the latest one.

Final Thoughts

Variables are one of the most important concepts in programming.

Mastering them early makes everything else easier later:

Conditions
Loops
Functions
APIs
Data structures
Web development
Automation
AI projects

Everything builds on top of variables.

So don’t rush this topic.

Practice creating variables daily.

Experiment with funny examples.

Build tiny anime-themed scripts.

And most importantly—enjoy the learning process.

Quick Practice Challenge ⚔️

Try creating variables for:

Your favorite anime character
Their power level
Their age
Whether they are a hero or villain

Example:

character_name = "Levi"
power_level = 9500
age = 34
is_hero = True

Try printing them using print().

Wrapping Up

This is the first article in my Python Basics series.

In the next article, we’ll explore:

👉 Data Types in Python
👉 How Python understands different kinds of information
👉 Type conversion and common beginner mistakes

Stay tuned. 🚀

And if this article helped you even a little, feel free to drop a reaction or share it with another beginner developer.

Happy coding 🐍✨

How to Join Strings Together in Swift

Gamya — Wed, 29 Apr 2026 03:56:40 +0000

Swift gives us two powerful ways to combine strings together:

Using the + operator
Using string interpolation

Both are useful, but string interpolation is usually the cleaner and more efficient option.

If you’re building iOS apps, games, or even anime-themed projects, you’ll use string joining constantly for messages, UI text, scores, usernames, and more 🌸✨

🔹 Joining Strings with `+`

The simplest way to combine strings is using +.

let firstName = "Naruto"
let lastName = "Uzumaki"

let fullName = firstName + " " + lastName
print(fullName)

Output:

Naruto Uzumaki

Swift takes both strings and joins them into one brand-new string.

🔹 Joining Multiple Strings

You can chain many strings together if needed.

let hero = "Luffy"
let dream = "King of the Pirates"

let intro = hero + " wants to become the " + dream
print(intro)

Output:

Luffy wants to become the King of the Pirates

This works perfectly for small examples and quick text combinations.

🔹 Operator Overloading in Swift

Earlier, you learned that + adds numbers:

let result = 10 + 5
print(result)

Output:

But with strings, + means “join together.”

This is called operator overloading — the same operator can do different things depending on the data type.

For example:

let anime = "One Piece"
let excitement = "!!!"

print(anime + excitement)

Output:

One Piece!!!

Swift understands that both values are strings, so it joins them instead of adding numbers.

🔹 Using `+=`

Swift also provides +=, which appends text directly to a string.

var powerLevel = "Goku"

powerLevel += " Ultra Instinct"
print(powerLevel)

Output:

Goku Ultra Instinct

This is useful when building strings step by step.

🔹 Why Too Much `+` Can Be Wasteful

Using + repeatedly creates temporary strings behind the scenes.

Look at this:

let code = "D" + "E" + "M" + "O"
print(code)

Swift actually builds several temporary strings:

"D" + "E" → "DE"
"DE" + "M" → "DEM"
"DEM" + "O" → "DEMO"

Those temporary strings are discarded afterward.

For tiny examples this is fine, but in real apps with lots of text processing, it becomes inefficient.

That’s where string interpolation shines ✨

🔹 String Interpolation

String interpolation lets you place variables directly inside strings using \().

This is the preferred Swift way to build strings.

let anime = "Attack on Titan"
let rating = 10

let message = "I rate \(anime) \(rating)/10."
print(message)

Output:

I rate Attack on Titan 10/10.

Swift automatically converts values into strings for you.

🔹 Why String Interpolation Is Better

With interpolation:

✅ Cleaner code
✅ Easier to read
✅ Faster and more efficient
✅ Works with many data types

For example:

let ninja = "Kakashi"
let missions = 1200

let summary = "\(ninja) completed \(missions) missions."
print(summary)

Output:

Kakashi completed 1200 missions.

Notice how missions is an integer, yet Swift inserts it into the string automatically.

🔹 The Problem with `+` and Numbers

This code does not work:

let episode = 5

let text = "Episode " + episode

Swift gives an error because you can’t directly join a string and an integer using +.

You could convert the number manually:

let text = "Episode " + String(episode)
print(text)

But interpolation is much easier:

let text = "Episode \(episode)"
print(text)

Output:

Episode 5

Cleaner and simpler 🌸

🔹 Calculations Inside Strings

One awesome feature of string interpolation is that you can place calculations directly inside \().

print("Gojo used \(3 * 10)% of his power.")

Output:

Gojo used 30% of his power.

You can even do more advanced calculations:

let chakra = 80
let boost = 20

print("Final chakra level: \(chakra + boost)")

Output:

Final chakra level: 100

🔹 Quotes Inside Strings

Sometimes you need quotation marks inside a string.

Use a backslash before quotes:

let quote = "Levi said \"Keep moving forward.\""
print(quote)

Output:

Levi said "Keep moving forward."

This is called an escape sequence.

Here’s a fun example combining everything together:

let hero = "Tanjiro"
let enemy = "Akaza"
let totalBattles = 3

let story = "\(hero) fought \(enemy) in \(totalBattles) epic battles!"
print(story)

Output:

Tanjiro fought Akaza in 3 epic battles!

This is exactly the kind of string building you’ll use in real iOS apps and games.

🌟 Wrap Up

Swift provides two ways to join strings together:

Using `+`

let text = "Hello " + "World"

Using String Interpolation

let text = "Hello \(name)"

Although both work, string interpolation is usually the best choice because it’s cleaner, easier to read, and more efficient.

Strings are everywhere in app development—chat apps, games, anime trackers, login screens, and more. ✨

Swift Booleans

Gamya — Sat, 14 Feb 2026 13:35:00 +0000

Swift Booleans

Alongside strings and numbers, Swift has a very simple data type called a Boolean.

A Boolean stores only two values: true or false.

Booleans are named after George Boole, who studied logic.

🔹 Booleans in the Wild

You’ve already seen Booleans without realizing it:

let imageFile = "sakura.png"
print(imageFile.hasSuffix(".png"))

let petals = 120
print(petals.isMultiple(of: 3))

Both checks return either true or false.

🔹 Creating Booleans

Creating a Boolean works just like other types:

let isBlooming = true
let gameOver = false

You can also assign a Boolean from a condition:

let isSpecialFlower = petals.isMultiple(of: 3)

🔹 Flipping Booleans

Booleans don’t support math operators, but they do support logical operators.

The ! operator means “not”:

var isAuthenticated = false

isAuthenticated = !isAuthenticated
print(isAuthenticated)

isAuthenticated = !isAuthenticated
print(isAuthenticated)

This flips the value from false → true → false.

🔹 Using `toggle()`

Swift provides a cleaner way to flip Booleans using toggle():

var battleWon = false
print(battleWon)

battleWon.toggle()
print(battleWon)

This does the same thing as !, but reads better in real apps.

🌟 Wrap Up

Booleans represent yes/no, on/off, true/false decisions.

They power conditions, logic, and flow control🌸✨

Swift Is Type-Safe Language

Gamya — Fri, 13 Feb 2026 12:44:00 +0000

🌸 Why Swift Is a Type-Safe Language ✨

Swift allows many kinds of data—strings, integers, decimals, booleans, and more.

Once Swift decides what type a variable holds, that type can never change.

This is called type safety, and it’s one of Swift’s biggest strengths.

🔹 How Swift Assigns Types

Swift infers the type from the value you assign:

var flowerCount = 42

Because 42 is a whole number, Swift treats flowerCount as an Int.

You can change the value:

flowerCount = 50

But you cannot change the type.

🔹 Type Safety in Action

This is not allowed:

// ❌ Error
flowerCount = "Forty two"

Swift won’t let you assign a String to a variable that was created as an Int.

🔹 Why This Matters

As apps grow, keeping track of every variable’s type becomes impossible.

Swift takes that responsibility for you and prevents bugs before your app runs.

Type safety ensures:

Numbers aren’t treated like text
Decimals aren’t mixed with integers accidentally
Data stays predictable and reliable

🌟 Wrap Up

Type safety means a variable has one job—and sticks to it.

Swift enforces this rule so your code stays safe, clear, and bug-free 🌸✨

Swift needs both Integers and Doubles

Gamya — Thu, 12 Feb 2026 12:00:00 +0000

Why Swift Needs Both Integers and Doubles

Swift gives us different number types because numbers solve different problems.

The two most common ones are Integers (Int) and Doubles (Double)—and Swift keeps them separate on purpose.

🔹 Integers vs Doubles

Integers store whole numbers:

let petals = 12
let powerLevel = -9000

Doubles store decimal numbers:

let flowerGrowth = 0.75
let animeRating = 4.5

Both are numbers, but they behave very differently.

🔹 How Swift Chooses the Type

Swift decides the type based on the value you write:

let myInt = 1      // Int
let myDouble = 1.0 // Double

Even though both represent the number one, they are not the same type.

🔹 Why You Can’t Mix Them

This is not allowed:

let total = myInt + myDouble // ❌ Error

Why? Because Double values can change:

var myDouble = 1.0
myDouble = 1.5

Swift can’t safely add an integer to a decimal without risking loss of precision.

This is why Swift enforces type safety.

🔹 Explicit Conversion

If you want to combine them, you must be clear about it:

let total1 = Double(myInt) + myDouble
let total2 = myInt + Int(myDouble)

Swift forces you to choose how the conversion happens.

🌟 Wrap Up

Int is exact and safe for whole numbers
Double handles decimals but isn’t perfectly precise
Swift keeps them separate to prevent bugs

It may feel strict at first, but this rule saves you from subtle bugs—just like a disciplined anime sensei 🌸✨

Decimals in Swift

Gamya — Wed, 11 Feb 2026 12:00:00 +0000

🌸 Swift Decimal Numbers✨

When you work with decimal numbers like 3.14, 0.5, or 9.99, Swift uses floating-point numbers, usually of type Double.

Decimals are used for things like ratings, percentages, and measurements.

🔹 Creating Decimal Numbers

If a number contains a dot (.), Swift treats it as a Double:

let animeRating = 4.5
let bloomGrowth = 0.75

Swift automatically chooses Double for decimal values.

🔹 Decimal Precision Gotcha

Decimal numbers are not always perfectly accurate:

let value = 0.1 + 0.2
print(value)

This prints:

0.30000000000000004

This happens because decimals are stored as binary approximations.

🔹 Int vs Double (Type Safety)

Swift does not allow mixing integers and decimals:

let episodes = 12
let duration = 2.0

// ❌ Error
// let total = episodes + duration

You must convert explicitly:

let total1 = Double(episodes) + duration
let total2 = episodes + Int(duration)

This is called type safety.

🔹 How Swift Chooses the Type

Swift decides the type based on the value:

let d1 = 3.14   // Double
let d2 = 3.0    // Double
let i1 = 3      // Int

Once set, a variable cannot change its type.

🔹 Decimal Math

Decimals support the same operators as integers:

var flowerRating = 4.0

flowerRating *= 2
flowerRating -= 1
flowerRating /= 2

print(flowerRating)

🌟 Wrap Up

Decimals in Swift use Double by default.

They’re powerful and fast, but not always perfectly precise—which is why Swift keeps Int and Double strictly separate 🌸✨

Integers in Swift

Gamya — Tue, 10 Feb 2026 11:00:00 +0000

Swift Integers ✨

When you work with whole numbers like 3, 42, or 1_000_000, you’re using integers in Swift (Int for short).

Integers represent whole numbers—no decimals.

🔹 Creating Integers

Creating an integer looks just like creating a string:

let powerLevel = 9000
var flowerCount = 12

Swift integers can be very large and can also be negative.

🔹 Readable Large Numbers

Big numbers are hard to read:

let petals = 100000000

Swift lets you use underscores to improve readability:

let petals = 100_000_000

Underscores are ignored by Swift—they’re just for humans.

🔹 Integer Math

Swift supports basic arithmetic operators:

let baseScore = 10

let bonus = baseScore + 5
let damage = baseScore * 2
let penalty = baseScore - 3
let halfPower = baseScore / 2

🔹 Updating Integers

Instead of rewriting values, you can use compound assignment operators:

var chakra = 10

chakra += 5
chakra *= 2
chakra -= 4
chakra /= 2

print(chakra)

These do the same thing, with less typing.

🔹 Useful Integer Checks

Integers have helpful built-in methods, like checking multiples:

let petals = 120
print(petals.isMultiple(of: 3))

You can even call it directly:

print(120.isMultiple(of: 3))

🌟 Wrap Up

Swift integers are powerful, safe, and easy to work with.

Strings in Swift

Gamya — Mon, 09 Feb 2026 21:05:05 +0000

🌸 Swift Strings ✨

In Swift, text stored in a variable or constant is called a string.

Strings are written using double quotes.

let animeHero = "Hinata Hyuga"
let flower = "Cherry Blossom 🌸"

🔹 Quotes Inside Strings

To include quotes inside a string, escape them with a backslash:

let quote = "She said, \"Every flower blooms in its own time.\""

🔹 Multi-line Strings

Regular strings cannot span multiple lines.

For longer text, use triple quotes:

let poem = """
Petals fall softly,
Anime dreams rise high,
Spring never fades.
"""

Swift keeps line breaks exactly as written.

🔹 Common String Operations

Count Characters

print(animeHero.count)

Swift correctly counts emoji and Unicode characters.

Uppercase Text

print(flower.uppercased())

Prefix & Suffix Checks

print(poem.hasPrefix("Petals"))
print(flower.hasSuffix("🌸"))

⚠️ String comparisons in Swift are case-sensitive.

🌟 Wrap Up

Swift strings are safe, Unicode-aware, and powerful.

Whether it’s anime dialogue or flower names, Swift handles text beautifully 🌸✨

Variables and Constants in Swift

Gamya — Tue, 06 Jan 2026 01:40:50 +0000

Variables and Constants in Swift

Whenever you build software, you need to store information.

That information could be:

A wizard’s name
A ninja’s village
Your dog’s breed
A score, setting, or calculation result

In Swift, storing information starts with two core concepts:

Variables and constants

Let’s break them down using examples that are a little more fun than usual.

Variables: When Your Data Can Change

Here’s a simple Swift variable:

swift
var wizardName = "Harry Potter"
This creates a variable called wizardName.

A variable is a piece of data that can change over time as your program runs.

What’s happening in this line?

There are four important parts:

var
Tells Swift you’re creating a variable.

wizardName
The variable’s name.
You can choose any name, but descriptive names are best.

= (equals sign)
Assigns a value to the variable.

"Harry Potter"
A string value — text in Swift is written inside double quotes.

Swift doesn’t require semicolons at the end of lines, which keeps code clean and readable.

Changing a Variable’s Value

Because variables can change, you can update them whenever you want:
var ninjaName = "Naruto Uzumaki"
ninjaName = "Sasuke Uchiha"
ninjaName = "Kakashi Hatake"
What’s happening here?

The variable starts as "Naruto Uzumaki"

It’s updated to "Sasuke Uchiha"

Then updated again to "Kakashi Hatake"

Important rule:

You use var only once

After that, you just change the value

Each new assignment replaces the previous one.

Constants: When Your Data Should Never Change

Some values should never change.

For those, Swift gives us constants, created using let.
let hogwartsHouse = "Gryffindor"
This creates a constant called hogwartsHouse.

Once assigned, it cannot be changed.

If you try, Swift will stop you:
let hokageTitle = "Seventh Hokage"
hokageTitle = "Sixth Hokage"
This will cause an error.

Why?
Because a constant is meant to stay constant.

The keyword “let” comes from mathematics—as in “let x be equal to 5.”
Important Rule (Seriously)

If Xcode shows errors because you tried to change a constant:

👉 Delete those lines.
Swift is protecting you from bugs.

Printing Values (Your Best Learning Tool)

When learning Swift, it’s incredibly helpful to see what’s inside your variables.

You can do this using print():
var dogBreed = "Golden Retriever"
print(dogBreed)

dogBreed = "Shiba Inu"
print(dogBreed)

dogBreed = "Border Collie"
print(dogBreed)
Each print() outputs the current value.

You won’t use print() much in real apps, but while learning, it’s your best friend.
Prefer Constants Over Variables

Here’s an important Swift habit to build early:

Use let by default.
Switch to var only when the value needs to change.
For example:
let animeSeries = "Naruto"
var episodeCount = 1
Why prefer constants?

Swift can optimize them better

Your code becomes safer

You avoid accidental changes

If something shouldn’t change, make it a constant.

Why You Should Learn Swift in 2026

Gamya — Sun, 04 Jan 2026 05:07:07 +0000

Why You Should Learn Swift in 2026

There are a lot of programming languages out there.

JavaScript, Python, Java, Go, Rust — the list keeps growing. So it’s natural to wonder:

Why Swift?

In this article, I want to explain why learning Swift in 2026 is still a great choice, especially if you’re:

Completely new to programming
Switching careers into tech
Interested in building real apps for Apple platforms

This isn’t hype. It’s a practical look at what makes Swift worth learning.

Swift Is a Skill That Can Pay the Bills

Let’s be honest — most people don’t learn programming just for fun.

Swift lets you build apps for:

iOS
iPadOS
macOS
watchOS
tvOS
visionOS

The Apple ecosystem remains one of the few places where:

Users pay for quality apps
Indie developers can still succeed
iOS developers are consistently in demand

With Swift, you can work at a company, freelance, or ship your own apps.

Swift Is Modern (Without Legacy Baggage)

Swift was introduced in 2014, which makes it relatively young compared to many popular languages.

That’s a good thing.

Older languages often carry decades of historical decisions and outdated patterns. Swift avoided much of that by learning from what came before.

In practice, this means:

Cleaner syntax
Fewer legacy concepts
Often one clear, recommended way to solve a problem

As a beginner, this reduces confusion and speeds up learning.

Swift Learns From Other Languages’ Mistakes

Swift borrows the best ideas from many languages and avoids many of their pitfalls.

Some examples:

Strong type safety to catch mistakes early
Optionals to handle missing values safely
Readable syntax that favors clarity
Unicode support by default, so text “just works”

Swift actively encourages code that is safer, clearer, and easier to maintain.

Swift Makes Unsafe Code Hard to Write

In many languages, it’s easy to write code that crashes at runtime.

Swift tries to prevent that.

Instead of failing mysteriously, Swift pushes many errors to compile time, meaning:

Problems are caught earlier
Crashes are less common
Error messages are clearer

For beginners, this makes learning far less frustrating.

Swift Encourages Readable, Professional Code

Swift is designed so code reads naturally.

That matters because:

You’ll read your own code months later
You’ll read other people’s code at work
Teams value clarity over clever tricks

Readable code scales better and makes collaboration easier.

Swift Is Just the Language — SwiftUI Builds the App

Swift alone doesn’t draw screens or buttons.

That’s where SwiftUI comes in.

SwiftUI is Apple’s modern UI framework that lets you build:

Text and images
Buttons and forms
Layouts and animations
User interactions

Most importantly:

SwiftUI was designed specifically for Swift.

It leverages Swift’s strengths to let you build powerful apps with surprisingly little code.

Swift + SwiftUI = Fast Feedback

One of the most satisfying parts of learning Swift is how quickly you see results.

You write code.

You run the app.

The UI updates instantly.

This fast feedback loop makes learning more engaging and motivating.

Swift Grows With You

Swift is beginner-friendly, but it doesn’t limit you as you grow.

Over time, you’ll learn:

Generics
Protocol-oriented design
Structured concurrency (async/await, actors)
Architecture patterns

The same language works for beginners and senior engineers alike.

Final Thoughts

You should learn Swift in 2026 because:

It’s modern without unnecessary complexity
It prioritizes safety and clarity
It’s beginner-friendly but powerful
It pairs beautifully with SwiftUI
It lets you build real, polished apps
And yes — it can be financially rewarding

No cruft.

No unnecessary confusion.

Just a lot of power at your fingertips.

What’s not to like?

How to become an iOS developer in 2026

Gamya — Sat, 03 Jan 2026 11:40:44 +0000

In this article, I want to walk you through what I believe it takes to become an iOS developer in 2026.

This is aimed squarely at two groups of people:

Absolute beginners to Swift — people who have never built an iOS app before
“False beginners” — people who tried learning Swift before but never quite reached the point of getting a job

No matter where you’re starting from, the goal is the same:

Put yourself in a strong position to apply for a junior iOS developer role — or ship your own apps if that’s your dream.

What We’ll Cover

We’ll look at:

The core skills you should focus on
Extension skills that can set you apart

Let’s start with the fundamentals.

Core Skills You Need in 2026

What is the absolute minimum skill set required to get a junior iOS job today?

I still think there are five:

Swift
SwiftUI
Working with data
Networking
Version control (Git)

That’s it.

The list is intentionally short.

Why so few?

The more you learn, the more there is to learn — it’s easy to get stuck in endless “learning mode”
You’ll almost always join a team with an existing codebase anyway
Swift and SwiftUI alone can take months to absorb properly
Most importantly: these five skills let you build real apps

Your early code won’t be perfect — and that’s fine.

The only way to write good code is to write a lot of bad code first.

Learning Swift

Swift is Apple’s core programming language.

It doesn’t know anything about screens or networking — it’s just logic:

Variables
Functions
Types
Control flow
Data structures

In 2026, Swift is a mature, modern language with:

Strong type safety
Optionals
Protocol-oriented design
Generics
Structured concurrency (async/await, actors)

Some parts will click quickly.

Others (like generics or concurrency) will take time.

That’s normal.

You do not need to master Swift before building apps.

You’ll learn most of it while building.

Learning SwiftUI

SwiftUI is Apple’s modern UI framework for:

iOS
iPadOS
macOS
watchOS
tvOS
visionOS

Swift is the language.

SwiftUI is how you describe what your app looks like and how it behaves.

In 2026, SwiftUI is no longer “new”:

It’s used in production apps (including Apple’s)
Widgets and many system features are SwiftUI-first
It’s the default choice for new projects

SwiftUI vs UIKit?

UIKit still matters — we’ll talk about it later.

But for beginners in 2026:

Swift + SwiftUI should be your core stack.

Why?

Less code for the same result
Designed for Swift from the ground up
Cross-platform by default
Most new platform investment is SwiftUI-first

UIKit isn’t disappearing — but SwiftUI is where things are going.

Networking & Working with Data

These two go hand-in-hand.

Networking

Fetching data from the internet or sending data to a server.

Working with Data

Turning that raw data into something useful in your app.

At a junior level, you should be comfortable with:

Fetching JSON using URLSession and async/await
Decoding data with Codable
Displaying it in SwiftUI
Optionally saving it locally

This fetch → decode → display cycle is a huge part of real-world iOS development.

Version Control (Git)

The final core skill isn’t iOS-specific: Git.

You don’t need to be an expert — just enough to:

Create a repository
Commit changes
Push to GitHub/GitLab
Pull changes
Resolve simple conflicts

Why it matters:

Teams rely on Git
Public repos give recruiters something real to review

No one understands all of Git. You just need enough to collaborate safely.

After the Core Skills

Once you’re comfortable with those five skills, you’re already able to:

Ship your own apps
Apply for junior roles

There is no secret sixth requirement.

That said, if you want to go further, there are extension skills that help you stand out.

Extension Skills That Level You Up

UIKit
Core Data / SwiftData
Testing
Software architecture
Concurrency & multithreading

These aren’t required to start — but they matter as you grow.

UIKit (Why It Still Matters)

UIKit has been around since 2008 and is still everywhere.

Why learn it?

Many large apps are UIKit-based
Some system behaviors are still easier in UIKit
There’s a massive ecosystem of knowledge around it

Why not start with it?

Much more boilerplate than SwiftUI
Older patterns
Auto Layout can be mentally exhausting

Build momentum with SwiftUI first.

Add UIKit once you’re comfortable.

Persistence: Core Data & SwiftData

Saving and querying data locally becomes essential as apps grow.

Core Data: mature, powerful, widely used
SwiftData: newer, Swift-native, SwiftUI-friendly

You don’t need persistence for your first job — but knowing one of these makes you stronger.

Testing

Testing helps ensure your app behaves correctly as it changes.

Why it’s not core:

Many apps still have limited test coverage
Employers prioritize platform knowledge first

My recommendation:

Build apps
Add tests to key logic
Learn unit tests and UI tests gradually

Software Architecture

Architecture is how you organize code so it scales.

Early code will be messy — that’s expected.

Architecture is about:

Separating responsibilities
Reducing coupling
Making change easier

If you look back at code from 6–12 months ago and cringe — that’s growth.

Concurrency

Concurrency lets your app do work without freezing the UI.

In modern Swift, that means:

async/await
Task
actors

Learn the basics. Avoid over-engineering.

Responsive, correct apps matter more than “maximum concurrency”.

The biggest takeaway?

Progress beats perfection.

Final Thoughts

You don’t need a degree.

You don’t need a bootcamp.

You don’t need expensive courses.

You need:

Consistency
Curiosity
Patience

If you keep building, keep asking questions, and keep showing up — you will get there.

Good luck on your journey. 🚀

Forem: Gamya

Understanding Data Types in Python

Python Basics #2 🐍🔥

What Is a Data Type?

The Main Data Types Beginners Should Know

1. Integers (int) 🔢

Example 🎌

Why Integers Matter

2. Floating-Point Numbers (float) 🌊

Why Are They Called “Floating-Point”?

Example ⚡

Integer vs Float

Checking Data Types in Python

3. Boolean Values (bool) ✅❌

Real-Life Example

Example 🎭

Why Booleans Are So Important

Important Note About Boolean Values

Combining Data Types Together

Beginner Mistakes to Avoid 🚨

1. Mixing Up Strings and Numbers

2. Forgetting Decimal Points

3. Using Quotes Around Boolean Values

Fun Mini Project 🎮

Quick Summary 🧠

Final Thoughts

Practice Challenge ⚔️

Wrapping Up

Understanding Variables

What Exactly Is a Variable?

Creating Variables in Python

Variables Can Change (And That’s Their Superpower)

Example 🎌

Why Variables Matter So Much

Rules for Naming Variables in Python

1. Variable Names Cannot Start With Numbers ❌

2. Spaces Are Not Allowed ❌

3. Special Characters Are Not Allowed ❌

Good Variable Names vs Bad Variable Names

Snake Case vs Camel Case 🐍🐫

Snake Case (Most Common in Python)

Camel Case

Variables Can Store Different Types of Data

Strings (Text)

Integers (Whole Numbers)

Floats (Decimal Numbers)

Booleans (True/False)

Fun Mini Example 🎮

Beginner Mistakes to Avoid 🚨

1. Forgetting Quotes Around Text

2. Using Confusing Names

3. Accidentally Overwriting Variables

Final Thoughts

Quick Practice Challenge ⚔️

Wrapping Up

How to Join Strings Together in Swift

🔹 Joining Strings with +

🔹 Joining Multiple Strings

🔹 Operator Overloading in Swift

🔹 Using +=

🔹 Why Too Much + Can Be Wasteful

🔹 String Interpolation

🔹 Why String Interpolation Is Better

🔹 The Problem with + and Numbers

🔹 Calculations Inside Strings

🔹 Quotes Inside Strings

🌟 Wrap Up

Using +

Using String Interpolation

Swift Booleans

Swift Booleans

🔹 Booleans in the Wild

🔹 Creating Booleans

🔹 Flipping Booleans

🔹 Using toggle()

🌟 Wrap Up

Swift Is Type-Safe Language

🌸 Why Swift Is a Type-Safe Language ✨

🔹 How Swift Assigns Types

🔹 Type Safety in Action

1. Integers (`int`) 🔢

2. Floating-Point Numbers (`float`) 🌊

3. Boolean Values (`bool`) ✅❌

🔹 Joining Strings with `+`

🔹 Using `+=`

🔹 Why Too Much `+` Can Be Wasteful

🔹 The Problem with `+` and Numbers

Using `+`

🔹 Using `toggle()`