мобильная
разработка

Что важно знать:

• понимать принципы отличия value и reference типов(ИЛИ понимать value и reference семантику, знать примеры value/ref типов), механизм Copy-on-Write для коллекций(понимать, что стандартные коллекции (Array, Dictionary, String) имеют семантику типа-значения (value semantics), а Copy-on-Write — это механизм оптимизации, который лежит в основе их эффективной работы)
• знать, зачем нужны Optionals, правила их безопасного использования и разворачивания(владеть техниками безопасного разворачивания (if let, guard let, optional chaining, nil-coalescing operator ??) понимать, почему force unwrap (!) — плохая практика в большинстве случаев);
• разбираться в основах работы с замыканиями, понимать разницу между escaping и non-escaping(знать примеры, когда использование @escaping обязательно).

Типичные проблемы:

• поверхностное понимание разницы между value и reference (например, ошибки при работе с массивами классов и структур, неверные рассуждения о Copy-on-Write);
• некорректное использование Optionals (force unwrap без проверки), путаница в ошибках компиляции и рантайма; формальное знание терминов (retain cycle), но слабое применение на практике (например, неумение определить, где он возникает).
• Формальное знание термина @escaping, но неумение объяснить на практике, когда он необходим (например, в асинхронных операциях или при сохранении замыкания в свойство для последующего вызова).

Как практиковаться:

• написать и сравнить два куска кода: с массивами структур и с массивами классов, отслеживать изменения при внесении данных по ссылке;
• написать пример кода, который демонстрирует поведение Copy-on-Write для массива, и с помощью функции isKnownUniquelyReferenced проверить, когда происходит копирование
• практиковать различные способы разворачивания Optionals (if let, guard let, optional chaining, ?? ); Попробовать написать функцию, которая принимает опциональное значение и безопасно с ним работает.
• выполнять упражнения на понимание escaping: объяснить, где он нужен (например, при сохранении closure в свойствах класса).

Полезные ресурсы:

• Hacking with Swift: Swift fundamentals / перейти

• The Swift Programming Languages / перейти

• книги и статьи, посвящённые основам языка и продвинутым концепциям.

Что важно знать:

• механику ARC, различия между strong, weak и unowned ссылками;
• жизненный цикл объектов, типичные ситуации возникновения retain cycles (например, два объекта, ссылающихся друг на друга (например, через делегаты)), и замыкание, захватившее self, которое хранится в свойстве этого же self;
• возможные побочные эффекты при захвате (strong/weak) self и случаи использования [weak self].

Типичные проблемы:

• неумение обнаружить цикл сильных ссылок в коде, несмотря на знание его определения
• непонимание различий между weak и unowned (например, что weak всегда optional, а unowned требует гарантии существования объекта).

Как практиковаться:

• нарисовать схему retain cycle между двумя классами через свойства и проанализировать, как это влияет на работу ARC(нарисовать схему взаимодействия двух классов, которые создают retain cycle. Проследить, как меняется счетчик ссылок);
• использовать Memory Graph Debugger в Xcode для поиска retain cycles в проекте;
• создать небольшое приложение с двумя классами, имеющими сильные ссылки друг на друга, и проверить, освобождается ли память после удаления объектов.

Полезные ресурсы:

• Официальная документация про ARC / перейти

• Swift Memory Management (Ray Wenderlich) / перейти

• вебинары и видеокурсы на платформах вроде Pluralsight

Что важно знать:

• жизненный цикл UIViewController, различия между UIView и UIViewController, работу с view hierarchy и lazy loading;
• механизм повторного использования ячеек в таблицах и коллекциях (register/dequeueReusableCell);
• ограничения работы с UI (только из main thread). Уметь переключиться на главный поток из фонового (DispatchQueue.main.async)
• различия между frame и bounds, роль методов setNeedsLayout, layoutIfNeeded и layoutSubviews.

Типичные проблемы:

