Genericidad en Swift

La genericidad es una de las características más poderosa de Swift, como también lo es en otros lenguajes de programación; nos permite definir estructuras de datos de tipo seguro (type-safe) y funciones sin tener que comprometernos con un tipo de dato en específico, aunque podemos definir algunas reglas.

Este tipo de funcionalidad nos permite reutilizar código, sobre todo, algoritmos relacionados al procesamiento de datos.

¿Para qué la genericidad?

Vamos a ver con un ejemplo, qué tipo de problemas la genericidad nos ayuda a resolver.

Supongamos que queremos desarrollar una estructura de datos Pila (Stack) que podamos utilizar con cualquier tipo de datos, la cual va a tener los métodos clásicos, poner un elemento en la pila (push) y extraer un elemento de la pila (pop). Vamos a asumir que Swift no soporta genericidad.

Seguir leyendo “Genericidad en Swift”

¿Qué pasó con mis “for” estilo C en Swift 3?

Ayer Apple anunció en el WWDC la disponibilidad de Xcode 8 beta para los desarrolladores y con ella Swift 3.

Si has tenido un tiempo de probar algún código escrito con una versión anterior de Swift es probable que hayas encontrado algunos errores inesperados, inesperados si no has estado al tanto de la evolución de Swift por estos meses.

Creo que los errores más comunes que nos vamos a encontrar en código viejo, cuando migremos a Swift 3, son las cosas que iban a marcarse obsoletas para esta versión. Una de ellas es la sintaxis del for estilo C.

for estilo C

Ya desde la versión 2.2 de Swift, Xcode nos venía alertando que esta sintaxis iba a ponerse obsoleta en versiones futuras. Si aún tienes instalado Xcode 7.x puede probarlo en un Playground:

Xcode alertando sobre for estilo C
Xcode alertando sobre for estilo C

Seguir leyendo “¿Qué pasó con mis “for” estilo C en Swift 3?”

Principio Open-Closed en Swift

En este post vamos a ver un ejemplo de diseño que no cumple con el principio Open-Closed y una versión del mismo ejemplo que sí cumple con el principio.

Principio Open-Closed (OCP)

Los principios SOLID son cinco principios básicos del diseño y la programación orientada a objetos, uno de los cuales es el principio Open-Closed

Una descripción más detallada de este principio la pueden encontrar en un artículo de Robert C. Martin “Uncle Bob”, coautor del Manifiesto Ágil, titulado The Open-Closed Principle.

Bertrand Meyer acuñó este principio en 1988 de la siguiente manera:

Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification.

Y en su artículo, Uncle Bob nos explica que:

Los módulos que cumplen con el principio open-closed tienen dos atributos principales:

  1. Están “abiertos para extensiones” (Open).
    • Esto significa que el comportamiento de un módulo puede ser extendido. Que podemos hacer que un módulo se comporte de nuevas y diferentes maneras a medida en que los requerimientos de la aplicación cambien, o para satisfacer nuevas aplicaciones.
  2. Están “cerrados para modificaciones” (Closed).
    • El código fuente de dicho módulo es inviolable. Nadie está autorizado a cambiar dicho código.

Seguir leyendo “Principio Open-Closed en Swift”

Opcionales en Swift

El otro día un amigo me comentaba que estaba implementando un juego para probar Swift por primera vez y me contaba que estaba teniendo problemas entendiendo algunas cosas de los opcionales (optionals) en Swift. Pensé que era un buen tema para escribir un pequeño post y de paso generar un poco de documentación en Español, lo cual es uno de los principales propósitos de este blog.

Opcionales

Según la documentación de Swift,

Los opcionales se utilizan en situaciones donde el valor puede estar ausente.

Este concepto no existe en Objective-C, en el cual es permitido incluso enviar un mensaje a nil. Lo más cercano a representar ausencia de valor es retornando nil en métodos que de otra manera deberían devolver un objeto, pero esto solo funciona con objetos y no con enumeraciones, estructuras y tipos básicos de C para los cuales generalmente se utiliza NSNotFound para representar ausencia de valor; en dependencia del tipo, algunos desarrolladores también utilizan 0, -1, NSIntegerMax y cosas parecidas.

Seguir leyendo “Opcionales en Swift”

Selector, su evolución en Swift

Antes de ver la evolución de los selectores en Swift, veamos qué es un selector en Objective-C.

Los selectores en Objective-C son del tipo SEL y es la manera mediante la cual podemos identificar/seleccionar un método y luego poder ejecutarlo en un objeto.

Las formas más comunes de obtener un selector son a través de la directiva @selector y la función NSSelectorFromString, veamos como se utilizan ambas:

SEL selector1 = @selector(calcularArea);
SEL selector2 = NSSelectorFromString(@"calcularArea");
SEL selector3 = @selector(avanzar:);
SEL selector4 = NSSelectorFromString(@"avanzar:");

En las líneas 1 y 2 representamos a un método que no tiene argumentos “calcularArea” y en la 3 y 4 representamos a un método con un argumento “avanzar:”.

Seguir leyendo “Selector, su evolución en Swift”

“Delegation” en Swift

A lo largo de tu carrera como desarrollador de aplicaciones para iOS te encontrarás utilizando muchos patrones de diseño como por ejemplo Singleton, MVC, Decorator, Observer; pero uno de los más importantes y utilizados es Delegation. Antes de entrar en detalles, ¿qué es un patrón de diseño?

Patrones de diseño

No vamos a profundizar en este post acerca de los patrones de diseño pues hay muchos artículos y libros sobre el tema, solamente veremos de que se trata y pueden consultar luego al respecto.

El concepto de patrones de diseño fue introducido en 1994 en el libro “Design Patterns: Elements of Reusable Object-Oriented Software” de los autores Erich Gamma, Ralph Johnson, Richard Helm, John Vlissides, el cual trata sobre temas de Programación Orientada a Objetos y patrones de diseño y desde entonces ha influenciado mucho en la ingeniería de software; este colectivo de autores es conocido por “Gang of Four (GoF)”.

Seguir leyendo ““Delegation” en Swift”

Protocolos en Swift (básico)

Antes de continuar con la serie de tutoriales sobre como crear un juego como Gorilla Rush, me pareció útil escribir un par de post acerca de algunas características de Swift, las cuales vamos a utilizar en los tutoriales.

En esta ocasión voy a hablar acerca de protocolos. Los protocolos probablemente sea algo nuevo para ti, pues si tienes experiencia en lenguajes como C# o Java seguramente has utilizado o leído sobre interfaces… bueno, eso es lo que un protocolo es en Swift.

No vamos a entrar en muchos detalles en este post sobre qué es una interfaz o protocolo, o cuándo usarlos o cuándo no, sobre esto hay bastante documentación en la web. Vamos en enfocarnos más en cuál es su sintaxis en Swift y algún que otro ejemplo.

En Swift, un protocolo es como un plano, que define métodos, propiedades y otros requerimientos que responden a una tarea en particular. Puede ser adoptado por una clase, estructura o enumeración con el objetivo de brindar una implementación a estos requerimientos. Cualquier tipo que implemente un determinado protocolo se dice que implementa (o se ajusta) a ese protocolo.

Sintaxis

Un protocolo se define de forma muy similar a una clase, estructura o enumeración:

Para que un tipo pueda adoptar/implementar un protocolo, debe colocar el nombre del protocolo luego del nombre del tipo separados por el signo de dos puntos como parte de su definición, el tipo puede implementar más de un protocolo colocándolos separados por coma:

Si una clase hereda de una super clase, coloca primero la superclase y luego los protocolos que implemente separados por coma:

Ejemplo

Antes de continuar veamos un ejemplo.

  1. Primero definimos el protocolo Hablar el cual contiene un método, decirHola(nombre: String).
  2. Definimos la clase Persona que va a adoptar/implementar el protocolo Hablar.
  3. Brindamos una implementación al método decirHola(nombre: String) en la clase Persona.
  4. Este método sólo va a imprimir el texto “Hola” seguido del valor que se le pase a través de la variable nombre que es de tipo String.
  5. Creamos dos variables con los nombres juliana y geykel, ambas guardan una referencia a un objeto de tipo Persona.
  6. Finalmente invocamos el método decirHola en ambas variables y el resultado que veremos serán dos lineas, la primera: “Hola Geykel.”, y la segunda: “Hola Juliana.”.

Propiedades

En Swift un protocolo puede también requerir al tipo que lo implemente, definir propiedades, especificando el nombre y el tipo de la propiedad y si la misma servirá sólo para obtener un valor o si además permitirá establecer un valor.

El siguiente ejemplo muestra los dos casos:

La primera propiedad especifica que puede tanto establecer un valor como devolver un valor, y la segunda sólo devolver.

En la definición de propiedades en un protocolo no se especifica si son propiedades cuyo valor es calculado o si sólo es una propiedad para almacenar un valor; es responsabilidad del tipo que implemente el protocolo decidir esto.

En el siguiente ejemplo veremos un caso de propiedad calculada:

  1. Definimos el protocolo NombreCompleto el cual provee una definición de la propiedad nombreCompleto: String { get } la cual sólo puede ser utilizada para devolver un valor debido a que no contiene un set.
  2. Definimos la clase Persona que implementa el protocolo NombreCompleto.
  3. Definimos dos atributos de la clase Persona, nombre y apellidos de tipo String.
  4. Creamos un inicializador (conocido en otros lenguajes como constructor) el cual inicializa los atributos de la clase Persona.
  5. Ahora implementamos la propiedad nombreCompleto que adoptamos del protocolo NombreCompleto.
  6. Como desarrollador de la clase he decidido que el valor retornado por esta propiedad es calculado y es el resultado de concatenar el valor de los atributos nombre y apellidos.
  7. Creamos una variable llamada juan la cual guarda una referencia a un objeto de tipo Persona, este objeto fue creado utilizando el inicializador que definimos en el paso 4.
  8. Llamamos a la función print para visualizar el valor de la propiedad nombreCompleto el cual es “Juan Pérez”.

Esto es todo lo que quería cubrir en este post, es más que suficiente para cubrir las bases para la serie de tutoriales sobre Gorilla Rush.

Hay mucho más sobre protocolos en Swift, incluso algunas funcionalidades que no había visto antes en lenguajes como Java y C#. Si deseas conocer más puedes consultar la guía de Swift en el sitio para desarrolladores en Apple.

Gorilla Rush, Parte 1: Creando el proyecto Xcode

Como prometí en el post anterior, hoy comenzaremos la serie de tutoriales sobre cómo hacer un juego como Gorilla Rush. Hoy comenzaré explicando cómo crear el proyecto en Xcode. Al momento de escribir este post, la versión estable de Xcode es la 7.1 y iOS 9.1 aunque el juego lo vamos a escribir para la versión de iOS 9 o superior.

Pueden descargar Xcode desde la App Store de Apple para Mac.

Nota: Esta serie de tutoriales asume que tienes algún conocimiento de programación y del lenguaje de programación Swift, Ray Wenderlich tiene una serie de tutoriales sobre Swift que te puede ser de mucha ayuda o leer la guía de Swift de Apple, también disponible en iBooks.

Seguir leyendo “Gorilla Rush, Parte 1: Creando el proyecto Xcode”

¿Cómo surgió Gorilla Rush?

Actualización: Ya está disponible la primera parte del tutorial, échale un vistazo.

¿Cómo surgió Gorilla Rush? buena pregunta… ya hacía varios años que no hacía algo para móviles, por algo me refiero a una aplicación o juego y desde entonces mucho ha cambiado en el ecosistema de desarrollo de Apple para iOS por lo que desde hace un tiempo tenía ganas de experimentar con el nuevo lenguaje de programación Swift y el framework para desarrollo de juegos SpriteKit, pues el último juego que hice con un grupo de amigos fue utilizando Objective-C, Cocos2d y Box2d.

La empresa donde me encuentro trabajando en estos momentos, ThoughtWorks Ecuador, desde el año anterior ha estado patrocinando la edición de Campus Party en Ecuador, específicamente el espacio del Coding Zone, donde se imparten charlas relacionadas a varios aspectos del desarrollo de software. Aproveché esta oportunidad para junto con Ariam y Meybis desarrollar un pequeño juego y hacer una charla sobre como hacer un juego sobre esta plataforma, en otro post les comento como fue esa experiencia.

Seguir leyendo “¿Cómo surgió Gorilla Rush?”