Ex-Machina


Durante los últimos años, se ha observado cómo la ciencia ficción se convierte poco a poco en parte de nuestra vida diaria. Elementos que han sido observados en películas y series como Star Trek, Doctor Who, Star Wars, desde videollamadas, teléfonos, que en años atrás los dispositivos no existían, ¿a qué viene esto? Los elementos de ciencia ficción suelen mostrarnos en el cine muchas de las ideas acerca del mundo en el que viviremos, una cuestión futurista. La película "Ex Machina", nos muestra un escenario con tres personajes (y uno secundario). 
La historia comienza con Caleb, un joven programador que trabajar en una empresa similar a Google, quien es ganador de un concurso interno que consiste en pasar una semana junto al presidente de la compañía. El inicio de la película, transcurre con el viaje de Caleb en helicóptero, luego llega con el presidente de la compañía quien vive aislado del mundo en un lugar que es una especie de paraíso, el cual es un lugar elitista, ya que no se permite la entrada al lugar por parte de otras personas. Caleb entra a la mansión donde conoce al presidente de nombre Nathan, quien nos muestra a un millonario excéntrico, que posee un look intimidante. 
En cualquier caso, incluso para el espectador más ingenuo, resulta evidente que Caleb no ha viajado hasta allí para tomar unas cervezas con Nathan. El propósito es desvelado muy pronto: participar en un experimento para determinar si una máquina posee inteligencia. ¿Cómo es el Test de Turing? El Test de Turing nos sirve para averiguar si una máquina es capaz de pensar a través de una serie de pruebas.  Una vez que Caleb acepta colaborar, entra en escena su gran creación, Ava, a quien el primero debe evaluar a través de unas entrevistas. Algo en lo que debemos prestar atención es que Ava tiene cierto encanto. 
Caleb comienza a preocuparse por la situación del Ava. Aunque al fin y al cabo, es una máquina, una cosa, sin derechos ni libertades, a merced de su creador. Durante las conversaciones entre los protagonistas; Caleb llega a plantearse si hay diferencia entre su existencia y la de la máquina. Del mismo modo, se llega a cortar para ver su composición fisiológica. Nathan llega a decir: "Un día nos mirarán como si fuésemos simios condenados a la extinción". No son pocos los científicos que han alertado sobre este riesgo, temiendo las posibilidades de un ordenador cuyo "cerebro" superaría al de sus creadores, y consciente de su diferencia, pudiera temer por su supervivencia y reproducirse o defenderse de manera catastrófica para el ser humano.
La película nos remonta a ciertos aspectos por analizar, ¿qué relación llevamos hoy en día con la tecnología? Los avances tecnológicos nos muestran poco a poco cómo la tecnología forma parte de nosotros como seres humanos, podemos observar la Realidad Aumentada. Aunque también es importante mencionar la serie de Black Mirror, la cual nos muestra diferentes escenarios futuristas en los cuales las cosas no han salido tan bien con la tecnología.  


Tutorial App: Web Services - API Clima

En este tutorial veremos cómo desarrollar una Aplicación que consuma datos de un API. Probablemente se estén preguntando, ¿qué es una API? Bueno, una API (Aplication Programming Interface), es un conjunto de reglas (código) y especificaciones que las aplicaciones pueden seguir para comunicarse entre ellas. Más que nada la función es facilitar la comunicación entre humano-software.

Últimamente muchas redes sociales y plataformas como Twitter, Facebook, YouTube, Flickr, LinkedIn, Google Maps, Wordpress, etc., han creado diversas API para manejar información, así como permitir el uso de funciones ya existentes en otro software, para no estar reinventando o buscando la manera de consumir información.

