Saltar al contenido
wandres.dev
Iniciar sesión

Swift

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.

40 unidades · 196 temasEmpezar la ruta
  1. 00

    Nivel 0

    1 temas
    1. 01La ontología de Swifthechoen curso
  2. 01

    Nivel 1

    5 temas
    1. 01Setup: Xcode 26 y tu primer códigohechoen curso
    2. 02Variables, tipos y seguridadhechoen curso
    3. 03Opcionales: el corazón de Swifthechoen curso
    4. 04Colecciones: Array, Dictionary y Sethechoen curso
    5. 05Funciones y closureshechoen curso
  3. 02

    Nivel 2

    5 temas
    1. 01Structs vs clases: valor y referenciahechoen curso
    2. 02Enums con superpodereshechoen curso
    3. 03Protocolos y programación orientada a protocoloshechoen curso
    4. 04Genéricos: código que funciona con cualquier tipohechoen curso
    5. 05Manejo de errores y typed throwshechoen curso
  4. 03

    Nivel 3

    5 temas
    1. 01async/await y tareashechoen curso
    2. 02Actores, @MainActor y Sendablehechoen curso
    3. 03Concurrencia estricta de Swift 6 sin dolorhechoen curso
    4. 04Redes: URLSession y Codablehechoen curso
    5. 05Async streams y flujos de valoreshechoen curso
  5. 04

    Nivel 4

    5 temas
    1. 01if, switch y las expresioneshechoen curso
    2. 02guard: la salida tempranahechoen curso
    3. 03defer: ejecutar al salir del ámbitohechoen curso
    4. 04Bucles y rangoshechoen curso
    5. 05Operadores propioshechoen curso
  6. 05

    Nivel 5

    5 temas
    1. 01El modelo de String: grafemas y no byteshechoen curso
    2. 02Índices y Substring: navegar sin romper el textohechoen curso
    3. 03Vistas de la cadena: escalares, UTF-8 y UTF-16hechoen curso
    4. 04Regex literales: expresiones regulares con tiposhechoen curso
    5. 05Formateo y localización: texto que no se concatenahechoen curso
  7. 06

    Nivel 6

    5 temas
    1. 01La jerarquía de protocolos: de Sequence a RandomAccessCollectionhechoen curso
    2. 02Los algoritmos de la stdlib y su complejidad realhechoen curso
    3. 03lazy: la evaluación perezosa de cadenas de transformacioneshechoen curso
    4. 04Slices y ArraySlice: vistas sobre una colección sin copiarhechoen curso
    5. 05Escribir tu propia colección: conformar a Collection con índices propioshechoen curso
  8. 07

    Nivel 7

    5 temas
    1. 01Optional es un enum, no una anotaciónhechoen curso
    2. 02Desenvolver bien: if let, guard let y switchhechoen curso
    3. 03Transformar sin desenvolver: map, flatMap y el encadenamientohechoen curso
    4. 04El force unwrap: cuándo es legítimo y cómo justificarlohechoen curso
    5. 05Diseñar con opcionales: cuándo sí y cuándo esconden un enumhechoen curso
  9. 08

    Nivel 8

    5 temas
    1. 01Closures como valoreshechoen curso
    2. 02La captura: qué recuerda un closurehechoen curso
    3. 03La lista de capturahechoen curso
    4. 04@escaping: el closure que sobrevivehechoen curso
    5. 05@autoclosure y closures como control de flujohechoen curso
  10. 09

    Nivel 9

    5 temas
    1. 01Copiar frente a compartir: qué ocurre al asignarhechoen curso
    2. 02mutating: la mutación como firma, no como permisohechoen curso
    3. 03inout: pasar por referencia sin usar claseshechoen curso
    4. 04Cuándo class y cuándo struct: identidad frente a valorhechoen curso
    5. 05Tipos híbridos: el struct que contiene una clasehechoen curso
  11. 10

    Nivel 10

    5 temas
    1. 01Enums con valores asociados: el tipo sumahechoen curso
    2. 02indirect: enums recursivos, árboles y expresioneshechoen curso
    3. 03Raw values y CaseIterable: el dominio como datohechoen curso
    4. 04Pattern matching completo: la gramática de los patroneshechoen curso
    5. 05Modelar el dominio: estados inválidos irrepresentableshechoen curso
  12. 11

    Nivel 11

    5 temas
    1. 01Protocolos como contrato: requisitos y conformidadhechoen curso
    2. 02Extensiones con implementación por defecto y el peligro del despacho estáticohechoen curso
    3. 03associatedtype y Self: protocolos con requisitos de tipohechoen curso
    4. 04Composición y refinamiento: combinar protocolos y acotar extensioneshechoen curso
    5. 05Los límites de POP: cuándo un enum o una clase son mejoreshechoen curso
  13. 12

    Nivel 12

    5 temas
    1. 01Restricciones de tipo: genéricos con contratohechoen curso
    2. 02Cláusulas where: restricciones sobre tipos asociadoshechoen curso
    3. 03Conformidad condicional: heredar capacidades del parámetrohechoen curso
    4. 04Especialización: cómo el compilador convierte un genérico en código concretohechoen curso
    5. 05Genéricos variádicos: parameter packs y eachhechoen curso
  14. 13

    Nivel 13

    5 temas
    1. 01El protocolo que no podía ser un tipohechoen curso
    2. 02some: el tipo que el compilador conoce y tú nohechoen curso
    3. 03any: la caja que puede contener a cualquierahechoen curso
    4. 04Cuándo cada uno: la regla y los casos forzadoshechoen curso
    5. 05Por dentro: tablas de testigos y contenedores existencialeshechoen curso
  15. 14

    Nivel 14

    5 temas
    1. 01Qué es un property wrapper: envolver el acceso a una propiedadhechoen curso
    2. 02Escribir el tuyo: validar, persistir, registrarhechoen curso
    3. 03projectedValue y el dólar: la segunda cara del wrapperhechoen curso
    4. 04Los wrappers que ya usas: State, Binding, Environmenthechoen curso
    5. 05Límites y alternativas: dónde el wrapper no llegahechoen curso
  16. 15

    Nivel 15

    5 temas
    1. 01Qué es un result builder: de un bloque de sentencias a un valorhechoen curso
    2. 02Los métodos del builder: qué habilita cada unohechoen curso
    3. 03Escribir tu propio DSL: un constructor de HTML paso a pasohechoen curso
    4. 04Cómo funciona SwiftUI: el ViewBuilder por dentrohechoen curso
    5. 05Límites y diagnóstico: errores crípticos y tiempos de compilaciónhechoen curso
  17. 16

    Nivel 16

    5 temas
    1. 01Qué es una macro de Swift: código que genera códigohechoen curso
    2. 02Freestanding y attached: los dos tipos y sus roleshechoen curso
    3. 03SwiftSyntax: manipular el árbol y escribir tu primera macrohechoen curso
    4. 04Empaquetar y usar: el target de macro, el plugin y el consumidorhechoen curso
    5. 05Depurar e inspeccionar: expandir, testear y conocer los límiteshechoen curso
  18. 17

    Nivel 17

    5 temas
    1. 01El modelo de errores de Swift: propagación explícita, no excepcioneshechoen curso
    2. 02typed throws: declarar qué error puede salirhechoen curso
    3. 03Result: el error como dato y el puente entre dos mundoshechoen curso
    4. 04rethrows: lanzar solo si tu clausura lanzahechoen curso
    5. 05Diseñar la jerarquía de errores: dominio, técnica y fronterahechoen curso
  19. 18

    Nivel 18

    5 temas
    1. 01Automatic Reference Counting: el compilador que cuenta por tihechoen curso
    2. 02Ciclos de retención: cuando dos objetos se sostienen mutuamentehechoen curso
    3. 03weak y unowned: romper el ciclo sin romper el programahechoen curso
    4. 04deinit y el ciclo de vida: cuándo muere realmente un objetohechoen curso
    5. 05Diagnosticar fugas: grafo de memoria, Instruments y pruebas automáticashechoen curso
  20. 19

    Nivel 19

    5 temas
    1. 01El truco: compartir el almacenamiento hasta que alguien escribehechoen curso
    2. 02isKnownUniquelyReferenced: la función que hace posible el COWhechoen curso
    3. 03Implementar copy-on-write en tu propio tipohechoen curso
    4. 04Cuándo el copy-on-write te traicionahechoen curso
    5. 05Medir: comprobar si tu tipo copia y si el COW merece la penahechoen curso
  21. 20

    Nivel 20

    5 temas
    1. 01Por qué ownership en Swift: el precio de la copia implícitahechoen curso
    2. 02borrowing y consuming: la convención hecha explícitahechoen curso
    3. 03Tipos no copiables: el valor con un solo dueñohechoen curso
    4. 04deinit en estructuras no copiables: RAII sin claseshechoen curso
    5. 05Comparación con Rust: lo compartido y la divergencia deliberadahechoen curso
  22. 21

    Nivel 21

    5 temas
    1. 01La familia de punteros: leer el nombre y saber qué prometehechoen curso
    2. 02Buffers: la dirección y la cuenta convertidas en un tipohechoen curso
    3. 03Reservar y liberar a mano: el ciclo completo sin ARChechoen curso
    4. 04Las funciones withUnsafe: un préstamo con fecha de caducidadhechoen curso
    5. 05Comportamiento indefinido: las reglas que Swift asume sin verificarhechoen curso
  23. 22

    Nivel 22

    5 temas
    1. 01Importar C: cuando una cabecera se vuelve un módulohechoen curso
    2. 02Interoperabilidad con C++: lo que llega y lo que se quedahechoen curso
    3. 03Objective-C desde Swift: el puente que ya estaba puestohechoen curso
    4. 04Swift desde Objective-C: la cabecera generada y sus límiteshechoen curso
    5. 05Diseñar la frontera: envolver C con un tipo que se cuida solohechoen curso
  24. 23

    Nivel 23

    5 temas
    1. 01La promesa: del bug fantasma al error de compilaciónhechoen curso
    2. 02Sendable: el pasaporte de los tiposhechoen curso
    3. 03Dominios de aislamiento: quién protege quéhechoen curso
    4. 04Aislamiento por regiones: enviar lo que no es Sendablehechoen curso
    5. 05Migrar código legado sin naufragarhechoen curso
  25. 24

    Nivel 24

    5 temas
    1. 01El actor como tipo: estado que se defiende solohechoen curso
    2. 02Reentrada: el actor atiende a otro mientras tú esperashechoen curso
    3. 03Global actors: `@MainActor` y el arte de aislar un dominio enterohechoen curso
    4. 04`nonisolated` y parámetros `isolated`: escapes con permisohechoen curso
    5. 05Diseñar con actores: granularidad, cuellos de botella y falsas solucioneshechoen curso
  26. 25

    Nivel 25

    5 temas
    1. 01AsyncSequence: la secuencia que ocurre en el tiempohechoen curso
    2. 02AsyncStream: convertir callbacks en secuenciashechoen curso
    3. 03Contrapresión y buffering: cuando los ritmos no cuadranhechoen curso
    4. 04Operadores: transformar sin romper la cadenahechoen curso
    5. 05Cancelación y limpieza: cerrar bien un flujohechoen curso
  27. 26

    Nivel 26

    5 temas
    1. 01El árbol de tareas: concurrencia que no deja huérfanoshechoen curso
    2. 02async let: paralelismo declarativo para un número fijo de trabajoshechoen curso
    3. 03TaskGroup: paralelismo dinámico con resultados y erroreshechoen curso
    4. 04Task y Task.detached: salir del árbol y qué cuestahechoen curso
    5. 05Cancelación cooperativa: pedir, observar y limpiarhechoen curso
  28. 27

    Nivel 27

    5 temas
    1. 01Ubicación transparente: llamar a un actor que quizá no está aquíhechoen curso
    2. 02El sistema de actores: identidad, resolución y transportehechoen curso
    3. 03Serialización, errores de transporte y la latencia como material de diseñohechoen curso
    4. 04Clústeres: la implementación de referencia, el descubrimiento y la vigilanciahechoen curso
    5. 05Cuándo usarlos: procesos vecinos, dispositivos que se hablan y por qué esto no sustituye a una API HTTPhechoen curso
  29. 28

    Nivel 28

    5 temas
    1. 01Package.swift: el manifiesto es un programahechoen curso
    2. 02Control de acceso: seis niveles y dos fronterashechoen curso
    3. 03Resolución de dependencias: una versión y solo unahechoen curso
    4. 04Plugins de SPM: generar código sin perder la reproducibilidadhechoen curso
    5. 05Diseñar la librería: la API es una promesa fechadahechoen curso
  30. 29

    Nivel 29

    5 temas
    1. 01El framework moderno: la macro que sustituyó a la herenciahechoen curso
    2. 02Precondición y verificación: el papel de requirehechoen curso
    3. 03Tests parametrizados: un cuerpo, muchos casoshechoen curso
    4. 04Suites y traits: organizar y condicionar la ejecuciónhechoen curso
    5. 05Probar código asíncrono, actores y la convivencia con XCTesthechoen curso
  31. 30

    Nivel 30

    5 temas
    1. 01Por qué Swift en el servidor: el argumento honestohechoen curso
    2. 02SwiftNIO: el motor que hay debajo de todohechoen curso
    3. 03Vapor y Hummingbird: elegir framework con criteriohechoen curso
    4. 04Desplegar en Linux: enlazado estático e imágenes mínimashechoen curso
    5. 05El ecosistema en 2026: qué está maduro y dónde apostarhechoen curso
  32. 31

    Nivel 31

    5 temas
    1. 01Qué es Embedded Swift: el lenguaje sin su runtimehechoen curso
    2. 02Qué se pierde: el subconjunto y su lógica internahechoen curso
    3. 03Compilar para un microcontrolador: toolchain, enlazador y binariohechoen curso
    4. 04Interoperar con C a bajo nivel: registros, interrupciones y tiposhechoen curso
    5. 05El caso de uso: seguridad de memoria en firmware, frente a C y a Rusthechoen curso
  33. 32

    Nivel 32

    5 temas
    1. 01Qué es realmente portable: el mapa por capashechoen curso
    2. 02Swift en Linux: toolchain, Foundation y las divergencias silenciosashechoen curso
    3. 03Swift en Windows: el estado real del soportehechoen curso
    4. 04SwiftWasm: compilar a WebAssembly y pagar su preciohechoen curso
    5. 05Escribir código portable: costuras, no condicionales dispersoshechoen curso
  34. 33

    Nivel 33

    5 temas
    1. 01El pipeline: del texto fuente al código máquinahechoen curso
    2. 02SIL: leer la representación intermedia de Swifthechoen curso
    3. 03Optimizaciones clave: especialización, inlining y ARChechoen curso
    4. 04Whole-module optimization: ver el módulo enterohechoen curso
    5. 05Diagnosticar compilaciones lentashechoen curso
  35. 34

    Nivel 34

    5 temas
    1. 01Los tres despachos: estático, por tabla y dinámicohechoen curso
    2. 02Reducir el coste: final, private y tipos concretoshechoen curso
    3. 03inlinable y usableFromInline: exponer el cuerpohechoen curso
    4. 04Asignaciones y ARC en caliente: el impuesto invisiblehechoen curso
    5. 05Benchmarks honestos: medir sin engañartehechoen curso
  36. 35

    Nivel 35

    5 temas
    1. 01Las API Design Guidelines: la claridad mandahechoen curso
    2. 02Nombrar bien: etiquetas, verbos y el par que mutahechoen curso
    3. 03Diseñar para el consumidor: defectos y tipos que blindanhechoen curso
    4. 04Documentar: comentarios, DocC y ejemplos que compilanhechoen curso
    5. 05Evolucionar sin romper: compatibilidad y deprecaciónhechoen curso
  37. 36

    Nivel 36

    5 temas
    1. 01El proceso: del pitch a la decisiónhechoen curso
    2. 02Leer una propuesta como se debehechoen curso
    3. 03Las decisiones que definieron el lenguajehechoen curso
    4. 04Language modes: romper sin partir el ecosistemahechoen curso
    5. 05Seguir el lenguaje y participar en élhechoen curso
  38. 37

    Nivel 37

    5 temas
    1. 01El `!` no es el error: es el recibo de un modelo mal hechohechoen curso
    2. 02Clases donde tocaba struct: identidad accidental y estado compartidohechoen curso
    3. 03Retenciones accidentales: el closure, el delegado y el timer inmortalhechoen curso
    4. 04Concurrencia mal entendida: tareas huérfanas, `@MainActor` de parche y colas heredadashechoen curso
    5. 05Sobreingeniería con genéricos y protocolos: la abstracción que nadie necesitabahechoen curso
  39. 38

    Nivel 38

    5 temas
    1. 01Swift y Rust: la memoria como contratohechoen curso
    2. 02Swift y Kotlin: dos herederos con el mismo encargohechoen curso
    3. 03Swift y Go: simplicidad contra expresividadhechoen curso
    4. 04Swift y C++: interoperar, generalizar, sucederhechoen curso
    5. 05Elegir con criterio: dónde gana Swift y dónde nohechoen curso
  40. 39

    Nivel 39

    5 temas
    1. 01El modelo mental completo: una sola imagen de todo Swifthechoen curso
    2. 02Decisiones de diseño en código real: leer una API de la stdlibhechoen curso
    3. 03Leer el código fuente de Swift: navegar la stdlib y aprender de quien la escribióhechoen curso
    4. 04El lenguaje que viene: ownership, macros, embedded y concurrenciahechoen curso
    5. 05Un plan de dominio continuo: profundizar, contribuir y no quemarsehechoen curso