Swift para programación de sistemas: una nueva y potente herramienta

Swift — el héroe inesperado de la programación de sistemas

Cuando escuchas «programación de sistemas», normalmente piensas en el severo C, ensamblador o, en su defecto, Rust. ¿Swift? ¿Ese mismo lenguaje para aplicaciones móviles bonitas? Resulta que sí. Y no es una broma.

Apple invirtió en Swift no solo comodidad y seguridad, sino también control total sobre la memoria, punteros y llamadas al sistema. En este artículo analizaremos cómo Swift puede convertirse en su herramienta principal para escribir utilidades, controladores, demonios de red e incluso componentes del sistema operativo. Prepárese para sorprenderse: el código será real, funcional y muy interesante.

¿Por qué Swift? Tres pilares de la programación de sistemas

La programación de sistemas requiere tres cosas: rendimiento, control sobre los recursos y la capacidad de trabajar «cerca del hardware». Swift ofrece todo esto, y además algo extra.

• Rendimiento a nivel de C. El compilador LLVM optimiza el código tan bien como para C o C++. En benchmarks, Swift a menudo supera a Go y Rust en tareas de E/S.
• Acceso directo a la memoria. A través del mecanismo UnsafePointer, UnsafeMutablePointer y trabajo con bytes sin procesar.
• Biblioteca estándar rica. No necesita arrastrar un montón de dependencias: todo para trabajar con sockets, archivos, procesos ya está incluido.

Al mismo tiempo, Swift sigue siendo seguro: si no usa bloques unsafe, el compilador lo protegerá contra desbordamientos de búfer y punteros colgantes. Y cuando lo necesite, simplemente escribe withUnsafePointer y obtiene control total.

Trabajo con memoria: desde bytes hasta estructuras

Empecemos con lo básico: trabajar con memoria sin procesar. Imagine que necesita leer un archivo binario e interpretarlo como un arreglo de estructuras. En C sufriría con malloc y sizeof. En Swift, es elegante y seguro.

Lectura de un archivo binario en Swift

import Foundation

struct Header {    let magic: UInt32    let version: UInt16    let count: UInt16}

func readBinaryFile(path: String) -> Header? {    let data = try? Data(contentsOf: URL(fileURLWithPath: path))    guard let data = data else { return nil }        return data.withUnsafeBytes { (ptr: UnsafeRawBufferPointer) in        guard let baseAddress = ptr.baseAddress else { return nil }        let headerPtr = baseAddress.assumingMemoryBound(to: Header.self)        return headerPtr.pointee    }}

Note: no asignamos memoria manualmente. withUnsafeBytes proporciona un puntero temporal que solo existe dentro del cierre. Es seguro, eficiente y se lee como buena prosa.

Creación de estructuras y trabajo con punteros

¿Y si necesita crear una estructura en memoria y pasar su dirección a una llamada del sistema? ¡Fácil!

struct sockaddr_in {    var sin_len: UInt8 = 0    var sin_family: UInt8 = UInt8(AF_INET)    var sin_port: in_port_t = 0    var sin_addr: in_addr = in_addr(s_addr: 0)    var sin_zero: (UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8) = (0,0,0,0,0,0,0,0)}

var address = sockaddr_in()address.sin_port = CFSwapInt16HostToBig(8080)address.sin_addr.s_addr = inet_addr("127.0.0.1")

let ptr = withUnsafePointer(to: &address) { $0 }let rawPtr = UnsafeRawPointer(ptr)

Este código es la base para trabajar con sockets a bajo nivel. Definimos manualmente la estructura, llenamos los campos y obtenemos un puntero sin procesar para pasarlo a connect o bind.

Llamadas al sistema y API POSIX

Swift se lleva muy bien con POSIX. Puede llamar a open, read, write, fork, exec — todo como en los viejos tiempos, pero con sintaxis del siglo XXI.

Creación de fork + exec en Swift

import Darwin

func spawnProcess(path: String, args: [Str