Swift Pills

Estado en SwiftUI: fuentes de verdad, bindings y errores que aparecen cuando la vista empieza a crecer

Wed, 03 Jun 2026 08:00:00 +0100

🧭 En SwiftUI, casi todos los problemas de con el estado empiezan igual: una pantalla pequeña funciona perfectamente, se añaden dos o tres interacciones más, aparece una vista hija, luego otra, y de pronto algo deja de actualizarse, se reinicia cuando no debería o se comparte entre vistas de forma inesperada. No suele ser un fallo de SwiftUI, sino una señal de que la fuente de verdad no está colocada en el sitio correcto.

Background App Refresh en SwiftUI: actualiza datos sin abrir la app

Tue, 02 Jun 2026 06:00:00 +0100

🔄 Las tareas en segundo plano son una de esas capacidades de iOS que parecen sencillas hasta que intentas implementar alguna de ellas. La idea es muy tentadora: permitir que una app actualice datos, limpie cachés o prepare contenido aunque el usuario no la tenga en primer plano. En SwiftUI, además, Apple ofrece una integración bastante cómoda mediante el modificador .backgroundTask, pero eso no significa que el sistema vaya a ejecutar nuestro código cuando queramos ni durante todo el tiempo que nos gustaría.

Sheets en SwiftUI que se ajustan automáticamente a su contenido

Sun, 31 May 2026 10:00:00 +0100

📐 Las sheet de SwiftUI funcionan muy bien cuando aceptas los tamaños que el sistema propone. El problema aparece cuando tu interfaz no encaja en niguno de esos tamaños. Una vista pequeña queda flotando dentro de un sheet demasiado alto. Una vista algo más grande puede quedar cortada. Y una pantalla que solo necesita presentar una confirmación breve termina ocupando gran parte de la pantalla sin necesidad.

Desde iOS 16, SwiftUI permite controlar la altura de una hoja con presentationDetents, usando valores como .medium, .large, .height(...) o .fraction(...). Es una mejora enorme frente al comportamiento inicial de los sheets, pero sigue teniendo una limitación importante: no existe un detent nativo que diga simplemente “mide el contenido y usa esa altura”.

Formatear valores en SwiftUI: menos String, más intención

Sat, 23 May 2026 09:00:00 +0200

🧩 En SwiftUI es muy tentador convertirlo todo a String antes de pintarlo en pantalla. Un número se interpola, una fecha se pasa por un DateFormatter, una cantidad se concatena con un símbolo de moneda y un porcentaje se multiplica a mano. Funciona, sí, pero también es una forma rápida de llenar la interfaz de pequeños futuros problemas: separadores decimales incorrectos, indicador de divisa mal colocados, fechas que resultan poco naturales o campos de texto que aceptan valores imposibles.

ARC y zombies en Swift

Sun, 17 May 2026 10:00:00 +0100

🧠 ARC (Automatic Reference Counting) lleva con nosotros desde el primer día en Swift, pero la mayoría de desarrolladores solo conoce su capa exterior: los objetos se retienen, se liberan y se destruyen cuando el contador llega a cero. Lo que muy pocos saben es que el modelo interno ha cambiado de forma significativa desde las primeras versiones del lenguaje. Esos cambios no son detalles de implementación irrelevantes: explican por qué ciertas decisiones de diseño tienen un coste, y por qué el runtime se comporta de una manera u otra en situaciones límite.

`.refreshable` en SwiftUI: por qué tu tarea se cancela sola (y cómo evitarlo)

Thu, 14 May 2026 10:00:00 +0100

🔄 .refreshable es uno de esos modificadores de SwiftUI que parece trivial hasta que algo falla de forma inexplicable. Lo añades a una lista, le pasas tu función async, y todo funciona en el simulador. Pero en producción, o simplemente bajo condiciones ligeramente distintas, la carga se interrumpe a la mitad, el indicador de refresco desaparece antes de tiempo, o una petición de red lanza un error. El origen del problema casi nunca está donde lo buscas.

onChange() en SwiftUI: reacciona a cambios con precisión

Wed, 13 May 2026 10:00:00 +0100

🔔 El modificador onChange() es la herramienta de SwiftUI para ejecutar código en respuesta a cambios de valor. Observa una propiedad concreta y dispara un closure cada vez que su contenido varía. Para determinar si el valor ha cambiado, el tipo observado debe conformar Equatable, lo que permite a SwiftUI realizar la comparación de forma automática y eficiente. Desde su introducción en iOS 14 hasta las revisiones de iOS 17, la API ha madurado considerablemente, y conocer sus variantes actuales marca la diferencia entre código predecible y comportamientos inesperados.

Enums en Swift: mucho más que una lista de constantes

Sat, 09 May 2026 09:00:00 +0100

🃏 Si vienes de Objective-C, Java o cualquier lenguaje donde un enum es básicamente un entero con nombre bonito, Swift va a sorprenderte. Los enums de Swift son tipos de datos muy completos: pueden transportar información propia en cada caso, tener métodos y propiedades computadas, conformar protocolos y modelar estructuras recursivas. Son una de las herramientas más expresivas del lenguaje, y no usarlas en todo su potencial es dejar sobre la mesa una ventaja real de diseño.

Parámetros inout en Swift: mutación controlada y diseño de API

Thu, 07 May 2026 07:00:00 +0100

🔒 Swift está diseñado para favorecer la inmutabilidad por defecto. Los parámetros de una función son constantes, lo que evita efectos secundarios accidentales y simplifica el razonamiento sobre el código. Pero hay situaciones en las que necesitas que una función modifique directamente el valor que recibe, no que devuelva una copia transformada. Para eso existe inout.

🔄 El mecanismo interno de inout no es paso por referencia al estilo de C o C++, aunque lo parezca. Swift implementa un modelo llamado copy-in copy-out: al llamar a la función, el valor se copia en un almacenamiento local; la función opera sobre esa copia; y al retornar, el valor modificado se escribe de vuelta en la variable original. El compilador puede optimizar este proceso usando directamente la dirección de memoria original cuando es seguro hacerlo, pero el contrato semántico sigue siendo el de copia.

