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

I majored in fashion design in Paris and came back to Korea to pursue a career in a related field. Meanwhile, I had a great opportunity to directly plan a fashion customization platform and participate in development, and I fell in love with the appeal of development through that experience.

Since I first started development as a non-major, I went through trial and error while searching for what I needed, learning, and writing my own code. Building up one by one, they eventually successfully launched the Plinn app and began a new career as an iOS developer.

When learning development as a non-major, there is a common wall that everyone runs into.

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

I also had to spend a lot of time looking for official documents and searching through various materials at this stage, making it difficult to understand.

During this process, I realized that I needed a course that solved the most difficult point for non-majors.

So every time I learn a new concept, I've carefully designed my curriculum to use only the knowledge I've already learned.

This made it possible for learners to go through the steps one by one without confusion and essentially understand why the code works the way it does, beyond simply “memorizing” the syntax.

I want to help you not repeat trial and error like me.

Therefore, the app textbook was first released, and then this course was presented through Class 101.

If you join me, even non-majors can experience a definite path to grow as an iOS developer by connecting naturally from basics to practice.

If you trust and follow me, I will definitely guide you to communicate with the world in the language of development!

When learning Swift, the iOS programming language, it can be confusing when several concepts come up all at once.

That's why I I created the course based on the principle “When understanding a new concept, only the concepts you have already learned should be used.”

So this course is

Only one new concept appears at each stage,

The sequential structure between concepts was carefully designed so that other unfamiliar concepts would never appear.

One minute for one concept, 180 pieces in total.

From basic variables and constants to memory structures understood from a CS perspective, and the latest syntax for asynchronous processing.

Over 3 hours, you'll learn 180 core concepts in the order they were designed.

Why in-depth learning is possible in a short timeis,

This is because the sequential structure between concepts was so finely designed.

Also, I drastically excluded typing time.

Since most students stop and follow the screen when typing on their own anyway,

If you pause the screen for a moment and type directly, the learning intensity remains the same, and you can make more efficient use of your time.

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

What is important when learning programming grammar

“How does the code work?” It's essentially understanding.

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

“A class is a reference type; a structure is a value type”.

But it's not just a grammar to memorize

what values are stored where (stack or heap),

When is it referenced, and at what moment is it disabled

It must be understood in terms of memory structure

It 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 thread)

You can make fatal mistakes, such as UI update errors.

This course provides a structured explanation from a CS perspective.

It's not just about “knowing how to write” the latest grammar,

You can be a developer who can understand why it works the way it does.

An app textbook for this course is also provided.

If you search Swift Grammar Master on the App Store

You can download the teaching app, which allows you to learn by typing in the example sentences of the lecture yourself.

All example sentences include explanations linked to the course content.

We've made it so you can review anytime without notes.

It will be a great tool for quickly browsing and reviewing Swift grammar even after the course is over.

Student benefits

A Starbucks gift card will be provided when writing a review after 100% of the course is completed!

Recommended for people like this

Those learning Swift for the first time but don't know where to start

A person who has gone through grammar and still blends concepts in their head

Those who want to go through all of Swift and get ready for work in a short time

Lecture reviews

“I wasn't really trying to study hard, but I just left the lecture on and focused on watching until the end...

The tone is very comfortable, and it's kind, but it's not excessive. Once I learned one, I was able to understand the next one, so it was really easy to follow along.”

“There's a story that always comes up when Swift starts. Value types, reference types... Honestly, I wasn't sure even when I looked at them all the time, but this time I got a sense of it. I think it stuck in my head because it didn't just show justice, but also told me why it happened.”

“Arrays and dictionaries alone really have a lot of features.

In the past, I used to only roughly write what I needed,

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

It was nice that the example sentences were short and simple, so it wasn't burdensome, and the explanations were uncomplicated.”

“At first, 1 minute per concept? Is this possible? I wanted to,

It wasn't burdensome at all because they picked up only the parts that needed explanation after listening to it.

It didn't just end quickly; the order was well organized, so there wasn't much confusion in the middle.

I especially felt it when explaining the differences between classes and structures,

It didn't just make me memorize it, it really made me understand it, and I felt like what I learned was connected to each other in my head.”

Curriculum highlights

Basic syntax and data types (9)

Operators (6)

Conditional statements and flow control (6 pieces)

tuples (3)

Loop statement and flow control (10 pieces)

Functions (16)

Optional (10 pieces)

Array (16)

Dictionaries (13)

Set (9 pieces)

Using strings (3)

Enumeration type (Enum) (5 pieces)

Class and structure basics (13)

Properties and methods (14)

Overlay type (1)

ARC (1 piece)

Type checking and conversion (7 pieces)

Extensions (6 pieces)

Protocol (11)

Closures (4 pieces)

Higher-order functions (6 pieces)

Error handling (4 pieces)

Defer door (1 piece)

Asynchronous processing (3)

Generics (3 pieces)

Study guide

If you stick to only 2 principles, you will have unwavering grammar skills.

First, when taking the course, be sure to stop on the screen where the full code is displayed and then try writing it yourself.

This course For efficient learning, we don't interpret every code flow except for new concepts.

If you do that, a lecture that ends in 3 hours will become a 10 hour course.

But there's no need to worry.

Because all example sentences used to learn new concepts are composed only of concepts that have already been learned

You can understand the code flow yourself by simply writing the entire code yourself.

Please be sure to write it yourself.

And secondly, if you don't fully understand the concept, don't move on to the next one.

This course is structured in layers, so if one step is shaken, the next step is also shaken.

Getting started with iOS app monetization, Swift Grammar Master

Getting started with iOS app monetization, Swift Grammar Master