La API que utilizaremos el día de hoy, será la proporcionada por Open Weather Map que posee una sección denominada API (http://openweathermap.org/api).

Ahora bien.

Comencemos.

Nuestro primer paso será crear una aplicación del tipo Single View


Agregamos un nombre a nuestra Aplicación

Quitamos la opción de Auto Layout



Lo siguiente será ajustar nuestra App a un tamaño predeterminado como lo es iPhone 4.


El siguiente paso será agregar una serie de elementos:
Un label que será nuestra etiqueta de Clima, otro label para el título de Ciudad, un TextField para capturar el nombre de la ciudad que nos interesa averiguar el clima, después otro label donde aparecerán los datos de la ciudad y por último un botón que no permitirá al momento de hacer un touch up, interactuar con nuestra aplicación.


Buscaremos alguna imagen ya sea en Google, o alguna que tengamos en nuestra computadora, un tipo interesante es buscar "wallpaper for iphone 4" por mencionar un ejemplo, ya que vienen con un tamaño específico para el móvil.


Creamos una carpeta (en XCode se llama "New Group") para crear y agregar nuestra imagen que hemos descargado.


A la derecha se puede ver la carpeta y la imagen contenida.


Una manera además de utilizar un elemento del tipo ImageView, es utilizar los atributos que posee nuestra aplicación, así que lo que haremos será escribir las siguientes instrucciones para que nos agregue la imagen como fondo de nuestra Aplicación.



Lo siguiente será poner los label en color blanco, que aunque al comienzo puede que no se vean, al momento de cargar nuestra App, se cargará con el background de imagen.



Una manera bastante sencilla de lograr menos complicaciones, es crear una constante para almacenar el nombre de la imagen.


Nuestro próximo paso será vincular los elementos y así definir las variables que utilizaremos para nuestra App.


Para la información que usaremos en nuestra App será manejar Open Weather Map, un sitio que provee información climatológica y que a su vez, provee una API desde la cual podremos obtener datos.


Ya si están interesados en buscar más información, métodos para consumir los datos y demás, simplemente se van a la Opción de API dentro del sitio Web


A modo de ejemplo, si nos interesa averiguar la información climatológica de Guadalajara accedemos a la siguiente URL:

http://api.openweathermap.org/data/2.5/weather?q=guadalajara

La cual nos mostrará toda la información en formato JSON.


Si se dan cuenta los datos no se ven con una estructura muy legible.

Así que lo que haremos será instalar la siguiente extensión en nuestro navegador para poder visualizar de una manera más bonita.


Volviendo al código, escribimos la siguiente instrucción, al momento de presionar el botón "iniciarWebService" nos imprimirá en el visualizador el nombre de la ciudad que hayamos escrito, esto nos sirve para verificar si hemos hecho todo bien.


Compilamos y verificamos.


Lo siguiente será crear una función denominada "llamadaWebService", quitamos nuestro printLn() y agregamos la llamada a la función. Una vez en la función escribimos una constante la cual contendrá la url de la API de donde obtendremos información.

Otra constante para convertir la cadena en un tipo url, así como crear una constante para nuestra sesión. Crearemos una constante que nos servirá para denominar o crear tareas que realizaremos con nuestra url y la sesión.


Vemos todo el código que hemos escrito, por ejemplo, una validación para imprimir y revisar si error NO está vacío y así nos imprima el error que posee. 



Ahora bien, compilamos y podremos observar que el resultado puesto en println se ve extraño, bueno, esto es la información que nos arroja la url, el detalle es que no posee un formato legible a los humanos.



Así que lo que haremos será crear otra función que nos permitirá recuperar el clima pero ya en formato JSON, para ello creamos una constante llamada "jsonCompleto" que permitirá "serializar" nuestro JSON y permitirle una conversión de datos ilegibles a un formato más estructurado.


Corremos nuestra aplicación y podremos verificar que los datos han cambiado de estructura


Acá se puede ver la función completa para hacer el cambio de JSON legible y la tarea es que se despliegue en texto en pantalla y que en lugar de que aparezca la información en inglés, aparezca en español directamente del API. 

Referencias:

http://www.ticbeat.com/tecnologias/que-es-una-api-para-que-sirve/
http://openweathermap.org/

Repositorio de código fuente:

https://github.com/OmarSainz/swift-apps





Tutorial Git





Cuando se es programador, una de las herramientas que se convierten en nuestras mejores amigas es Git. Se trata de un sistema de control de versiones creado por nada más y nada menos que Linus Torvalds, el creador del Kernel Linux y es la mejor manera de evitar catástrofes en nuestro código además de ser un excelente gestor del trabajo cuando se trabaja en equipo.

Git principalmente se usa para código, incluso hay lugares en la web (Como BitBucket y GitHub) que se dedican a crearnos un frontend para la gestión de nuestro código controlado por Git; Sin embargo, no veo razón alguna por la cual Git no pueda ser usado por otras personas para otros ámbitos (diseño, arquitectura, qué se yo) en proyectos que requieran trabajar con más de una versión de un archivo y varias modificaciones. Dicho esto, aprendamos Git pues:

NOTA: Para éste tutorial usaré un sistema Linux (Ubuntu) como referencia, pero (exceptuando las instrucciones de instalación) las mismas instrucciones de uso de Git aplican para cualquier otra distro Linux, además de para MacOS o bien, gente que use CygWin en Windows  por ejemplo.

1) Instalando Git

