domingo, 29 de agosto de 2010

Uso básico de Git

Git es un sistema de control de versiones distribuido.

Un sistema de control de versiones, es un software que administra los cambios realizados en un conjunto de archivos, pudiendo ver el estado de cualquier elemento en cualquier momento dado, combinar cambios realizados por otros, ver las diferencias, etc.

Al ser distribuido, cada "clon" del repositorio tiene toda la información necesaria así como la historia completa, pudiendo realizar todas las operaciones sin necesidad de estar conectado al servidor centralizado (en caso que exista).

No es el único producto que hace esto, existen muchos más, como por ejemplo Mercurial o SubVersion (este último es centralizado).

Git se usa para el trabajo en equipo (generalmente para el desarrollo de software), ya que permite que cada uno de los integrantes del equipo tenga su propia versión, realiza sus propios cambios, y luego combina las modificaciones realizadas (merge).

Pero en realidad, Git también sirve para equipos de una sola persona. Por ejemplo a mi me da mucha más tranquilidad trabajar con un control de versiones que me permite volver a un estado anterior, que tener cualquier otra clase de respaldo. Cuando se que atrás tengo un control de versiones, me resulta mucho más fácil hacer modificaciones para hacer pruebas.

Veamos entonces un poco del uso de Git.

Hay dos formas de inicializar un repositorio. Una es creando un nuevo repositorio, lo que se hace (en el directorio donde queremos realizar el control de versiones) con
git init
La otra alternativa es clonar un repositorio que ya existe, para esto usamos
git clone [url_del_repositorio]
En la medida que se hacen cambios en los archivos o se agregan archivos nuevos, estos se deben ir agregando con
git add [nombre_archivo]
En cualquier momento podemos ver el estado del repositorio con
git status
Esto muestra varias cosas:
  • archivos modificados/agregados/borrados que todavía no se han incorporado al repositorio (falta un git add/rm
  • archivos modificados/agregados/borrados que ya se agregaron al repositorio
  • commits por delante o por detrás del repositorio centralizado
Una vez que tenemos los cambios y ya están agregados, se debe hacer un commit
git commit -m "descripción del commit"
Si queremos volver a la versión anterior de un archivo (y todavía no se hizo el commit)
git checkout -- [nombre_archivo]
Nótese que este commit no envía los cambios al repositorio centralizado (en caso que exista). Para eso, debemos hacer
git push [url_del_repositorio]
La cantidad de opciones disponibles en Git es mucho mayor que esta. En general está bien documentado y se puede encontrar toda la información necesaria buscando en internet.

Una de las cosas que facilita mucho Git, es hacer "branches". Esto es, creo una nueva versión en que es independiente del "trunk" (rama principal del desarrollo) en la cual realizo cambios, que en algún momento son combinados con el desarrollo principal o descartados. Les dejo de deberes la sintaxis :)

sábado, 28 de agosto de 2010

Animar la interfaz de usuario en iOS

Una de las cosas que tienen mucho las aplicaciones para el iPhone, son animaciones en la interfaz de usuario, por ejemplo en las transiciones entre pantallas.

Esta animación, la que se da al pasar de una pantalla a otra, es bien simple. Lo único que se precisa es pasar un parámetro a la función que muestra la siguiente vista. Algo así:
[navigationController pushViewController:newViewController animated:YES];
Pero además, también es muy sencillo crear animaciones más complejas, de forma totalmente trivial. Alcanza con encerrar el código que modifica la interfaz de usuario en un bloque de animación.
[UIView beginAnimations:nil context:nil];
[UIView setAnimationDuration:duration];

//código del cambio que queremos hacer en la UI

[UIView commitAnimations];
La duración de la animación está expresada en segundos.

Por ejemplo, supongamos que tenemos una toolbar en la parte inferior de la pantalla, y queremos que desaparezca deslizándose hacia abajo cuando presionamos un botón. El código es el siguiente:
[UIView beginAnimations:nil context:nil];
[UIView setAnimationDuration:0.3f];

CGRect frame = toolbar.frame;
frame.origin.y += frame.size.height + 1;
toolbar.frame = frame;

[UIView commitAnimations];
Si además quiero que vaya desapareciendo (haciéndose transparente) a medida que se va deslizando hacia abajo, alcanza con agregar:
toolbar.alpha = 0;
antes de hacer el commit de la animación.

Otro ejemplo. Tengo un UIView (clase base para los componentes que tienen interfaz gráfica) que quiero reemplazar por otro girando la interfaz 180º. ¿Qué tan complicado es?

Este es el código:
[UIView beginAnimations:nil context:nil];
[UIView setAnimationDuration:0.7f];
[UIView setAnimationBeginsFromCurrentState:NO];
[UIView
  setAnimationTransition:UIViewAnimationTransitionFlipFromRight
  forView:viewThatRotates
  cache:YES];

[oldView removeFromSuperview];

UIView * newView;
// agregar código para inicializar newView...

[self.view newView];

[UIView commitAnimations];

viernes, 13 de agosto de 2010

Vista rápida de archivos en Mac OS X

Acabo de encontrar de forma accidental una funcionalidad en Mac OS X (10.5 y superior) que es espectacular.

Apretando "espacio" cuando se tiene seleccionado un archivo, muestra una vista rápida del mismo ("quick look" en inglés).

Hasta ahí no tiene nada de extraño. Lo que lo hace espectacular es que ¡se pueden abrir archivos para los cuales no tengo un programa instalado!

Por ejemplo puede abrir archivos de MS Office que normalmente abro con Google Docs. Pero también abre imágenes, videos, código fuente (con syntax coloring), PDFs, y cualquier otra cosa que haya encontrado en mi disco...

Si se quiere recorrer todos los archivos de una carpeta, se puede hacer con tab o shift-tab una vez que se abrió la vista rápida.

Acá pueden encontrar más información sobre accesos de teclado en Mac OS X.