Propiedades lazy en Swift: qué son, cómo funcionan y por qué fallan en SwiftUI

Sat, 25 Apr 2026 20:00:00 +0100

💤 Una propiedad lazy en Swift es una propiedad almacenada cuyo valor no se calcula hasta que se accede a ella por primera vez. A diferencia de las propiedades almacenadas habituales, que se inicializan en el momento en que se crea la instancia, las propiedades lazy difieren ese trabajo hasta que realmente se necesita. La sintaxis es directa: basta con anteponer la palabra clave lazy a una declaración de var.

associatedtype en Swift: el mecanismo que hace posible la abstracción genérica en protocolos

Mon, 20 Apr 2026 10:00:00 +0200

🧩 associatedtype es una de esas características del sistema de tipos de Swift que pasan desapercibidas al principio, pero que están detrás de casi todo lo que usamos a diario. El protocolo Sequence, la colección Array, el propio protocolo View de SwiftUI: todos ellos dependen de esta misma pieza. Entender cómo funciona no es solo un ejercicio teórico; es comprender el contrato que Swift establece entre la abstracción y la seguridad de tipos en tiempo de compilación.

El ciclo de vida de las vistas en SwiftUI: cuándo se dispara onAppear de verdad

Thu, 16 Apr 2026 10:00:00 +0100

🎭 onAppear es uno de esos modificadores que parece trivial hasta que deja de comportarse como esperas. En configuraciones sencillas funciona exactamente como esperas: la vista aparece, onAppear se dispara; desaparece, onDisappear hace lo propio. El problema llega cuando añades esa lógica en un TabView, en una pila de navegación o en una lista de miles de filas, y de repente el comportamiento cambia de forma que no cuadra con el modelo mental que tenías.

Stack vs Heap en Swift: más allá de la regla que todos repiten

Tue, 14 Apr 2026 10:00:00 +0100

🧩 Hay una regla que circula sin parar en entrevistas técnicas de iOS: los structs van al stack y las clases van al heap. Es fácil de memorizar, suena convincente y, en la mayoría de los casos sencillos, parece funcionar. El problema es que no describe cómo Swift gestiona la memoria en la práctica. En cuanto hablamos de código real, la regla se rompe. Entender el modelo de verdad requiere empezar por otro sitio: la semántica, no el almacenamiento.

Mutex en Swift: protege el estado mutable compartido sin renunciar al rendimiento

Sat, 11 Apr 2026 10:00:00 +0100

🔒 La concurrencia en Swift ha madurado mucho con Swift 6 y el modelo de actores, pero hay situaciones donde los actores no son la herramienta correcta, ni siquiera suficente. El tipo Mutex ha sido introducido en el framework Synchronization junto a iOS 18, y cubre ese espacio: protección síncrona, de bajo nivel y alto rendimiento sobre estado mutable compartido.

⚙️ Un Mutex (del inglés mutual exclusion) garantiza que solo un hilo puede acceder al valor protegido en un instante determinado. A diferencia de los actores, que suspenden la tarea con await y dejan que el planificador de Swift Concurrency tome el control, un Mutex bloquea el hilo hasta que el recurso queda libre. Esta diferencia es fundamental: bloqueante contra suspensivo. No hay una opción universalmente mejor; hay una opción correcta para cada escenario.

ARC en Swift: lo que todo desarrollador debería saber

Tue, 07 Apr 2026 10:00:00 +0100

🧠 ARC (Automatic Reference Counting) es uno de esos temas que todos los desarrolladores Swift dicen conocer, pero pocos entienden de verdad. La superficie es simple: los objetos se liberan cuando su contador de referencias llega a cero. Lo interesante empieza cuando profundizas en cómo el compilador y el runtime colaboran para que eso ocurra de forma eficiente.

⚙️ ARC no es solo un mecanismo en tiempo de compilación, aunque esa sea la simplificación más común. El compilador de Swift analiza tu código e inserta las operaciones de gestión de memoria. Esas operaciones se ejecutan después en tiempo de ejecución. ARC, por tanto, vive entre el análisis estático y la ejecución dinámica. Eso es precisamente lo que lo hace predecible y rápido sin necesitar un recolector de basura al estilo de Java o Go.

Swift en Android es oficial

Sun, 04 Jan 2026 13:21:00 +0100

🚀 El SDK oficial de Swift para Android ya está aquí en las previews diarias de Swift 6.3. Lo que empezó como parches aportados por la comunidad en 2015, se ha convertido en apps de producción descargadas millones de veces. Desde Spark hasta Flowkey, empresas llevan años compartiendo código Swift entre iOS y Android.

🔧 Swift compila directamente a código nativo en Android usando LLVM, igual que en iOS. Esto significa rendimiento comparable a C/C++ con el Android NDK, pero con las garantías de seguridad y ergonomía de Swift. Tu código incluye el runtime de Swift con Foundation y Dispatch listos para funcionar.

Desarrollar para watchOS no es iOS en miniatura: son mundos diferentes

Sat, 03 Jan 2026 12:39:00 +0100

⚠️ El desarrollo para Apple Watch es el gran olvidado del ecosistema Apple. Aunque millones de personas llevan uno en la muñeca, pocos desarrolladores se especializan en crear apps realmente profesionales para watchOS. La razón es clara: está lleno de peculiaridades no documentadas, comportamientos inesperados y limitaciones que solo descubres cuando tienes apps con millones de usuarios.

🔄 El primer gran problema es la sincronización de versiones entre dispositivos. Si tu iPhone tiene iOS 26.1 y el Apple Watch tiene watchOS 26.0, prepárate para lidiar con apps que no se instalan, datos de HealthKit que desaparecen, anillos de actividad que no se rellenan y comunicación por WCSession que simplemente falla. Esta incompatibilidad afecta directamente a la experiencia del usuario desde el momento de la instalación.