Para instalar Git en Ubuntu Linux por ejemplo, haríamos lo siguiente en Terminal:

sudo apt-get install git git-core

2) ¿Primera vez? Configura tus Opciones

Ahora tendremos que correr éstos comandos (Globales entre sistemas) para configurar nuestras opciones de Git:

1. git config --global user.name "Tu Nombre"
2. git config --global user.email tu-email@servicio.com
3. git config --global push.default simple

Como podrán notar, el nombre va entre comillas, el e-mail no.

3) Editor predeterminado

Cuando necesitemos añadir un mensaje a nuestros Commits y no lo hagamos directamente desde consola por ejemplo, necesitamos que un editor aparezca y nos recuerde/permita hacerlo, para configurar ésta opción hacemos:

git config --global core.editor "editor" 

Algunas opciones a usar en lugar de "editor" son por ejemplo: subl -w (ParaSublimeText en todas las plataformas) mate -w (Para TextMate en Mac) gvim -f (Para GVim en Linux) o bien, mvim -f (Para MacVim en Mac); Yo personalmente usonano para el editor nano (de consola) en Linux. Recuerda que debes seleccionar una opción según tu sistema operativo y asegurarte de que el editor está instalado... Para Linux por ejemplo usaremos GVim y lo instalaremos de la siguiente manera antes de establecer la opción (en Ubuntu):

sudo apt-get install vim vim-gtk vim-gnome

4) Nuestro primer Repo!

Ahora sí, es hora de empezar a trabajar con Git para conocer sus beneficios: Crea una nueva carpeta en algún lugar y añade unos 2 o 3 archivos de texto (o HTML o de cualquier tipo de script o código que quieras) además de una imagen .jpg o .pngpor ejemplo, una carpeta vacía (con el nombre "empty") y un archivo vacío con extensión ".dumm" (y de nombre "archivo") jaja. En tu terminal haz cd hacia la ruta de la carpeta donde pusiste todo, luego inicializa un repositorio Git... Éstos dos pasos se hacen así:

cd ruta/a/carpeta
git init 

5) Git Ignore

Por defecto, Git siempre toma todo el contenido de la carpeta del proyecto donde se inicializó el repo y lo utiliza cuando trabajamos con el repositorio... El problema con ésto es que hay ciertos archivos que ciertamente no queremos en nuestro repositorio o es más, no queremos que se les tome en cuenta porque son constantemente cambiados. Éstos son aquellos como por ejemplo los "Logs" o también, el famoso "Thumbs.db" en Windows por solo mencionar algunos. Para evitar que éstos archivos se nos interpongan, tenemos que crear un archivo llamado .gitignore (obviamente oculto) en la raíz de la carpeta del proyecto y debe de tener el siguiente formato según nuestras necesidades:

# Ignorando grupos de archivos individuales por extensión

rutas/de/locación/*.extensión

# Ignorando una Carpeta

ruta/a/carpeta/ignorada

# Ignorando un Archivo Individual

ruta/a/archivo.ext

Si ésto de arriba no tuvo mucho sentido para ti, veamos un ejemplo: Por decir, supongamos que quiero evitar que Git cargue las imágenes que puse en mi carpeta de ejemplo que hice arriba, el archivo ".dumm" que me inventé y la carpeta vacía. Mi archivo .gitignore quedaría algo así:

# Ignorando JPG's y PNG's

/*.jpg
/*.jpeg
/*.png

# Ignorando la Carpeta Vacía

/empty

# Ignorando un Archivo Individual

/archivo.dumm
Si estás acostumbrado a trabajar con rutas de carpetas en Linux o MacOS por ejemplo, entonces éste archivo no te parecerá raro: es lo mismo. La única diferencia es que toma como Raíz a la carpeta del proyecto y de ahí uno selecciona los archivos que quiere ignorar. En el caso de querer ignorar en base a  las extensiones usamos el comodín (*) para que ignore todos los archivos que sean de ésa extensión. Si te das cuenta, en ningún momento pasamos parámetros (Como -R) puesto que Git está muy bien configurado y hará su trabajo a la perfección de manera recursiva, ésto quiere decir que aplicará las reglas adecuadas en directorios y subdirectorios (además de en todos sus archivos) cuando se amerite según nuestras instrucciones del archivo .gitignore.

6) Añadiendo archivos

Lo siguiente que se hace es añadir los archivos a nuestro árbol git. Dentro de la terminal (estando en la ruta de la raíz de nuestro proyecto) hacemos lo siguiente:

git add .

Éso es simplemente para hacer que todos los archivos (nuevos y modificados) sean añadidos a una especie de "lista de espera" de Git. El mismo comando lo tenemos que correr al borrar y/o añadir archivos/carpetas para que git tome en cuenta las modificaciones en el proyecto.

7) Haciendo válidos los cambios

Ahora tenemos que realizar un commit, para hacer válidos los cambios en nuestro proyecto. Ésto se hace con:

git commit -m "Mensaje" 

Lo que va después de -m es el mensaje que describe a éste commit, siempre hagan sus commits con un mensaje de preferencia. Si no quieren añadir mensaje, omitan el-mgit commit hace válidos los cambios de manera Local en nuestro árbol del proyecto.

NOTAS: Cabe destacar que puedes usar los comandos git status y git log para monitorizar tu proyecto con Git de cuando en cuando. Por otro lado, si haces cambios menores en tu proyecto (como renombrar archivos, editarlos etc) Puedes usar el siguiente comando para añadir y hacer el commit:

git commit -a -m "Mensaje" 


Pero recuerda que si haces cambios importantes (Como añadir nuevos archivos o eliminar otros por ejemplo) debes de usar el comando de add . y luego el de commitcomo lo harías regularmente.

8) Git y su Utilidad

Supongamos que por alguna razón eliminaste de manera forzada e irrecuperable (rm -rf jajajaja) algún archivo o carpeta de tu proyecto desde tu último commit. Bueno, pues siempre puedes volver al último snapshot de tu código (es decir, al código como estaba al momento de realizar el último commit registrado) con el comando:

git checkout -f

El parámetro -f hace que git force a sobreescribir los cambios hechos por accidente en el proyecto y se restauren los archivos y carpetas de nuestro último commit.

9) A la Nube!

Todo ésto que hemos estado viendo es en el ámbito Local. Pero, ¿Qué pasa si estoy colaborando con varios programadores en un mismo proyecto? Qué tal si quiero tener un backup de mi código en alguna parte que no sea mi PC? Qué tal si quiero que más y más gente me conozca y tenga acceso a lo que hago? Aquí es donde entran en juego los servicios de almacenamiento de repositorios Git como podrían serGitHub y BitBucket o bien, Gitorious. Personalmente, prefiero BitBucket debido a que ofrece prácticamente las mismas funciones que GitHub y similares además de algunas ventajas que se agradecen, como el hecho de poder tener todos los repositorios públicos y privados que quieras completamente gratis. Es por ésto que en éste tutorial usaremos ése servicio, pero estás en libertad de irte con el que más te convenza.

Lo primero que haremos será sacar una cuenta de BitBucket en bitbucket.org, configuraremos nuestras preferencias y validaremos la cuenta. Más adelante, crearemos un nuevo repositorio PRIVADO que funcione con Git como control de versiones:



Le ponemos un nombre, seleccionamos un lenguaje (la selección de lenguaje ahorita es indiferente, pero trata de seleccionarlo según el tipo de lenguaje más utilizado en tu proyecto) y de momento no marcamos ni Wiki ni Issue Tracking, pues no los vamos a usar. Añadimos una descripción y nuestra web si así lo queremos también.

10) Git Push

Una vez teniendo un lugar en la web que nos sirva de alojamiento para nuestro repo, tenemos que pasar nuestros cambios a la web, así como hacemos commits locales. Justo después de hacer un commit local, si uno quiere que ésos cambios pasen a la nube (usando bitbucket) hace:

git remote add origin https://usuario@bitbucket.org/usuario/repo.git
git push -u origin master 

Reemplazando "usuario" por tu nombre de usuario en bitbucket y "repo" por el nombre del repo hacia donde quieres enviar tu código.

Y eso hará que Git sepa que tiene que subir la rama principal del proyecto (es decir todo el proyecto pues) a BitBucket. Para fines prácticos (no tener que introducir credenciales) uno usa integración con SSH pero eso está para explicarse en otra ocasión. También debo recalcar que el comando 1 se tiende a usar una sola vez cada que añadimos un nuevo origen remoto (por cada repo inicializado) según las instrucciones que se nos hayan dado en el mismo, y el 2 pasa a ser simplemente git push en la mayoría de sistemas tras haberlo usado como aquí se muestra la primera vez en cada repo inicializado.

11) Branching

Imaginemos a nuestro proyecto en Git como un árbol donde la raíz es el proyecto principal y de ahí crecen varias ramas. El branching en Git es justo lo que te imaginarás: Se trata de crear ramificaciones del proyecto en base a copias del código del proyecto original en las cuales podemos realizar modificaciones sin preocuparnos por comprometer el proyecto en sí. Ésto quiere decir que si yo tengo un proyecto en el cual se me ocurre añadir una nueva característica que quizá no sea lo suficientemente confiable a nivel estabilidad puedo hacerlo en una rama de mi proyecto y dejar el original intacto. Para crear ramas, usamos el siguiente comando:

 git checkout -b NombredeRama

Donde "NombredeRama" es el nombre que le pondremos a nuestra rama que se creará entonces. Podemos usar el comando git branch para saber en qué rama estamos trabajando actualmente en el proyecto. Si queremos saltar de rama en rama, usamos el comando:

git checkout rama

Donde reemplazaremos "rama" (obviamente) por el nombre de la rama a la que queramos saltar.

12) Merging

Supongamos que creaste una rama nueva donde hiciste algunas modificaciones que resultaron ser una buena idea y quieres que el proyecto original (rama master) las integre. Para ésto sirve el merging... Si queremos combinar 2 ramas, nos moveremos a la rama donde queramos integrar el código nuevo (en el ejemplo la master) y haremos el merge con:

git merge Rama-a-Mezclar 

Donde "Rama-a-Mezclar" es el nombre de la rama que mezclaremos con la rama a la que nos movimos. Si vamos a mezclar "ramapatito" con "master" por ejemplo entonces haríamos:

git checkout master
git merge ramapatito

Y eso añadiría los cambios realizados en "ramapatito" a la rama principal del proyecto.

13) Borrando Ramas

Cuando queramos borrar una rama que ya haya sido mezclada, lo haremos con:

git branch -d Rama 

Donde "Rama" es obviamente el nombre de la rama...

Y si queremos borrar una rama que no ha sido mezclada tendríamos que usar -D en lugar de -d como en el ejemplo de arriba. Ojo que ésto no elimina los archivos mezclados, sino simplemente la rama como contenedor, para eliminar los archivos mezclados (si al final no te gustó) harías un rollback como mostramos en el paso 8.

Básicamente esas son las opciones fundamentales de Git y para qué nos sirve cada una. Espero que éste tutorial haya sido de su agrado y que a partir de ahora valoren la posibilidad de usar Git para sus proyectos... Quieras que no, te permite tener un ambiente de trabajo más ordenado y tranquilo.

Fuente: 
Git desde Cero

El giro del Material Design





La idea principal de Material Design es servir de lenguaje de diseño común en un amplio rango de dispositivos y, por tanto, de experiencias de usuario. Desde el móvil hasta la Web, pasando por las tabletas, podrán servirse de este lenguaje de diseño. Está diseñado sobre todo para ser utilizado en dispositivos táctiles, pero no deja de lado otros métodos de entrada como el teclado, el ratón o la entrada por voz.


Todos los elementos de una interfaz que siga este lenguaje de diseño pueden tener relieve. El mundo real no es plano, por lo que la representación del mundo real que Material Design nos permitiría crear tampoco lo sería. De igual modo, un objeto en el mundo real sigue una serie de leyes físicas; cada objeto dentro de una interfaz de Material Design también debería seguirlas.


Lo principal es entender las aplicaciones y los elementos que forman parte de ellas, porque su interacción será idéntica a la del mundo real. La tipografía también tiene mucho más sentido en este nuevo lenguaje de diseño: distintos tamaños y cuerpos permiten crear jerarquías. Tienen un sentido, más allá de ser atractivas a la vista. Las animaciones también buscan imitar la interacción de los objetos en el mundo real (y, por cierto, prometen 60 frames por segundo, incluso en la Web).


La tipografía cobra un sentido mayor del que tiene ahora, con diferentes tamaños y cuerpos que permiten crear jerarquías. Y por supuesto las nuevas animaciones, que es lo que más entra por el ojo. Pasaremos de una animaciones algo simplonas a unas nuevas mucho más animadas y con efectos realmente llamativos. Sin duda un bonito cambio para nuestro sistema favorito que venía pidiendo desde hace tiempo un pequeño lavado de cara, y que ahora Google parece va a realizar en el diseño de aplicaciones.


Desde luego se nota que le han dedicado mucho trabajo a este nuevo lenguaje de diseño para sus interfaces, cuidando muchos de los detalles (como que un menú emergente surja desde el elemento que la invoca y no desde el centro de la pantalla, por ejemplo).


La fiebre por Material Design, el nuevo concepto de diseño creado por Google para Android 5.0 Lollipop, sigue en alza. Y tanto es así que esta semana ha nacido un nuevo proyecto que pretende llevar las directrices de diseño publicadas por Google a nuestros equipos de sobremesa mediante una nueva distribución GNU/Linux que se llamará Quantum OS.


Para conseguir este objetivo, Michael Spencer tiene pensado basarse en alguna distribución ya consagrada como Arch Linux o Ubuntu, utilizando el framework multiplataforma Qt5 con el lenguaje programación QML, lo que permitirá que sea usado en el servidor gráfico Wayland. De momento, Quantum OS es sólo una idea en la mente de su creador llevada al "papel mediante los diseños creados por Andrea Del Sarto, pero eso no quita que sea un proyecto de lo más interesante.


Aun es pronto para saber qué dirección tomará Quantum OS, y si seguirá adelante con su idea de crear una nueva distro por su cuenta o unirá esfuerzos con alguna otra. Pero lo que sí está claro es que, de llevarse a cabo, podría ofrecer una interesante alternativa para todos los amantes de Material Design.


Fuentes: