<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Saul Urias Guzman on Medium]]></title>
        <description><![CDATA[Stories by Saul Urias Guzman on Medium]]></description>
        <link>https://medium.com/@sauluriasguzman?source=rss-6dd0a01181ff------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*YRL-S9Nz8eQwUhUcVhTBWg.jpeg</url>
            <title>Stories by Saul Urias Guzman on Medium</title>
            <link>https://medium.com/@sauluriasguzman?source=rss-6dd0a01181ff------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 08:58:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sauluriasguzman/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Semaphores vs Operations: ¿Cuál es la mejor opción para manejar la concurrencia en iOS con Swift?]]></title>
            <link>https://medium.com/@sauluriasguzman/semaphores-vs-operations-cu%C3%A1l-es-la-mejor-opci%C3%B3n-para-manejar-la-concurrencia-en-ios-con-swift-54045214d987?source=rss-6dd0a01181ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/54045214d987</guid>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[concurrent-programming]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[operations]]></category>
            <dc:creator><![CDATA[Saul Urias Guzman]]></dc:creator>
            <pubDate>Sat, 31 Dec 2022 03:30:56 GMT</pubDate>
            <atom:updated>2022-12-31T03:31:52.240Z</atom:updated>
            <content:encoded><![CDATA[<p>A la hora de desarrollar aplicaciones para dispositivos móviles, es importante tener en cuenta la concurrencia y cómo manejarla de manera eficiente. En iOS con Swift, existen dos herramientas principales para hacerlo: Semaphores y Operations. ¿Cuál es la mejor opción? Veamos las diferencias, ventajas y desventajas de cada una.</p><p>Semaphores son mecanismos de sincronización que permiten controlar el acceso a recursos compartidos por varios hilos. Por ejemplo, podemos utilizar un semáforo para evitar que dos hilos escriban al mismo tiempo en un archivo:</p><pre>let semaphore = DispatchSemaphore(value: 1)</pre><pre>func writeToFile() {<br>    semaphore.wait()<br>    // escribir en el archivo<br>    semaphore.signal()<br>}</pre><p>Por otro lado, Operations son tareas que se pueden agregar a una cola y ejecutar de manera concurrente. Por ejemplo, podemos crear una operación para descargar una imagen de Internet y otra para procesarla:</p><pre>let downloadOperation = BlockOperation {<br>    let imageData = try? Data(contentsOf: imageURL)<br>}</pre><pre>let processingOperation = BlockOperation {<br>    let image = UIImage(data: imageData)<br>    let processedImage = image.applyFilter()<br>}</pre><pre>processingOperation.addDependency(downloadOperation)</pre><pre>let queue = OperationQueue()<br>queue.addOperations([downloadOperation, processingOperation], waitUntilFinished: false)</pre><p>Entre las ventajas de utilizar Semaphores destaca su alta flexibilidad y control sobre el acceso a recursos compartidos. Además, son fáciles de usar y permiten evitar conflictos y errores en situaciones donde varios hilos compiten por el mismo recurso. Sin embargo, también es importante tener en cuenta que Semaphores pueden ser más difíciles de depurar y pueden requerir un mayor conocimiento de programación concurrente.</p><p>Por otro lado, las ventajas de utilizar Operations incluyen su facilidad de uso y su optimización para dispositivos móviles. Además, permiten crear dependencias entre tareas y manejar la prioridad de ejecución de manera sencilla. Sin embargo, también es importante tener en cuenta que Operations pueden tener menos control y flexibilidad que Semaphores y que pueden no ser la mejor opción para situaciones más complejas.</p><h3>Conclusión</h3><p>En conclusión, Semaphores y Operations son dos herramientas útiles para manejar la concurrencia en iOS con Swift. Semaphores ofrecen un alto grado de flexibilidad y control, pero pueden ser más difíciles de usar y depurar. Por otro lado, Operations son más fáciles de usar y están optimizadas para dispositivos móviles, pero pueden tener menos control y flexibilidad. Al elegir entre estas dos opciones, es importante tener en cuenta las necesidades del proyecto y las habilidades del equipo de desarrollo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=54045214d987" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ARC en Swift iOS]]></title>
            <link>https://medium.com/@sauluriasguzman/arc-en-swift-ios-28c499873a7f?source=rss-6dd0a01181ff------2</link>
            <guid isPermaLink="false">https://medium.com/p/28c499873a7f</guid>
            <category><![CDATA[memory-leak]]></category>
            <category><![CDATA[arc-swift]]></category>
            <category><![CDATA[automatic-reference-count]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[weakreference]]></category>
            <dc:creator><![CDATA[Saul Urias Guzman]]></dc:creator>
            <pubDate>Sat, 31 Dec 2022 03:16:39 GMT</pubDate>
            <atom:updated>2022-12-31T03:16:39.338Z</atom:updated>
            <content:encoded><![CDATA[<p>ARC (Automatic Reference Counting) es una característica de la programación en Swift que se encarga de gestionar automáticamente la asignación y liberación de memoria en nuestro código. Esto significa que no tenemos que preocuparnos por liberar la memoria manualmente cuando ya no la necesitamos, ya que ARC se encargará de hacerlo por nosotros.</p><p>Cómo funciona ARC:</p><ol><li>ARC funciona a través del uso de contadores de referencia, que llevan la cuenta de cuántas veces se usa un objeto en nuestro código.</li><li>Cuando se crea un objeto en Swift, se le asigna un contador de referencia de 1.</li><li>Cada vez que se hace referencia al objeto, el contador de referencia se incrementa en 1.</li><li>Cuando ya no se hace referencia al objeto, el contador de referencia se decrementa en 1.</li><li>Cuando el contador de referencia llega a 0, el objeto es eliminado de la memoria.</li></ol><h3>Ejemplo de ARC con Swift</h3><pre>class Person {<br>    let name: String<br>    init(name: String) {<br>        self.name = name<br>        print(&quot;\(name) is being initialized&quot;)<br>    }<br>    deinit {<br>        print(&quot;\(name) is being deinitialized&quot;)<br>    }<br>}<br><br>var reference1: Person?<br>var reference2: Person?<br>var reference3: Person?<br><br>reference1 = Person(name: &quot;John&quot;)<br>// Imprime &quot;John is being initialized&quot;<br><br>reference2 = reference1<br>reference3 = reference1<br><br>reference1 = nil<br>reference2 = nil<br><br>reference3 = nil<br>// Imprime &quot;John is being deinitialized&quot;</pre><p>En este ejemplo, tenemos una clase Person con una propiedad de name y un inicializador que imprime un mensaje cuando se inicializa una nueva persona. También tenemos un deinit que se ejecuta cuando se elimina una persona de la memoria.</p><p>Luego creamos tres variables opcionales reference1, reference2 y reference3 y les asignamos una nueva instancia de Person con el nombre &quot;John&quot;. Esto imprime el mensaje &quot;John is being initialized&quot;, lo que indica que se ha creado una nueva persona y se le ha asignado un contador de referencia de 1.</p><p>Luego asignamos reference1 a reference2 y reference3, lo que significa que ahora todas las variables tienen una referencia a la misma persona. Esto incrementa el contador de referencia en 2, lo que significa que ahora el contador de referencia de la persona es 3.</p><p>A continuación, eliminamos la referencia de reference1 y reference2 estableciéndolas en nil. Esto decrementa el contador de referencia en 2, lo que significa que ahora el contador de referencia de la persona es 1.</p><p>Finalmente, eliminamos la última referencia estableciendo reference3 en nil. Esto decrementa el contador de referencia en 1 y cuando llega a 0, se ejecuta el deinit y se imprime el mensaje &quot;John is being deinitialized&quot;, lo que indica que la persona ha sido eliminada de la memoria.</p><h4>Weak &amp; Unwoned</h4><p>En Swift, podemos usar referencias weak y unowned para romper la retención cíclica que se produce cuando dos objetos se hacen referencia mutuamente. Esto es importante ya que, como mencioné anteriormente, la retención cíclica puede causar problemas de memoria ya que ARC no puede liberar la memoria de ninguno de los objetos ya que siempre hay una referencia a ellos.</p><p>Las referencias weak y unowned son similares en que ambas permiten que un objeto tenga una referencia débil a otro objeto, lo que significa que no se incrementa el contador de referencia del objeto al que se hace referencia. Sin embargo, hay una diferencia importante entre ellas:</p><ul><li>Las referencias weak son opcionales y se establecen a nil cuando el objeto al que se hace referencia es eliminado de la memoria.</li><li>Las referencias unowned no son opcionales y se espera que el objeto al que se hace referencia siempre esté presente. Si el objeto es eliminado de la memoria, la referencia unowned provocará un error en tiempo de ejecución.</li></ul><p>Aquí tienes un ejemplo de cómo podríamos usar referencias weak y unowned en el código anterior:</p><pre>class Person {<br>    let name: String<br>    init(name: String) {<br>        self.name = name<br>        print(&quot;\(name) is being initialized&quot;)<br>    }<br>    deinit {<br>        print(&quot;\(name) is being deinitialized&quot;)<br>    }<br>}</pre><pre>class Apartment {<br>    let unit: String<br>    weak var tenant: Person?<br>    init(unit: String) {<br>        self.unit = unit<br>        print(&quot;Apartment \(unit) is being initialized&quot;)<br>    }<br>    deinit {<br>        print(&quot;Apartment \(unit) is being deinitialized&quot;)<br>    }<br>}</pre><pre>var john: Person?<br>var unit4A: Apartment?</pre><pre>john = Person(name: &quot;John&quot;)<br>// Imprime &quot;John is being initialized&quot;</pre><pre>unit4A = Apartment(unit: &quot;4A&quot;)<br>// Imprime &quot;Apartment 4A is being initialized&quot;</pre><pre>unit4A?.tenant = john</pre><pre>john = nil<br>unit4A = nil<br>// Imprime &quot;John is being deinitialized&quot;<br>// Imprime &quot;Apartment 4A is being deinitialized&quot;</pre><p>En este ejemplo, tenemos dos clases: Person y Apartment. La clase Person es igual que en el ejemplo anterior, pero hemos añadido una propiedad opcional tenant a la clase Apartment para hacer referencia a una persona.</p><h3>Conclusión</h3><p>En resumen, ARC (Automatic Reference Counting) es una característica muy útil de Swift que nos permite gestionar automáticamente la asignación y liberación de memoria en nuestro código. ARC funciona a través del uso de contadores de referencia, que llevan la cuenta de cuántas veces se usa un objeto en nuestro código. Cuando el contador de referencia de un objeto llega a 0, el objeto es eliminado de la memoria.</p><p>ARC nos permite evitar tener que preocuparnos por la gestión de la memoria de forma manual y nos permite evitar problemas comunes de memoria como los fugas de memoria. Sin embargo, es importante tener en cuenta que ARC no es perfecto y todavía es posible que tengamos problemas de memoria en nuestra aplicación si no utilizamos ARC de manera adecuada. En particular, es importante tener cuidado con las retenciones cíclicas, que ocurren cuando dos objetos se hacen referencia mutuamente. Podemos usar referencias weak y unowned para romper la retención cíclica y evitar problemas de memoria.</p><p>En general, ARC es una herramienta valiosa que debemos tener en cuenta al desarrollar aplicaciones en Swift y nos permite enfocarnos en el desarrollo de nuestra aplicación en lugar de preocuparnos por la gestión de la memoria manualmente.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=28c499873a7f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>