¿Por qué @State en SwiftUI no se actualiza desde la vista padre? Este error confunde hasta a desarrolladores avanzados

Fri, 02 Jan 2026 11:12:00 +0100

🔐 @State representa el estado privado interno de una vista en SwiftUI. Su valor inicial solo se aplica cuando la vista establece su identidad por primera vez en la jerarquía. Después, SwiftUI ignora completamente cualquier nuevo valor que intentes pasarle.

🧬 La clave está en entender la identidad de las vistas. SwiftUI adopta una estrategia de inicialización única: cuando la vista se carga por primera vez, crea el almacenamiento interno (State). En actualizaciones posteriores, aunque el padre llame de nuevo al init de la hija con nuevos valores, SwiftUI detecta que ya existe almacenamiento para esa identidad y lo reutiliza, descartando los parámetros nuevos.

¿Integras modelos de IA en tus apps de iOS 26 pero no sabes si su rendimiento es óptimo?

Thu, 01 Jan 2026 14:23:00 +0100

🎯 Con iOS 26, Apple democratizó el acceso a modelos de lenguaje en el dispositivo mediante el framework ``Foundation Models. Este modelo de 3 mil millones de parámetros ejecuta inferencia de IA completamente local, protegiendo la privacidad del usuario mientras ofrece capacidades avanzadas de generación de texto, extracción de información y llamadas a herramientas.

📊 Xcode 26 incorpora una plantilla en Instruments para inspeccionar ``Foundation Models que nos permite visualizar métricas críticas: tiempo de carga de recursos, procesamiento de prompts, conteo de tokens de entrada y salida, y latencia total de respuesta. Esto es fundamental porque el modelo tiene un límite estricto de 4096 tokens, y excederlo causa fallos en las sesiones.

Cerrar apps en iOS para ahorrar batería: el mito que debes dejar de creer

Wed, 31 Dec 2025 10:20:00 +0100

🔄 Cuántas veces has visto a alguien cerrando compulsivamente todas las apps del multitarea para “ahorrar batería”. Incluso Craig Federighi, vicepresidente de ingeniería de software de Apple, lo dejó claro: “no y no”.

📱 El ciclo de vida de una app iOS tiene cinco estados principales:

Sin ejecución

Inactiva

Activa

Segundo plano

Suspendida

Cuando sales de una aplicación, sin forzar el cierre, iOS la suspende automáticamente tras unos segundos.

🧠 Las apps suspendidas permanecen en memoria pero no ejecutan código ni consumen CPU. El sistema las mantiene ahí listas para reanudarse instantáneamente. Esto es mucho más eficiente que forzar su cierre y obligarlas a arrancar desde cero.

¿Sabías que puedes permitir a los usuarios responder directamente desde una notificación sin abrir tu app?

Tue, 30 Dec 2025 12:14:00 +0100

📝 Las acciones de entrada de texto en notificaciones iOS son una de las funciones más poderosas del framework UserNotifications. Permiten que los usuarios escriban respuestas, proporcionen información o envíen mensajes cortos sin interrumpir su flujo de trabajo.

🎯 La clase UNTextInputNotificationAction representa estas acciones especiales. Aquí un ejemplo creando una acción para que un usuario añada una tarea rápida:

let addTaskAction = UNTextInputNotificationAction(
 identifier: "addQuickTask",
 title: "Nueva tarea",
 options: [],
 textInputButtonTitle: "Guardar",
 textInputPlaceholder: "Escribe tu tarea..."
)

🏗️ Estas acciones deben agruparse en categorías. Puedes combinar acciones de entrada de texto con botones normales:

¿Tu app se cierra inesperadamente y Xcode Organizer no te da suficiente información? MetricKit es la solución

Mon, 29 Dec 2025 11:07:00 +0100

🔍 Xcode Organizer nos proporciona métricas esenciales como crashes, consumo de batería, tiempos de arranque y uso de memoria. Sin embargo, se queda corto cuando necesitamos diagnosticar la terminación abrupta de la app o profundizar en problemas complejos de rendimiento que afectan a usuarios reales.

⚡ MetricKit es el framework que Apple introdujo en iOS 13 para llenar este vacío. Nos permite recopilar diagnósticos detallados a nivel del sistema operativo sobre cómo se comporta nuestra app en dispositivos reales. Recibe informes agregados cada 24 horas con datos de rendimiento, batería y diagnósticos de la jornada anterior.

¿Autoreleasepool en Swift? ¿Un vestigio del pasado o una herramienta esencial?

Sun, 28 Dec 2025 14:38:00 +0100

🧬 Aunque ARC gestiona la memoria automáticamente en Swift, autoreleasepool sigue siendo relevante. Este superviviente de la era MRC (Manual Reference Counting) es un contenedor temporal que retiene objetos enviados a través de un mensaje autorelease hasta que el pool se vacía, momento en el que todos reciben un release.

⚙️ Muchas APIs del sistema siguen escritas en Objective-C, y el puente entre Swift y Objective-C genera objetos autoreleased. Frameworks como Core Image, AVFoundation y PDFKit devuelven valores autoreleased por razones de rendimiento, por lo que autoreleasepool sigue siendo necesario.

¿Sigues usando SF Symbols estáticos cuando podrías darles vida con animaciones nativas?

Sat, 27 Dec 2025 10:35:00 +0100

🎨 SF Symbols no son solo íconos: son gráficos vectoriales diseñados específicamente para integrarse con el sistema tipográfico de Apple. Desde iOS 17, SwiftUI incluye efectos de animación nativos que transforman estos símbolos en elementos dinámicos y expresivos sin necesidad de frameworks externos.

💫 Las animaciones disponibles son sorprendentemente variadas: pulse hace que el símbolo simule un latido como un corazón, bounce añade un rebote, wiggle crea un movimiento de lado a lado, rotate lo gira suavemente, y breathe simula una pulsación sutil (como la respiración). Cada una transmite un significado diferente y mejora la comunicación visual.

