Forem: Gamya

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

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

🔹 Why This Matters

🌟 Wrap Up

Swift needs both Integers and Doubles

Why Swift Needs Both Integers and Doubles

🔹 Integers vs Doubles

🔹 How Swift Chooses the Type

🔹 Why You Can’t Mix Them

🔹 Explicit Conversion

🌟 Wrap Up

Decimals in Swift

🌸 Swift Decimal Numbers✨

🔹 Creating Decimal Numbers

🔹 Decimal Precision Gotcha

🔹 Int vs Double (Type Safety)

🔹 How Swift Chooses the Type

🔹 Decimal Math

🌟 Wrap Up

Integers in Swift

Swift Integers ✨

🔹 Creating Integers

🔹 Readable Large Numbers

🔹 Integer Math

🔹 Updating Integers

🔹 Useful Integer Checks

🌟 Wrap Up

Strings in Swift

🌸 Swift Strings ✨

🔹 Quotes Inside Strings

🔹 Multi-line Strings

🔹 Common String Operations

Count Characters

Uppercase Text

Prefix & Suffix Checks

🌟 Wrap Up

Variables and Constants in Swift

Variables and Constants in Swift

Variables: When Your Data Can Change

Constants: When Your Data Should Never Change

Why You Should Learn Swift in 2026

Why You Should Learn Swift in 2026

Swift Is a Skill That Can Pay the Bills

Swift Is Modern (Without Legacy Baggage)

Swift Learns From Other Languages’ Mistakes

Swift Makes Unsafe Code Hard to Write

Swift Encourages Readable, Professional Code

Swift Is Just the Language — SwiftUI Builds the App

Swift + SwiftUI = Fast Feedback

Swift Grows With You

Final Thoughts

How to become an iOS developer in 2026

What We’ll Cover

Core Skills You Need in 2026

Why so few?

Learning Swift

Learning SwiftUI

SwiftUI vs UIKit?

Networking & Working with Data

Networking

Working with Data

Version Control (Git)

After the Core Skills

Extension Skills That Level You Up

UIKit (Why It Still Matters)

Persistence: Core Data & SwiftData

Testing

Software Architecture

Concurrency

Final Thoughts

🔹 Using `toggle()`