iOS App Monetization Start, Swift Grammar Master [Beginner]

Hello! I'm iOS developer Jang Sang-gu.

I majored in fashion design in Paris and returned to Korea to build my career in the related field. During that time, I had a great opportunity to directly plan and participate in developing a fashion customization platform, and through that experience, I became captivated by the charm of development.

As someone who started development without a technical background, I learned by finding the necessary content on my own and went through trial and error while writing code directly. By building up knowledge piece by piece like this, I eventually successfully launched the Plinn app and began a new career as an iOS developer.

As a non-major learning development, there are common walls that everyone inevitably hits.

This is because when studying Swift, it's easy to get lost in concepts that require CS knowledge such as value types and reference types, memory structure, and asynchronous processing.

I also had to spend countless hours at this stage searching through official documentation and digging through various resources to understand it with great difficulty.

I realized that a course was needed to address exactly those points that non-majors struggle with most in this process.

So I meticulously designed the curriculum to use only previously learned knowledge whenever introducing new concepts.

Through this approach, learners can progress step by step without confusion, moving beyond simply 'memorizing' grammar to fundamentally understanding why code works the way it does.

I want to help you avoid repeating the same trial and error that I went through.

So I first released the app textbook, and then introduced this course through Inflearn.

If you join me, even non-majors can experience a solid path to grow as iOS developers by naturally connecting from the basics to practical work.

Just trust me and follow along, and I will definitely guide you so that you can communicate with the world through the language of development!

When learning Swift, the iOS programming language, it can be confusing when multiple concepts appear all at once.

So I created the lectures with the principle that "when understanding new concepts, only previously learned concepts should be used."

So this lecture is,

Only one new concept appears at each step,

We meticulously designed a sequential structure between concepts to ensure that no unfamiliar concepts appear unexpectedly.

One concept per minute, 180 total.

From the basics of variables and constants to understanding memory structures from a CS perspective, and even the latest syntax for asynchronous processing.

In 3 hours, you will learn 180 core concepts in a designed sequence.

The reason why deep learning is possible in a short time is,

This is because the sequential structure between concepts has been meticulously designed.

Additionally, I boldly excluded typing time.

Most students pause the screen and type along when they're typing on their own anyway, so

You can pause the screen for a moment and type directly to maintain the same learning density while using your time more efficiently.

Why should we understand memory structure and concurrency from a CS perspective?

The important thing when learning programming syntax is

It's about fundamentally understanding "how code works."

One of the explanations you often hear when first learning about classes and structures is

"Classes are reference types, structs are value types."

But it's not just grammar to memorize and move on from

What values are stored where (stack or heap),

when it is referenced and at what moment it is released

Understanding from a memory structure perspective

You can accurately diagnose and resolve issues such as memory leaks.

Also, async/await and MainActor introduced in Swift 5.5

If you don't understand the execution flow of asynchronous code (main thread and external threads)

Fatal mistakes such as UI update errors can occur.

This course provides structured explanations from a CS perspective.

It's not just about 'knowing how to use' the latest syntax,

You can become a developer who thoroughly understands why things work the way they do.

We also provide an app textbook for this course.

If you search for Swift Grammar Master on the App Store

You can download an app textbook that allows you to learn by directly typing the lecture examples.

All examples include explanations that are connected to the lecture content.

I made it so you can review anytime without notes.

Even after the course ends, it will serve as a reliable tool for quickly looking up and reviewing Swift grammar.

Student Benefits

100% completion + review = Starbucks gift card provided!

Recommended for these people

Someone who is just starting to learn Swift and feels overwhelmed about where to begin

Someone who has gone through grammar once but still has concepts getting mixed up in their head

Those who want to quickly overview Swift as a whole and prepare for practical work in a short time

Course Reviews

"I wasn't really planning to study hard or anything, but I just had the lecture on and was watching casually, then ended up getting focused and watching it all the way through...

The tone is really comfortable and Kind but not excessive. When you learn one thing, you can immediately understand the next thing with it, so it was really easy to follow along."

"You know that topic that always comes up when you start Swift, right? Value types, reference types... Honestly, I never really understood it even though I saw it all the time, but this time it clicked a bit. Instead of just showing the definitions, they explained why it works that way, so I think it stuck in my head better."

"Arrays and dictionaries alone have so many features.

I used to just roughly write only what was necessary and move on,

Looking at them one by one this time, I found there were many things I didn't know at all.

The examples are short and concise, so they're not overwhelming, and the explanations are also good because they're free of unnecessary details.

"At first, I thought, 'One minute per concept? Is this even possible?'

When I actually listened to it, the explanations pinpointed exactly the parts that needed explanation, so it wasn't overwhelming at all.

It's not just that it finishes quickly, but the sequence is well-structured so there's hardly any confusion in the middle.

I especially felt this when explaining the differences between classes and structs,

It's not just about making you memorize, but really helping you understand, so I felt like the things I learned were connecting with each other in my head."

Curriculum Highlights

Basic Grammar and Data Types (9 items)

Operators (6)

Conditional Statements and Flow Control (6 items)

Tuple (3 items)

Loops and Flow Control (10)

Functions (16)

Optional (10)

Array (16)

Dictionary (13 items)

Set (9 items)

String Utilization (3 items)

Enumeration (Enum) (5 items)

Classes and Structures Basics (13 items)

Properties and Methods (14)

Nested Types (1)

ARC (1)

Type Checking and Conversion (7 items)

Extension (6)

Protocol (11)

Closures (4)

Higher-order functions (6)

Error Handling (4)

defer statement (1)

Asynchronous Processing (3 items)

Generics (3)

Learning Guide

If you follow just 2 principles, you will develop unshakeable grammar skills.

The first is that when taking the course, please make sure to pause at screens where the complete code is visible and try writing it yourself.

This course does not interpret the code flow step by step, except for new concepts, for efficient learning.

If we did that, a lecture that should finish in 3 hours would end up becoming a 10-hour lecture.

But there's no need to worry.

All example sentences used when learning new concepts are composed only of concepts that have already been learned

Just by writing the entire code yourself, you can understand the code flow on your own.

I strongly encourage you to try writing it yourself.

And second, if you don't completely understand the concept, you shouldn't move on to the next one.

This course has a layered structure, so if one stage becomes unstable, the next stage will also become unstable.