Sombra interior en SF Symbols: el efecto que desconocías para tus iconos en SwiftUI

Fri, 26 Dec 2025 12:09:00 +0100

🎨 SwiftUI ofrece docenas de APIs para personalizar iconos con SF Symbols, pero existe una técnica poco conocida que transforma radicalmente la apariencia de tus símbolos: las sombras interiores aplicadas directamente al estilo de primer plano.

💎 Esta técnica permite crear iconos que parecen tallados o hundidos en su fondo, generando un efecto de profundidad inversa. En lugar de que el símbolo sobresalga de la superficie, aparece como si estuviera recortado dentro de ella.

Swift 6.2 cambia las reglas del juego en concurrencia: ¿será finalmente sencillo para todos?

Thu, 25 Dec 2025 14:53:00 +0100

🎯 Swift 6 prometía seguridad ante condiciones de carrera, pero llegó con una barrera enorme: cientos de errores del compilador que aparecían al activar la concurrencia estricta. Muchos desarrolladores activaban Swift 6, veían el caos de advertencias y volvían atrás de inmediato.

🔄 Swift 6.2 introduce la Approachable Concurrency, un cambio fundamental en cómo el lenguaje trata la concurrencia. En lugar de obligarte a entender actores, el protocolo Sendable y aislamiento global desde el primer momento, ahora el compilador asume que tu código empieza siendo de un solo hilo.

Deslizar desde cualquier punto de la pantalla para volver atrás en UIKit: una experiencia nativa mejorada

Wed, 24 Dec 2025 14:38:00 +0100

🎯 El gesto de deslizar desde el borde izquierdo para retroceder es uno de los patrones de navegación más intuitivos de iOS. Sin embargo, por defecto en UIKit, este gesto solo funciona desde un área muy estrecha del borde izquierdo de la pantalla.

📏 Apple limita el área táctil del gesto de retroceso a aproximadamente 44 puntos desde el borde izquierdo. Esta restricción puede resultar frustrante para los usuarios, especialmente en dispositivos más grandes donde alcanzar el borde puede ser incómodo.

¿Probando Universal Links en desarrollo y la CDN de Apple te frena? El modo alternativo es tu salvavidas.

Tue, 23 Dec 2025 12:24:00 +0100

🚦 Desde iOS 14, el sistema ya no descarga el archivo AASA directamente de tu servidor. En su lugar, usa una CDN gestionada por Apple que cachea el contenido. Esta CDN puede tardar entre 1 y 6 horas en actualizar su caché, lo que complica el desarrollo cuando necesitas probar cambios rápidamente en tu archivo AASA.

🔒 Peor aún: si tu servidor de desarrollo está detrás de una VPN o en una red privada, la CDN simplemente no puede acceder a él y tus pruebas quedan bloqueadas. Apple ofrece una solución elegante: los modos alternativos. Añadiendo ?mode=developer al dominio en los entitlements, iOS omite la CDN y conecta directo con tu servidor.

Transferable: el protocolo que revoluciona copiar, compartir y arrastrar datos en SwiftUI.

Mon, 22 Dec 2025 10:50:00 +0100

🔄 Antes de iOS 16, implementar drag-and-drop o compartir datos personalizados requería trabajar con NSItemProvider, serialización manual y mucho código repetitivo. Todo eso cambió con Transferable.

✨ El protocolo Transferable del framework Core Transferable permite describir de forma declarativa cómo tus tipos personalizados se serializan y deserializan para transferencias de datos. Lo mejor: funciona automáticamente con APIs de SwiftUI como ShareLink, PasteButton, draggable() y dropDestination().

🎯 Para adoptar Transferable solo necesitas definir una propiedad estática: transferRepresentation. Esta representación le dice al sistema cómo convertir tu tipo en datos transferibles y cómo reconstruirlo después. Apple proporciona tres formas principales de representación según tus necesidades.

Swift cierra 2025 como un lenguaje verdaderamente universal: del servidor al microcontrolador

Sun, 21 Dec 2025 13:01:00 +0100

🎯 Diciembre marca el final de un año histórico para Swift como proyecto de código abierto. Desde su nacimiento hace una década, Swift ha evolucionado de ser un lenguaje exclusivo para plataformas Apple a convertirse en una solución multiplataforma que abarca más de 70 repositorios y cientos de contribuidores semanales.🚀 Swift 6.2 representa un salto cualitativo con concurrencia más accesible mediante valores predeterminados que siguen la filosofía de aprendizaje progresivo: las funciones avanzadas están disponibles cuando las necesitas, pero no estorban cuando no las usas.💻 El soporte oficial para WebAssembly abre nuevas fronteras. Gracias a la comunidad SwiftWasm y la integración con WASI (WebAssembly System Interface), ahora puedes compilar código Swift para ejecutarse en navegadores, entornos serverless y cualquier runtime compatible. El runtime WasmKit está incluido directamente en los toolchains de Swift 6.2.📱 Android recibe soporte oficial con mejoras increméntales y versiones diarias del SDK. Los desarrolladores pueden crear aplicaciones nativas para Android usando Swift, con interoperabilidad con Java mediante swift-java, que genera automáticamente los wrappers necesarios. Esto permite compartir lógica de negocio entre iOS y Android sin sacrificar rendimiento.⚡ Embedded Swift evoluciona rápidamente hacia casos prácticos. Swift 6.3 trae mejoras significativas: soporte completo para APIs de String, tipos any para protocolos con restricciones de clase, y los nuevos tipos InlineArray y Span. Esto hace posible ejecutar Swift en microcontroladores ARM y RISC-V con binarios extremadamente compactos.🌐 Windows, BSD y la nube también forman parte del ecosistema. FreeBSD 14.3 cuenta con soporte preliminar, Amazon Linux integra Swift oficialmente, y AWS Lambda Runtime se traslada a AWS Labs como solución soportada por el proveedor. La extensión de VS Code está verificada y distribuida oficialmente.🏗️ El stack tecnológico se consolida: Swift Configuration 1.0 unifica el manejo de configuración, gRPC Swift potencia servicios cloud de alto rendimiento, y paquetes como MLX llevan machine learning a Apple Silicon con APIs nativas de Swift.👨‍💻 Swift demuestra que seguridad de memoria, rendimiento nativo y expresividad moderna pueden coexistir en un solo lenguaje. ¿Ya estás explorando Swift más allá de las plataformas Apple?