• краши или некорректное поведение из-за обращения к UI вне main thread;
• непонимание механики register/dequeue, попытки ручного инстанцирования ячеек, что приводит к утечкам памяти и подтормаживаниям(непонимание механики dequeueReusableCell, что ведет к созданию лишних ячеек, утечкам памяти и тормозам при скроллинге);
• неверные представления о жизненном цикле UIViewController и различиях между frame и bounds.

Как практиковаться:

• Сверстать экран кодом: Создать простой экран полностью в коде, без Storyboard/XIB. Для позиционирования элементов использовать Auto Layout anchors и ручной подсчет фреймов(два альтернативных подхода).
• создать проект с кастомной таблицей и ячейками, наблюдать за их переиспользованием и ставить точки останова(лучше: в методе cellForRowAt выводить в консоль адрес ячейки, чтобы наглядно увидеть, как они переиспользуются при скроллинге);
• поэкспериментировать с переопределением pointInside и hitTest, чтобы увеличить область нажатия кнопки;
• попробовать обращаться к subviews в конструкторе UIViewController и отслеживать, когда они становятся доступными.

Полезные ресурсы:

• Официальная документация Apple по UIKit; / перейти

• документация по обработке жестов в UIKit / перейти

• видеоуроки и статьи на YouTube, например, плейлист по ссылке

Что важно знать:

• View как struct: Понимать, что View в SwiftUI — это легковесная структура, а не класс. Они постоянно создаются и уничтожаются.
• Управление состоянием (State Management):
• Знать базовые property wrappers для управления данными:
  • @State — для локального, «приватного» состояния внутри View.
  • @Binding — для создания двусторонней связи с состоянием, которое «живет» в другом месте.
  • @StateObject / @ObservedObject — для работы с состоянием, вынесенным в отдельный класс (Reference Type).
  • @Binding — для создания двусторонней связи с состоянием, которое «живет» в другом месте.
• Компоновка интерфейса: Знать базовые контейнеры для компоновки: VStack, HStack, ZStack.
• Списки: Уметь создавать динамические списки с помощью List или ScrollView + ForEach.
• Интеграция с UIKit: Знать, что SwiftUI и UIKit могут сосуществовать. Иметь представление о существовании UIViewRepresentable и UIViewControllerRepresentable для встраивания UIKit-компонентов в SwiftUI.

Типичные проблемы:

• Попытка изменить UI «императивно», как в UIKit (например, найти кнопку и поменять ей цвет), вместо изменения состояния (@State), от которого зависит цвет.
• Путаница в выборе property wrappers: использование @State там, где нужен @Binding, или непонимание разницы между @StateObject (создает и владеет объектом) и @ObservedObject (просто наблюдает за существующим).

Как практиковаться:

• Создать простой экран (например, счетчик с кнопками «+» и «-») с использованием @State.
• Разделить экран на два View: родительский (с @State) и дочерний. Передать состояние в дочерний View через @Binding.
• Сверстать простой список элементов (например, контактов) с помощью List и ForEach.

Полезные ресурсы:

• Apple SwiftUI Tutorials — лучший официальный старт / перейти

• 100 Days of SwiftUI — бесплатный курс от Пола Хадсона / перейти

• Официальная документация по SwiftUI / перейти

Что важно знать:

• основы многопоточности в iOS (main, serial, concurrent очереди, async/await);
• GCD (Grand Central Dispatch):
  • Различать sync (блокирует текущий поток) и async (не блокирует).
  • Знать основные типы очередей: main (серийная, для UI), global (параллельные, для фоновых задач), кастомные serial/concurrent.
• Modern Swift Concurrency:
  • Понимать синтаксис async/await и как он упрощает написание асинхронного кода (избавляет от «пирамиды ада» из колбэков).
  • Знать, что такое Task для запуска асинхронной работы и как TaskGroup помогает выполнять несколько задач параллельно.
• что такое race conditions и deadlocks, как они возникают и как их избегать;
• современный стек инструментов (async/await, Task, TaskGroup)

Типичные проблемы:

