Swift 6 a fondo: el modelo de tipos y valores, protocolos y genéricos, macros y result builders, memoria y ownership, concurrencia estricta, y Swift fuera de Apple.
Cada nivel construye sobre el anterior. Sin saltos, sin huecos.
La visión aérea del lenguaje: el modelo de tipos y valores, protocolos y genéricos, concurrencia estructurada, macros, memoria y el ecosistema.
La base del lenguaje: instalar el toolchain, tipos y variables, opcionales (el corazón de Swift), colecciones, funciones y closures.
Structs vs clases, enums con valores asociados, protocolos, genéricos y el manejo de errores con typed throws.
La concurrencia moderna: async/await, actores, Sendable, la concurrencia estricta de Swift 6, streams y redes con URLSession.
El resto de la sintaxis: control de flujo, `guard`, `defer`, bucles con etiquetas, operadores propios y precedencia.
El tipo String de Swift: grafemas frente a bytes, índices, `Substring`, expresiones regulares y formateo localizado.
La jerarquía de Collection: Sequence, Collection, RandomAccess; algoritmos, `lazy`, y escribir tu propia colección.
Todo sobre los opcionales: encadenamiento, `map`/`flatMap`, `guard let`, los peligros del force unwrap y el diseño de APIs opcionales.
Funciones de primera clase: captura de variables, `@escaping`, `@autoclosure`, closures que retienen, y funciones anidadas.
La diferencia profunda entre value types y reference types: copia, identidad, mutabilidad, y cómo elegir en cada caso.
Enums indirectos, genéricos, con raw values; modelar estados imposibles fuera del dominio y el pattern matching completo.
Programación orientada a protocolos: extensiones con implementación por defecto, requisitos asociados, y dónde el enfoque se rompe.
Genéricos en serio: cláusulas `where`, especialización, tipos condicionalmente conformes y el sistema de resolución.
Los dos modos de abstracción: tipos opacos (`some`) y existenciales (`any`); su coste en rendimiento y cuándo usar cada uno.
Property wrappers: cómo funcionan, escribir el tuyo, `projectedValue`, y los que ya usas sin saberlo en SwiftUI.
Result builders: la magia detrás de SwiftUI; construir tu propio DSL declarativo y entender qué genera el compilador.
Las macros de Swift: freestanding y attached, SwiftSyntax, escribir una macro propia y depurar su expansión.
El sistema de errores: `typed throws`, `Result`, `rethrows`, diseñar jerarquías de error y la conversión en las fronteras.
Automatic Reference Counting: retain/release, ciclos de retención, `weak` y `unowned`, y diagnosticar fugas.
Cómo Swift hace baratos los value types: copy-on-write, `isKnownUniquelyReferenced`, y escribir tus propios tipos COW.
El modelo de ownership de Swift: `borrowing`, `consuming`, tipos no copiables (`~Copyable`), y su parentesco con Rust.
Las APIs unsafe: punteros tipados y crudos, buffers, gestión manual de memoria, y cuándo se justifica salir del jardín.
Swift con el mundo exterior: importar C y C++, el puente con Objective-C, y exponer Swift a otros lenguajes.
La concurrencia estricta de Swift 6: aislamiento de actores, `Sendable`, regiones de aislamiento, y migrar código legado.
Actores en serio: `@MainActor`, global actors propios, reentrada, prioridad, y los errores de diseño más comunes.
Secuencias asíncronas: `AsyncStream`, `AsyncThrowingStream`, escribir la tuya, backpressure y cancelación.
La estructura del paralelismo: `Task`, `TaskGroup`, `async let`, herencia de prioridad, cancelación cooperativa y `withTaskCancellationHandler`.
Actores distribuidos: el modelo, los sistemas de actores, serialización, y su uso en sistemas repartidos entre procesos.
Swift Package Manager: paquetes, targets, dependencias, control de acceso entre módulos y binarios precompilados.
El nuevo framework de testing: `@Test`, `#expect`, parametrización, traits, y la migración desde XCTest.
Swift fuera de Apple: servidores con Vapor o Hummingbird, SwiftNIO por debajo, y desplegar en Linux con Docker.
Embedded Swift: el subconjunto para microcontroladores y entornos restringidos; qué se pierde y qué se gana.
El estado real fuera de Apple: la biblioteca estándar, Foundation en Linux, Windows, y WebAssembly.
Cómo compila Swift: el pipeline hasta SIL, la especialización de genéricos, el whole-module optimization, y leer el SIL generado.
Optimizar Swift: Instruments, el coste de los existenciales y del dispatch dinámico, `@inlinable`, y los benchmarks honestos.
Las API Design Guidelines de Swift: nombrar con claridad, argumentos etiquetados, y diseñar bibliotecas que se leen como prosa.
El proceso de evolución: leer una propuesta, entender por qué se aceptó, y seguir hacia dónde va Swift.
Los tropiezos clásicos: abuso de opcionales, clases donde tocaba struct, retención accidental y la concurrencia mal entendida.
Situar Swift entre sus pares: seguridad de memoria frente a Rust, ergonomía frente a Kotlin, simplicidad frente a Go.
La síntesis: el modelo mental unificado de Swift, decisiones de diseño en código real, y un plan de dominio continuo.
El lenguaje moderno de Apple: opcionales, protocolos, genéricos y typed throws.
Construye interfaces con estado reactivo: describe el qué, no el cómo.
El framework Observation: estado reactivo sin boilerplate, con @State como macro.
Persistencia con @Model y @Query: sin .xcdatamodeld ni NSManagedObject.
async/await, actores y Sendable con concurrencia estricta que previene data races.
URLSession con async/await y Codable para consumir APIs sin dolor.
El nuevo framework de tests con @Test y #expect, más expresivo que XCTest.
Arquitectura, firmas, TestFlight y publicación: de la idea a la tienda.
Empieza por los fundamentos y sube nivel a nivel hasta el dominio total.
Comenzar el camino →