Listas interactivas en macOS con SwiftUI: selección, doble clic y menús contextuales unificados

Sat, 20 Dec 2025 13:16:00 +0100

🖱️ En macOS, los usuarios esperan un comportamiento específico en las listas: un clic selecciona, doble clic ejecuta una acción principal y clic derecho muestra opciones.

📋 Para habilitar este patrón necesitas dos elementos clave: un inicializador de List que acepte el parámetro selection con binding, y el modificador contextMenu(forSelectionType:menu:primaryAction:). Primero define un tipo Identifiable y la propiedad de selección:

struct DocumentItem: Identifiable {
 let id = UUID()
 var title: String
 var type: String
}
@State private var selectionID: DocumentItem.ID? = nil

🎯 El modificador contextMenu tiene tres partes esenciales: forSelectionType define el tipo de identificador, menu construye el menú contextual con botones de acción, y primaryAction define la acción del doble clic. Implementa la lista con el modificador completo:

¿Crees que @Query en SwiftData es estático? Te sorprenderá lo dinámico que puede ser

Fri, 19 Dec 2025 14:38:00 +0100

🔍 La macro @Query de SwiftData nos permite consultar datos persistentes de forma declarativa, pero muchos desarrolladores no saben que puede volverse completamente dinámico cuando lo necesitamos.

⚡ El problema surge cuando intentas usar @State directamente en un predicado: SwiftData no puede acceder a propiedades de instancia durante la inicialización de @Query. La solución está en la arquitectura de vistas.

🏗️ El patrón correcto implica separar responsabilidades: una vista contenedora maneja el estado dinámico (filtros, búsquedas, ordenación) y una subvista ejecuta el @Query recibiendo parámetros por inyección de dependencias.

¿Inicializas correctamente tus clases @Observable en SwiftUI? Algnos errores pueden romper tu app

Thu, 18 Dec 2025 10:25:00 +0100

🔄 Muchos desarrolladores experimentados siguen teniendo dudas sobre cómo gestionar el ciclo de vida de las clases @Observable en SwiftUI. El problema no es solo técnico: es conceptual. Cuando creamos una clase @Observable en una vista SwiftUI, podría parecer que no necesitamos @State porque las propiedades se actualizan automáticamente. Pero aquí está el peligro oculto.

⚠️ Sin @State, tu modelo no está vinculado al ciclo de vida de la vista. SwiftUI recreará una nueva instancia cada vez que la estructura de la vista se reinicialice. Y eso pasa más de lo que crees. Imagina este escenario: tienes un contador en una vista hija. Cambias un color en la vista padre. El body se reconstruye, el inicializador de la vista hija se ejecuta nuevamente, y boom. Tu contador vuelve a cero sin razón aparente.

¿Guardas las API keys directamente en tu app de SwiftUI? Es el error que te costará caro

Wed, 17 Dec 2025 12:29:00 +0100

🚨 Uno de los fallos más comunes en iOS es almacenar claves de API en archivos .plist o .xcconfig sin protección adicional. Aunque mantengas estos archivos fuera del control de versiones, cualquier atacante con herramientas de ingeniería inversa puede extraer las claves del binario compilado en texto plano.

🔐 El Keychain de iOS es el mecanismo oficial de Apple para almacenar datos sensibles con cifrado. Utiliza el Secure Enclave del dispositivo para proteger credenciales, tokens y claves criptográficas. A diferencia de UserDefaults o archivos locales, el Keychain persiste incluso tras desinstalar la app y ofrece integración con Face ID y Touch ID.

¿Cuatro formas de previsualizar documentos en SwiftUI y no conoces cuál usar? Aquí está la guía definitiva

Tue, 16 Dec 2025 11:47:00 +0100

📄 Trabajar con documentos es fundamental en muchas apps iOS: PDFs, imágenes, documentos Office… Pero no todos los frameworks ofrecen lo mismo. Algunos priorizan simplicidad, otros control total, y cada uno tiene su lugar según tus necesidades.

🚀 Quick Look es tu primera opción cuando necesitas rapidez y cero configuración. Con una sola línea de código obtienes un visor nativo del sistema que soporta decenas de formatos diferentes sin esfuerzo adicional.

¿SwiftUI ha muerto en 2025? El debate que divide a la comunidad iOS

Mon, 15 Dec 2025 13:26:00 +0100

🔄 Un artículo reciente ha provocado una gran controversia al afirmar que 2025 es el año que murió SwiftUI. La tesis principal: UIKit ha recibido modernizaciones fundamentales mientras que las herramientas de IA generativa trivializan lo que antes era la gran ventaja de SwiftUI.

🛠️ iOS 18 trajo una revolución silenciosa para UIKit. Apple añadió soporte para el macro @Observable y el nuevo método updateProperties() que permite actualizaciones reactivas automáticas, similar a cómo funciona SwiftUI desde el principio.

¿Gestionar configuración en Swift sigue siendo un dolor de cabeza con código disperso y acoplado? Swift Configuration 1.0 cambia las reglas

Sun, 14 Dec 2025 12:29:00 +0100

🎯 Hasta ahora, gestionar variables de entorno, archivos JSON, argumentos de línea de comandos y secretos requería código repetitivo y específico para cada origen. Cada fuente necesitaba su propia lógica de lectura, haciendo que el código de la aplicación quedara acoplado a proveedores concretos.

✨ Swift Configuration introduce una abstración limpia entre cómo accedemos a la configuración y de dónde proviene. Esta separación permite que las librerías acepten una configuración sin dictar el origen. Esto habilita a su vez la composición de configuraciones entre diferentes entornos de despliegue. El verdadero valor no está en leer archivos, sino en la flexibilidad que aporta.

SwiftData en 2025: de código caótico a arquitectura maestra

Sat, 13 Dec 2025 14:38:00 +0100

🧩 SwiftData llegó en 2023 como la evolución de CoreData, prometiendo sintaxis moderna y declarativa. Pero dos años después, muchos desarrolladores siguen luchando con su arquitectura porque intentan forzar patrones antiguos en lugar de aprovechar su diseño.

🔑 El framework gira en torno a dos componentes esenciales: ModelContainer gestiona el esquema y la persistencia, mientras ModelContext coordina las operaciones de lectura y escritura. Entender esta base es crucial antes de construir sobre ella.

Swift Subprocess: ¿el futuro del scripting en Swift o solo una ilusión?

Fri, 12 Dec 2025 12:19:00 +0100

🚀 Swift ha luchado durante años por escapar del nicho móvil y expandirse a otros casos de uso como scripting, automatización y herramientas CLI. El problema histórico ha sido Process (antes NSTask), una API heredada de Objective-C que no soporta async/await, depende de closures y usa excepciones para indicar errores.

📦 En septiembre de 2024 llegó swift-subprocess, un paquete oficial del proyecto swift-foundation diseñado para revolucionar la creación de procesos en Swift. Promete ergonomía moderna, compatibilidad multiplataforma y soporte nativo para concurrencia con async/await.

¿Conoces el concepto de identidad en .task de SwiftUI? Cambia por completo cómo manejas operaciones asíncronas

Thu, 11 Dec 2025 13:36:00 +0100

🎯 El modificador .task en SwiftUI no solo ejecuta código asíncrono cuando aparece una vista: también gestiona automáticamente la identidad de esas tareas basándose en el ciclo de vida y los valores que le pasamos.

🔄 Cuando adjuntas un .task a una vista, SwiftUI crea una Task que se cancela automáticamente cuando la vista desaparece. Esto evita fugas de memoria y operaciones que continúan ejecutándose en segundo plano innecesariamente.

💡 La clave está en entender que .task(id:) permite vincular la tarea a un valor específico. Cada vez que ese valor cambia, SwiftUI cancela la tarea anterior y ejecuta una nueva. Esto es perfecto para recargar datos cuando cambian filtros o parámetros.

¿SwiftData necesita MVVM o es sobre-ingeniería? Hay un camino intermedio

Wed, 10 Dec 2025 14:53:00 +0100

⚖️ Añadir MVVM a esto puede ser sobre-ingeniería si peleas contra el framework. Pero existe un enfoque híbrido que respeta la arquitectura nativa y añade testabilidad solo donde importa.

🎯 SwiftData y SwiftUI están diseñados para trabajar juntos sin capas adicionales. Apple nos da @Query para lectura reactiva y @Environment(.modelContext) para escritura. Funciona perfecto.

💡 @Query ya es un ViewModel de lectura: observa la base de datos, actualiza automáticamente las vistas y gestiona el ciclo de vida de los datos. No necesitas replicar esto en otra capa.

¿Confundes .count con .length o usas métodos de NSString en Swift? Estos errores pueden hacer añicos tu app

Tue, 09 Dec 2025 10:30:00 +0100

🚨 El manejo de cadenas en Swift tiene trampas que muchos desarrolladores pisan constantemente. La mayoría provienen de mezclar métodos de Objective-C con tipos nativos de Swift, generando bugs extraños con emojis y caracteres Unicode.

⚠️ El error más común es usar replacingOccurrences(of:with:) en lugar de replacing(_:with:). El primero viene de NSString y no respeta las secuencias Unicode. Puede convertir 🇨🇦🇺🇸 en 🇨🇳🇮🇸 sin previo aviso al romper los indicadores regionales.

Números que no hacen salto de línea en SwiftUI: ¿conoces este detalle tipográfico que mejora la legibilidad?

Mon, 08 Dec 2025 13:41:00 +0100

📱 Cuando trabajamos con textos dinámicos en SwiftUI, hay un problema visual que muchos pasamos por alto: los números grandes pueden partirse entre líneas de forma incómoda. Por ejemplo, 1 000 000 podría aparecer como 1 000 en una línea y 000 en la siguiente.

🔍 Este fenómeno afecta especialmente a fechas, cantidades monetarias, números de teléfono y cualquier cifra con separadores. La experiencia de lectura se deteriora porque el usuario debe reconstruir mentalmente el número completo.

¿Swift 6 te parece complicado? Las herramientas de migración automática lo cambiarán todo

Sun, 07 Dec 2025 12:14:00 +0100

🔄 Swift 6 introduce mejoras importantes en concurrencia y seguridad de datos, pero migrar código existente puede parecer abrumador. Apple lo sabe y está trabajando en herramientas que automatizarán gran parte del proceso.

🛠️ El nuevo sistema de migración analizará tu código y sugerirá cambios específicos para cumplir con el modelo de concurrencia estricto de Swift 6. No tendrás que buscar manualmente cada warning de Sendable o actor isolation.

⚡ Xcode 16 ya incluye capacidades básicas de detección, pero las próximas versiones traerán fix-its inteligentes que aplicarán las correcciones directamente. Piensa en ello como tener un asistente experto en concurrency revisando tu código.

Valores por defecto en interpolación de cadenas de texto: el truco que no conocías en Swift

Sat, 06 Dec 2025 14:43:00 +0100

🎯 La interpolación de String en Swift es una herramienta que usamos a diario, pero ¿sabías que puedes definir valores por defecto cuando el valor interpolado es nil? Esta técnica puede ahorrarte múltiples líneas de código y hacer tu app más robusta.

💡 Swift 6.2 nos permite extender el protocolo StringProtocol para personalizar cómo se comporta la interpolación. Esto significa que podemos interceptar valores opcionales y proporcionar alternativas automáticas sin necesidad de usar el operador de coalescencia nula cada vez.