• непонимание разницы между async и sync в GCD, например, возникновение deadlock при использовании main.sync в main thread;
• неспособность объяснить, в каком потоке выполняется callback из сетевого запроса, если не гарантирован main thread(непонимание, в каком потоке будет выполнен completion блок асинхронной операции (например, сетевого запроса) и, как следствие, краши из-за обновления UI в фоновом потоке.);
• поверхностные знания о race conditions без реального опыта их обнаружения.

Как практиковаться:

• написать пример deadlock, используя main.sync внутри main.async в main thread;
• реализовать длительную операцию в фоновом режиме (через GCD или global queue) и попытаться обновить UI — обратить внимание на возникающие ошибки и предупреждения;
• Async/Await: Переписать код с «пирамидой колбэков» (например, загрузка данных -> их парсинг -> обновление UI) на async/await.

Полезные ресурсы:

• GCD и основы многопоточности / перейти

• Выпуски WWDC, посвящённые многопоточности и современным подходам к concurrency в Swift; / перейти

• Официальная документация по Swift concurrency / перейти

• Swift Concurrency by Example / перейти

Что важно знать:

• Нужно знать две буквы:
  • S (Single Responsibility): У класса должна быть только одна причина для изменения. Главный пример — борьба с «Massive View Controller», когда сетевая логика, форматирование данных и управление UI свалены в одну кучу.
  • D (Dependency Inversion): Зависеть от абстракций (протоколов), а не от конкретных классов. Практическая реализация этого принципа — Dependency Injection (DI), то есть передача зависимостей (например, сетевого сервиса) в класс извне.
• способы организации зависимостей без создания retain cycles (например, в связке View — Service — ViewController — замыкания);
• основные антипаттерны в MVC (раздувание ViewController, tight coupling, god object).
• Архитектурные паттерны:
  • MVC: Понимать роль каждого компонента (Model, View, Controller) и его главный недостаток в UIKit — склонность к «раздуванию» контроллера.
  • DMVVM: Иметь представление, что это такое и какую проблему MVC он решает (выносит логику и состояние из View Controller в ViewModel).

Типичные проблемы:

• Весь код написан во ViewController (сетевые запросы, обработка данных и т.д.).
• «Жесткое» создание зависимостей внутри класса (let networkService = NetworkService()), что делает код нетестируемым и негибким.
• Неумение объяснить своими словами, что такое «принцип единственной ответственности» на примере ViewController.

Как практиковаться:

• Провести простой рефакторинг: создать класс Model, в котором есть сетевой запрос, и вынести этот запрос в отдельный класс NetworkService.
• Сделать следующий шаг: создать для NetworkService протокол и заставить Model зависеть от этого протокола, а не от конкретного класса. Передавать сервис в контроллер через инициализатор.
• Написал тест на Model и написать мок для NetworkService

Что важно знать:

• понимать и уметь объяснять сложность алгоритмов (O(N), O(1) и т. д.);
• использовать стандартные коллекции, не изобретать собственные решения без необходимости;
• уметь решать алгоритмические задачи, связанные с обработкой строк и массивов.

Практические задания:

• решать задачи на LeetCode, уделяя внимание оценке сложности и использованию памяти;

• практиковаться в решении задач на HackerRank и CodeSignal

• изучать алгоритмы и структуры данных по книгам и онлайн-курсам, например, «Introduction to Algorithms» (Томас К. Кормен и др.).

• пройти базовые курсы на SwiftBook или HackingWithSwift

• смотреть разборы собеседований на YouTube;

• практиковать мини-проекты: работа с таблицами, layout, сетевыми запросами;

• регулярно решать задачи на LeetCode;

• просматривать выпуски WWDC, например, «What’s new in Swift» и «Modern concurrency in Swift»;

• изучать официальную документацию Apple.

Coderun / перейти

LeetCode / перейти

Яндекс.Стажировка: тренировка алгоритмов / перейти

Полезные материалы от Яндекс.Стажировки / перейти

Открытые лекции от Яндекс.Стажировки / перейти

Yatalks / перейти

Статьи на Habr от Яндекса / перейти

Образование от Яндекса / перейти

YouTube-канал Young and Yandex / перейти

Telegram-канал Young and Yandex / перейти

Язык Swift: основы синтаксиса, Optionals, Value/Reference semantics.

• освежить знания основ синтаксиса Swift, повторить базовые конструкции языка;
• изучить и попрактиковать работу с Optionals: разобраться в правилах безопасного использования и разворачивания (if let, guard let, optional chaining, ??);

Теория:

• Основы: синтаксис, типы данных.
• Optionals: if let, guard let, ??, !.
• Value/Reference семантика (struct vs class). Понятие Copy-on-Write.
• Замыкания: синтаксис, @escaping.

Практика:

• Написать функцию, которая безопасно работает с опционалами.
• Написать два примера: с изменением массива структур и массива классов, чтобы увидеть разницу.
• Объяснить вслух, в чем разница между struct и class.

Ресурсы:

• Hacking with Swift, официальные туториалы по Swift.

• углубиться в понимание разницы между value и reference типами, попрактиковаться с массивами структур и классов;
• выполнить упражнение: написать и сравнить два куска кода — с массивами структур и с массивами классов, отслеживать изменения при внесении данных по ссылке;
• прочитать про механизм Copy-on-Write для коллекций.

Управление памятью: ARC, retain cycles, ссылки.

• изучить механику ARC, различия между strong, weak и unowned ссылками;
• ознакомиться с официальной документацией про ARC;
• понять, как возникают retain cycles и как их избегать.

Теория:

• ARC: strong, weak, unowned.
• Retain Cycles: как возникают (делегаты, замыкания).
• Принципы S и D из SOLID. Dependency Injection (DI).
• Антипаттерн «Massive View Controller».

Практика:

• Создать два класса с сильными ссылками, увидеть утечку через deinit, исправить с помощью weak.
• Взять простой проект и вынести сетевой код из ViewController в отдельный NetworkService. Передать его в контроллер через инициализатор (это и есть DI).
• Написать простой Unit-тест для этого сервиса с помощью «мока».

UI и Многопоточность

Теория:

• Жизненный цикл UIViewController (viewDidLoad, viewWillAppear и т.д.).
• UITableView и переиспользование ячеек (dequeueReusableCell).
• Основы GCD: DispatchQueue.main.async, global(). Правило «UI обновляется в главном потоке».
• Основы async/await: как более современная альтернатива GCD.

Практика:

• Создать таблицу, которая загружает данные из сети.
• Сначала сделать «неправильно»: выполнить сетевой запрос в главном потоке и увидеть, как UI «зависает».
• Затем «исправить»: вынести запрос в фоновый поток (global queue или Task), а обновление таблицы (массива данных и tableView.reloadData()) вернуть в главный (main queue).

• попрактиковаться в использовании Memory Graph Debugger в Xcode для поиска retain cycles;
• создать небольшое приложение с двумя классами, имеющими сильные ссылки друг на друга, и проверить, освобождается ли память после удаления объектов;
• почитать Swift Memory Management (Ray Wenderlich).

Работа с UI: UIKit и основы layout.

• повторить жизненный цикл UIViewController, различия между UIView и UIViewController;
• разобраться в механизме повторного использования ячеек в таблицах и коллекциях (register/dequeueReusableCell);
• ознакомиться с официальной документацией по UIKit.

• посмотреть несколько видеоуроков на YouTube по теме UIKit и layout, например, из плейлиста;
• начать проект с кастомной таблицей и ячейками, понаблюдать за их переиспользованием.

Многопоточность: GCD, OperationQueue, modern Swift Concurrency.

Повторить то, что изучали до этого, и отдохнуть перед собеседованием!

• каждый день выделять время на решение задач на LeetCode или HackerRank — это поможет держать ум в тонусе и улучшит алгоритмическое мышление;
• просмотреть 1–2 выпуска WWDC, посвящённых темам, которые вызывают затруднения;
• если остаётся время, уделить внимание принципам ООП, SOLID и архитектуре приложений — это добавит вам уверенности в понимании общей картины разработки.
• Такой план позволит вам систематизировать знания и сосредоточиться на самых важных аспектах, которые часто проверяют на собеседованиях. Удачи в подготовке!

