iOS: qué es, arquitectura del sistema y lenguaje Swift

¿Qué es iOS?

iOS es el sistema operativo móvil de Apple, lanzado por primera vez en 2007 junto con el primer iPhone. El sistema está construido sobre el micronúcleo XNU, un núcleo híbrido que combina componentes de Mach y FreeBSD. A diferencia de Android, iOS es una plataforma cerrada: la instalación de aplicaciones solo es posible a través de la App Store y el código fuente del sistema no está disponible.

Apple controla tanto el hardware como el software, lo que garantiza un alto nivel de optimización. Según StatCounter (2026), iOS tiene aproximadamente el 28% del mercado global de SO móviles y supera el 50% en EE. UU. y Japón.

El sistema utiliza el modelo App Sandbox — cada aplicación se ejecuta en un entorno aislado y no puede acceder a los datos de otras aplicaciones sin permiso explícito del usuario a través de diálogos del sistema.

Historial de versiones de iOS

La primera versión, iPhone OS 1.0, no admitía aplicaciones de terceros. La App Store llegó con iOS 2.0 en 2008. Hitos clave: iOS 4 (multitarea), iOS 7 (diseño plano), iOS 10 (iMessage Apps), iOS 14 (widgets en escritorio), iOS 17 (modo StandBy). Cada gran versión trae nuevas API y frameworks.

Arquitectura de iOS: cuatro capas del sistema

La arquitectura de iOS consta de cuatro capas abstractas, cada una proporciona API para la capa superior. Las capas inferiores son el núcleo y los servicios del sistema, las superiores son frameworks de usuario.

Cocoa Touch — capa superior

Cocoa Touch es la capa de frameworks para construir interfaces de usuario. Incluye UIKit, SwiftUI, Foundation, MapKit, NotificationCenter y otras API con las que el desarrollador trabaja directamente. UIKit proporciona UIViewController, UIView, UIWindow y todos los componentes visuales.

Media — gráficos y sonido

La capa Media incluye Core Graphics, Core Animation, Core Image, AVFoundation y Metal. Metal es una API de GPU de bajo nivel que ofrece alto rendimiento gráfico en juegos y aplicaciones de realidad aumentada. Core Animation gestiona animaciones a nivel de capas con aceleración por hardware.

Core Services — servicios del sistema

Core Services incluye Core Data, CloudKit, Core Location, HealthKit, Core Motion y Network. CFNetwork es una interfaz C de bajo nivel para trabajar con protocolos de red. Foundation es un envoltorio orientado a objetos sobre Core Foundation con clases NSString, NSArray, NSDictionary.

Core OS — núcleo y seguridad

La capa inferior incluye el núcleo XNU, el sistema de archivos APFS, módulos criptográficos (CommonCrypto, Security.framework), gestión de energía y controladores de dispositivos. El Secure Enclave opera en este nivel — un coprocesador para almacenar datos biométricos y claves de cifrado.

// Verificación de integridad de Secure Enclave mediante Security framework
#import <LocalAuthentication/LocalAuthentication.h>

LAContext *context = [[LAContext alloc] init];
NSError *error = nil;

if ([context canEvaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics
                          error:&error]) {
    NSLog(@"Secure Enclave disponible para biometría");
} else {
    NSLog(@"Secure Enclave no disponible: %@", error.localizedDescription);
}

Swift — el lenguaje principal para desarrollo iOS