NotificationCenter en Swift 6.2: ¿Sigues usando el método antiguo con warnings de concurrencia?

Fri, 05 Dec 2025 12:04:00 +0100

🚨 El sistema clásico de NotificationCenter tiene un problema grave: incluso cuando especificas .main como cola, el compilador no puede verificar la seguridad entre hilos. El dominio de aislamiento permanece como nonisolated, lo que genera advertencias del compilador cuando intentas llamar métodos aislados a @MainActor.

🎯 iOS 26 y Swift 6.2 introducen MainActorMessage y AsyncMessage, dos protocolos que revolucionan cómo trabajamos con notificaciones. Estos nuevos tipos permiten al compilador verificar la seguridad de concurrencia en tiempo de compilación, no en ejecución.

Swift como código abierto cumple 10 años: de proyecto Apple a ecosistema multiplataforma

Thu, 04 Dec 2025 14:23:00 +0100

🎉 El 3 de diciembre de 2015, Apple liberó Swift bajo licencia Apache 2.0, transformando un lenguaje propietario en un proyecto comunitario global. Una década después, el impacto de esa decisión ha superado todas las expectativas.

🌍 Hoy Swift es verdaderamente multiplataforma: se ejecuta en Linux (Debian, Fedora, Ubuntu), Windows (incluyendo arquitecturas arm64), y hay vistas previas oficiales para Android y FreeBSD. Ya no es solo el lenguaje de Apple.

UIKit ahora puede observar cambios de estado automáticamente como SwiftUI: adiós al código manual

Thu, 04 Dec 2025 12:19:00 +0100

🎯 iOS 26 marca un antes y un después para los desarrolladores UIKit. Apple ha integrado el framework Observation directamente en el ciclo de vida de UIKit, permitiendo que las vistas se actualicen automáticamente cuando cambian las propiedades de objetos marcados con @Observable.

📝 Hasta ahora, mantener la interfaz sincronizada con los datos en UIKit requería código tedioso: usar didSet, llamar manualmente setNeedsLayout(), o implementar callbacks con Combine. Olvidarte de actualizar la UI significaba vistas obsoletas y bugs difíciles de rastrear.

¿Tu app sigue obligando a los usuarios a elegir idioma manualmente? iOS 26 Language Discovery cambia las reglas del juego

Wed, 03 Dec 2025 11:02:00 +0100

🌍 La realidad multilingüe es más compleja de lo que pensamos. Un desarrollador en Toronto programa en inglés, lee documentación técnica en inglés, pero consume noticias en español y escribe a su familia en francés.

🔍 El problema es que las apps tradicionales los obligan a navegar listas alfabéticas de cientos de idiomas o conformarse con inglés porque es más fácil de encontrar. Esta fricción es exactamente lo que iOS 26 elimina.

Tests parametrizados en Swift Testing: las 5 trampas que debes evitar

Tue, 02 Dec 2025 12:54:00 +0100

🚀 SwiftTesting llegó en WWDC24 con una de las funcionalidades más esperadas: los tests parametrizados. En lugar de escribir múltiples tests casi idénticos, podemos ejecutar un solo test con diferentes argumentos automáticamente.

⚠️ Sin embargo, la conveniencia de parametrizar puede llevarnos a cometer errores sutiles que comprometen la calidad de nuestras pruebas. Migrar decenas de miles de tests ha revelado patrones problemáticos que debemos evitar.

🔍 Trampa 1: Huecos en la cobertura. Cuando usamos variables opacas en las aserciones, el test puede pasar incluso con bugs reales. Si verificamos que una función devuelve el mismo valor calculado que genera, estamos duplicando la lógica en lugar de validarla.

¿Entiendes realmente cómo funcionan los bucles for-in en Swift? La maquinaria que hay detrás es fascinante

Mon, 01 Dec 2025 12:59:00 +0100

🔄 Cuando escribes for item in lista, el compilador pone en marcha toda una jerarquía de protocolos que trabajan en segundo plano. Lo que parece una simple iteración es en realidad un sistema elegante basado en Sequence e IteratorProtocol.

🎯 En Swift, Sequence es el protocolo base que permite iterar sobre una colección de elementos. Su único requisito es proporcionar un iterador mediante el método makeIterator(). El iterador, a su vez, solo necesita implementar un método: next(), que devuelve el siguiente elemento o nil cuando termina.

Thread safety en Swift: ¿GCD con barreras, OSAllocatedUnfairLock o actors?

Fri, 28 Nov 2025 10:40:00 +0100

🔒 Garantizar seguridad entre hilos es uno de los retos más complejos en desarrollo iOS. Un simple diccionario compartido puede provocar condiciones de carrera, crashes o estados corruptos si varios hilos escriben y leen simultáneamente sin la sincronización adecuada.⚙️ La solución clásica con GCD usa colas concurrentes con lecturas síncronas y escrituras asíncronas. Pero sin el flag .barrier, las lecturas y escrituras pueden solaparse, creando inconsistencias. El patrón recomendado es lecturas concurrentes y escrituras serializadas mediante barriers.🚀 OSAllocatedUnfairLock llega en iOS 16 como el wrapper moderno de os_unfair_lock. Gestiona memoria automáticamente, es Sendable, y su API withLock elimina el riesgo de olvidar liberar el lock. Usa la misma primitiva del kernel que su predecesor pero sin interoperabilidad con C.🛡️ Los actores de Swift Concurrency eliminan colas y barreras por completo. Aislan el estado mutable garantizando que solo una tarea pueda acceder a él simultáneamente. El compilador y el runtime manejan la sincronización sin bloqueos explícitos ni riesgo de deadlocks.🔬 Internamente, los actors gestionan una cola de tareas pendientes y un flag para indicar si están activos. Cuando una tarea llama a un método del actor, Swift la encola. El actor procesa su cola secuencialmente, ejecutando una tarea a la vez, lo que garantiza aislamiento total del estado.⚡ Si priorizas rendimiento y seguridad con GCD, usa .barrier. Para compatibilidad total con Swift 6 y simplificar tu código, los actores son el camino. Apple recomienda migrar de os_unfair_lock a OSAllocatedUnfairLock para garantizar comportamiento correcto del locking.👨‍💻 ¿Ya estás usando actores en tus proyectos o sigues confiando en GCD? La evolución del ecosistema Swift apunta claramente hacia concurrencia estructurada y la seguridad de datos por defecto.