Язык Swift: основы синтаксиса, Optionals, Value/Reference semantics.

• тщательно повторить основы синтаксиса Swift, уделить внимание сложным конструкциям и нюансам языка;
• подробно изучить работу с Optionals: все способы разворачивания, типичные ошибки и способы их избежать;

Ресурсы:

• Hacking with Swift, официальные туториалы по Swift.

• глубоко разобраться в различиях между value и reference типами, понять механизм Copy-on-Write для коллекций;
• выполнить ряд упражнений: сравнить поведение массивов со структурами и классами, попробовать вручную реализовать Copy-on-Write для собственного типа;
• попрактиковать различные способы работы с массивами и другими коллекциями.

Управление памятью: ARC, retain cycles, ссылки.

• детально изучить механику ARC, разобраться в различиях между strong, weak и unowned ссылками;
• ознакомиться с официальной документацией про ARC;
• понять, как возникают и как устраняются retain cycles.

• активно использовать Memory Graph Debugger в Xcode для анализа и поиска retain cycles в проектах;
• создать несколько приложений с разными сценариями использования ссылок, проверить, как ведёт себя память;
• прочитать Swift Memory Management (Ray Wenderlich) и разобрать примеры.

Работа с UI: UIKit и основы layout.

• подробно разобрать жизненный цикл UIViewController, понять различия между UIView и UIViewController;
• изучить механизмы работы с view hierarchy и lazy loading, разобраться в register/dequeueReusableCell;
• ознакомиться с официальной документацией по UIKit и обработке жестов.

• посмотреть серию видеоуроков на YouTube по теме UIKit и layout, например, из плейлиста;
• начать и завершить проект с кастомной таблицей и ячейками, понаблюдать за их 
• переиспользованием, поэкспериментировать с pointInside и hitTest.

Многопоточность: GCD, OperationQueue, modern Swift Concurrency.

• глубоко изучить основы многопоточности в iOS, разобраться в различиях между main, serial, concurrent очередями;
• ознакомиться с официальной документацией по Swift concurrency и GCD;
• просмотреть выпуски WWDC, посвящённые многопоточности и modern concurrency.

• реализовать несколько задач с использованием GCD и modern Swift Concurrency, обновить UI из фонового потока;
• пройти туториал по modern concurrency;
• порешать задачи, связанные с многопоточностью, чтобы выявить и устранить пробелы в знаниях.

Дополнительные темы: работа с коллекциями, ООП, SOLID, архитектура.

• разобраться в различиях семантики value и reference для коллекций, понять типичные ошибки при копировании массивов;
• прочитать материалы о работе с коллекциями на Hacking with Swift.

• изучить принципы ООП и SOLID, понять, как они применяются в iOS-разработке;
• разобрать примеры чистой архитектуры для iOS, подумать, как разделить приложение на слои;
• попробовать разработать простое приложение с учётом принципов SOLID.

• повторить ключевые моменты всех тем;
• порешать задачи на LeetCode и HackerRank, чтобы освежить алгоритмическое мышление;
• просмотреть ещё раз сложные моменты и темы, которые вызвали затруднения.

• каждый день выделять время на решение алгоритмических задач и практику кодирования;
• вести заметки по сложным темам и регулярно их пересматривать;
• участвовать в онлайн-сообществах и форумах, задавать вопросы, если что-то непонятно;
• попробовать объяснить сложные концепции кому-нибудь (или самому себе вслух) — это поможет лучше усвоить материал.

Лекции Школы мобильной разработки, Flutter — 2024 / перейти

Плейлисты DartUp — 2020 / перейти

Dart / перейти

Flutter / перейти

Блог didierboelens.com. Особенно рекомендуем статьи о дереве виджетов, асинхронном программировании в Dart и изолятах / перейти

Awesome Flutter / перейти

Основы управления состояниями во Flutter / перейти

Подходы по управлению состояниями / перейти