Swift es un lenguaje de programación presentado por Apple en 2014 como reemplazo de Objective-C. Fue creado por Chris Lattner en Apple. Swift combina la sintaxis de lenguajes modernos (Rust, Kotlin, C#) con rendimiento a nivel de C. Según TIOBE (2026), Swift está entre los 15 principales lenguajes de programación.

Características clave de Swift

Swift utiliza Automatic Reference Counting (ARC) para la gestión de memoria sin recolector de basura. La programación orientada a protocolos (POP) permite extender tipos mediante extensiones de protocolo. Optionals proporcionan manejo type-safe de nil, y pattern matching simplifica la lógica de ramificación.

import UIKit

/// Protocolo para servicio de carga de datos
protocol DataServiceProtocol {
    associatedtype T
    func fetch(completion: @escaping (Result<[T], Error>) -> Void)
}

/// Implementación de servicio para cargar usuarios
final class UserService: DataServiceProtocol {
    typealias T = User

    private let session: URLSession
    private let decoder: JSONDecoder

    init(session: URLSession = .shared, decoder: JSONDecoder = JSONDecoder()) {
        self.session = session
        self.decoder = decoder
    }

    func fetch(completion: @escaping (Result<[User], Error>) -> Void) {
        guard let url = URL(string: "https://api.example.com/users") else {
            completion(.failure(URLError(.badURL)))
            return
        }

        session.dataTask(with: url) { [weak self] data, response, error in
            guard let self, let data = data else {
                completion(.failure(error ?? URLError(.badServerResponse)))
                return
            }
            do {
                let users = try self.decoder.decode([User].self, from: data)
                completion(.success(users))
            } catch {
                completion(.failure(error))
            }
        }.resume()
    }
}

struct User: Codable, Identifiable {
    let id: Int
    let name: String
    let email: String
}

El ejemplo muestra una implementación de servicio de carga de datos usando Swift Concurrency (async/await), un protocolo con associatedtype y Codable para decodificar JSON. ARC gestiona la memoria automáticamente, y weak self previene ciclos de referencias fuertes en closures.

Swift Concurrency: async/await y Actors

Desde iOS 13, Swift admite asincronía incorporada mediante async/await y Actors — tipos thread-safe que protegen el estado de condiciones de carrera. DispatchQueue para multitarea está siendo reemplazado gradualmente por async/await y estructuras Task.

actor UserRepository {
    private var cache: [Int: User] = [:]
    private let service = UserService()

    func getUser(id: Int) async throws -> User {
        if let cached = cache[id] {
            return cached
        }
        let users = try await service.fetchAsync()
        guard let user = users.first(where: { $0.id == id }) else {
            throw UserError.notFound
        }
        cache[id] = user
        return user
    }
}

El actor UserRepository garantiza que el acceso a la caché ocurra en un solo hilo, eliminando condiciones de carrera. El compilador verifica el aislamiento en tiempo de compilación — acceder a una propiedad mutable de un actor solo es posible mediante await.

Xcode y herramientas de desarrollo

Xcode es el entorno de desarrollo integrado (IDE) de Apple, disponible exclusivamente en macOS. Incluye editor de código, Interface Builder para diseño visual, simulador de dispositivos, Instruments para perfilado y el depurador LLDB. Xcode 15 es compatible con Swift 5.9 y macros.

Interface Builder y Storyboards

Interface Builder permite crear interfaces mediante arrastrar y soltar con generación automática de descripciones XML (XIB/Storyboard). Los Storyboards describen flujos de pantallas. Desde 2023, Apple recomienda SwiftUI Preview como herramienta principal de desarrollo visual, aunque Interface Builder sigue en proyectos UIKit.

Herramientas de depuración y perfilado

Xcode Instruments incluye decenas de plantillas: Time Profiler (análisis de CPU), Allocations (memoria), Leaks (fugas), Core Animation (FPS), Network y Energy Log. Metal Debugger permite inspeccionar llamadas de GPU y shaders. LLDB es un depurador de consola con soporte de expresiones Swift y puntos de interrupción condicionales.

Frameworks principales de desarrollo iOS

El iOS SDK incluye cientos de frameworks. A continuación se presentan los clave con los que todo desarrollador iOS trabaja a diario.

Core Data: trabajo con datos locales

Core Data es un framework para gestionar el modelo de datos de objetos. Permite guardar, cargar y sincronizar objetos entre el hilo de UI y contextos en segundo plano. iOS 17 introdujo SwiftData — un envoltorio moderno sobre Core Data con soporte de Swift Macros.

UIKit vs SwiftUI: comparación de enfoques

La elección entre UIKit y SwiftUI es una decisión arquitectónica clave al iniciar el desarrollo iOS. UIKit existe desde 2007 y es compatible con todas las versiones de iOS. SwiftUI se presentó en 2019 y requiere iOS 13+.

En la práctica, la mayoría de los proyectos comerciales utilizan un enfoque híbrido: SwiftUI para nuevas pantallas y formularios simples, UIKit para componentes personalizados complejos que requieren control fino de renderizado. Apple invierte activamente en SwiftUI y se espera que se convierta en el framework principal para 2028.

Ciclo de vida de una app iOS

Cada app iOS pasa por cinco estados gestionados por UIApplication y AppDelegate. En SwiftUI, este rol lo asume el App Protocol con el atributo @main.

Estados de la aplicación

Not running — la app no se ha iniciado o fue terminada por el sistema. Inactive — la app está en primer plano pero no recibe eventos (p. ej., durante una llamada entrante). Active — estado normal, la app recibe eventos táctiles. Background — la app está minimizada, ejecutando tareas en segundo plano. Suspended — la app está en memoria pero no ejecuta código.

import SwiftUI

@main
struct MyApp: App {
    @Environment(\.scenePhase) private var scenePhase

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { oldPhase, newPhase in
            switch newPhase {
            case .active:
                print("La app se volvió activa")
            case .inactive:
                print("La app está inactiva")
            case .background:
                print("La app pasó a segundo plano")
            @unknown default:
                break
            }
        }
    }
}

El sistema puede terminar la app en segundo plano cuando falta memoria. El desarrollador debe guardar el estado en onDisappear o mediante ScenePhase.background para que el usuario no pierda datos al cambiar entre apps.

App Store: publicación y requisitos

La App Store es la única tienda oficial de aplicaciones para iOS. Publicar requiere una suscripción al Apple Developer Program ($99/año). Cada aplicación pasa por moderación — automática (análisis estático del binario) y manual (revisión de interfaz y contenido).

Proceso de publicación

El desarrollador crea un archivo en Xcode y lo sube mediante Transporter o Xcode Organizer a App Store Connect. El tiempo medio de moderación es de 24 a 48 horas. App Review verifica el cumplimiento de las pautas: seguridad de datos, rendimiento, diseño HIG, ausencia de funcionalidad oculta.

Requisitos de App Review

Se presta especial atención a la privacidad: todos los tipos de recopilación de datos deben declararse en el Privacy Manifest. Desde 2025, Apple exige especificar los motivos de uso de API (NSPrivacyAccessedAPITypes). Las aplicaciones que usan rastreadores sin consentimiento del usuario son rechazadas.