Conformar protocolos en Swift 6: navegando por los desafíos de aislamiento de actores

Thu, 27 Nov 2025 10:55:00 +0100

🧩 Uno de los aspectos más complejos de la concurrencia en Swift es hacer que tipos aislados a actores conformen protocolos que no fueron diseñados con concurrencia.🎯 El problema es común: tienes un tipo marcado con @MainActor que necesita conformar Equatable, Codable o cualquier otro protocolo estándar.⚠️ Aparece el temido error: Conformance crosses into main actor-isolated code and can cause data races.🔍 La raíz del problema está en que protocolos como Equatable esperan implementaciones nonisolated, es decir, que funcionen desde cualquier contexto.🛠️ Swift 6.2 introduce isolated conformances (SE-0470), que permiten restringir una conformación a un actor global específico.💡 Con esta nueva característica, puedes escribir tipo como extension ImageModel: @MainActor Equatable y el compilador entiende la restricción de contexto.🚀 El ajuste InferIsolatedConformances, que hace esto automáticamente cuando está habilitado, parte del nuevo enfoque Approachable Concurrency en Xcode 26.🔄 Antes de Swift 6.2, la solución era @preconcurrency conformances (SE-0423), que funciona, pero semánticamente sugiere que el protocolo está desactualizado y no es seguro.⚡ Otra alternativa es usar nonisolated + MainActor.assumeIsolated, aunque es verboso y puede introducir verificaciones en tiempo de ejecución peligrosas.🎨 Existe un enfoque alternativo poco conocido: diseñar tipos como no Sendable y nonisolated desde el inicio, dejando que el compilador prevenga su escape.🔒 Los tipos no Sendable quedan automáticamente atrapados en el dominio de aislamiento donde se crean, sin necesidad de marcas explícitas de actor.🧠 Este principio no Sendable por definición puede ser la solución más simple o la más compleja, dependiendo de las necesidades internas del tipo.👨‍💻 Dominar estos patrones de conformance es esencial para migrar proyectos a Swift 6 sin comprometer la seguridad de datos. Lamentablemente no hay una regla o patrón eficaz y la mejor implementación depende del caso concreto.

Gauge, ProgressView o Slider en SwiftUI: ¿cuál usar en cada caso?

Wed, 26 Nov 2025 13:56:00 +0100

🎯 Aunque parecen similares, estos tres componentes nativos de SwiftUI tienen propósitos completamente distintos.

Elegir el correcto marca la diferencia entre una interfaz intuitiva y una confusa.

📊 Gauge es para mostrar valores medidos dentro de un rango. Introducido en iOS 16, es ideal para representar temperatura, nivel de batería o uso de CPU.

A diferencia de los otros, es de solo lectura: el usuario no puede interactuar con él para cambiar el valor.

¿Sabías que el modelo de Foundation Models tiene un límite de contexto que puede romper tu app?

Tue, 25 Nov 2025 12:44:00 +0100

🧠 El modelo on-device de Apple Intelligence opera con una ventana de contexto fija de 4096 tokens por sesión. Esto incluye todas las instrucciones, prompts y respuestas generadas durante la conversación. Cuando se supera este límite, la app lanza un error exceededContextWindowSize que puede interrumpir completamente la experiencia del usuario.

⚡ Un token no es exactamente una palabra. El modelo divide el texto en pequeñas subcadenas que pueden ser palabras completas, fragmentos o incluso caracteres individuales. Apple no expone públicamente un tokenizador ni metadatos de uso, por lo que calcular cuántos tokens consumes es complicado y la mayoría de desarrolladores nos enfrentamos a esto a ciegas.

¿Tus vistas de SwiftUI parecen novelas interminables? La arquitectura es la solución

Mon, 24 Nov 2025 10:05:00 +0100

📚 A medida que los proyectos crecen, el body de nuestras vistas acumula decenas de VStacks, HStacks y modificadores anidados hasta volverse ilegible.Scrollear por el código se convierte en un martirio. El problema no es la cantidad de líneas, sino la falta de estructura clara.🚫 Muchos desarrolladores intentan “arreglarlo” moviendo código a extensiones y propiedades computadas en el mismo archivo. Esto solo desplaza el problema.La legibilidad no mejora realmente y el archivo sigue siendo igual de largo. Necesitamos una estrategia mejor para construir arquitectura en SwiftUI.🎯 La clave está en extraer vistas dedicadas cuando una porción de UI tiene un propósito claro y potencial de reutilización. Cada vista debe tener una única responsabilidad.Esto permite previsualizar estados individuales y facilita el mantenimiento a largo plazo del código.🎨 Los ViewModifiers personalizados son perfectos para consolidar combinaciones repetitivas de estilos que definen tu lenguaje de diseño.Puedes actualizar la apariencia de toda tu app desde un único punto. Además, funcionan como extensiones de View para mayor conveniencia.🔄 Las extensiones genéricas de View ayudan cuando repites layouts similares constantemente, como encabezados de sección con formato consistente.Reducen la indentación del código y mantienen tu interfaz coherente sin duplicar implementaciones.🧩 SwiftUI está diseñado desde cero para composición y reutilización. Aprovecha esa arquitectura: descompón interfaces complejas en bloques pequeños y combínalos.Vistas más simples significan código más fácil de leer, probar y mantener. La meta no es minimizar líneas, sino maximizar claridad.👨‍💻 Una buena arquitectura SwiftUI transforma el caos en componentes limpios, componibles y testeables. ¿Ya estructuras tus vistas para reutilización?