4 bits blog

Se dice, y seguro que es verdad, que la forma de trabajar con SVN debe ser a base de branches y, una vez probados los diferentes cambios, pasarlo al trunk. Desde Eclipse, con el Subclipse, crear un nuevo branch es muy fácil, pero… ¿cómo se hace posteriormente el merge?

El día que tuve que hacerlo por primera vez seguí las instrucciones de aquí, la parte donde dice Merging Two Different Trees y que, traduciendo, resumiendo y ampliando, dice lo siguiente:

1. Ponte en la copia local del Eclipse que apunta al trunk (muy importante)
2. Pulsa botón derecho del ratón, selecciona Team → Merge
3. En el campo “From” se indica la URL completa del trunk
4. Selecciona la revisión en la que iniciaste el branch
5. Desmarca el check del Use “From:” URL
6. En el campo “To” se indica la URL completa del branch
7. Selecciona la revisión del branch que quieres juntar (habitualmente será el HEAD)
8. Pulsa “OK”
9. Finalmente, comprueba que todo es correcto, corrige posibles problemas en el buildpath y realiza un commit

Este método es exactamente lo que se debe hacer también para volver a una versión anterior (ahora que está de moda, imaginemos el fallo de Debian), salvo el paso 5 ya que estamos con la misma URL. A pesar de que algunos lo odien, SVN es a buen seguro la herramienta de control de versiones más extendida y espero que lo anterior os sirva para vuestro día a día.

Hace poco programando en C, eché en falta una función split al estilo de Java, para dividir una cadena de caracteres en varias usando un carácter separador (ya sé que en el método de Java se pueden usar expresiones regulares, pero yo sólo buscaba la división a partir de un carácter).

Como no existe nada parecido, bueno strtok es algo parecido pero tiene muchos inconvenientes (para muchos es una función maldita), pues me decidí a programar una función que lo hiciera, viendo que parece que funciona bastante bien voy a dejar aquí el código por si a alguien le resultase útil o incluso quisiera mejorarla (es toda vuestra).

#include <stdlib.h>

/* split: Splits a string in parts delimited by a character. */
char **split (char *string, char sep) {

	char **ret;
	char *p = string;
	int i = 0;
	int nParts = 0;
	int len = strlen (string);

	ret = (char **) malloc (sizeof (char *));
	if (ret == NULL)
		return NULL;

	ret[0] = NULL;

	while (i < len) {

		/* Jump the separator characters */
		while ((p[i] == sep) && (i < len))
			i++;

		/* Find a non separator character */
		if (i < len) {
			char **tmp = (char **) realloc (ret,
										(nParts + 2) * sizeof (char *));
			if (tmp == NULL) {
				free (ret);
				return NULL;
			}
			ret = tmp;
			tmp = NULL;

			ret[nParts + 1] = NULL;
			ret[nParts] = (char *) malloc (sizeof (char));
			if (ret[nParts] == NULL) {
				for (i = 0; i < nParts; i++)
					free (ret[i]);
				free (ret);
				return NULL;
			}

			int j = 0;
			for (i; ((p[i] != sep) && (i < len)); i++) {
				ret[nParts][j] = p[i];
				j++;

				char *tmp2 = (char *) realloc (ret[nParts],
											(j + 1) * sizeof (char));
				if (ret[nParts] == NULL) {
					for (i = 0; i < nParts; i++)
						free (ret[i]);
					free (ret);
					return NULL;
				}
				ret[nParts] = tmp2;
				tmp2 = NULL;
			}
			ret[nParts][j] = '\0';
			nParts++;
		}
	}

	return ret;
}

Como podéis ver la función devuelve un array de cadenas de caracteres cuya última posición es NULL, de modo que sólo tengáis que recorrer el array hasta encontrar NULL para conseguir las partes de la cadena dividida. Como es obvio, deberéis liberar la memoria del array devuelto una vez no lo vayáis a usar.

Si veis algún fallo decirlo y se corrige.

Supongo, y espero, que todos los que programáis seáis buenos y sigáis un estilo a la hora de escribir código, me refiero a tabular, comentar, agrupar operaciones lógicas entre paréntesis, … Y si no lo hacéis espero que pronto lo hagáis, ya que es algo necesario en cualquier código, que mejora la legibilidad de éste y hace que la posterior modificación por alguien externo (o por ti mismo) sea más sencilla.

Os cuento esto porque estos he seguido una discusión que ha surgido hace poco en la lista de correo del GUL de mi universidad, en esta discusión se preguntaba si era mejor usar espacios o el carácter tabulador.

Si le echáis un ojo a la discusión podréis ver todo tipo de opiniones, aunque al final parece quedar claro que lo más extendido es el uso de espacios, ya que puedes poner el número que tú quieras (normalmente 4 para los primeros niveles y 2 para los niveles más avanzados) de modo que el código se mantenga legible y no abarque muchas columnas. Para ello muchos editores tienen auto identación o incluso en el comienzo del archivo puedes poner el tipo de identación que has usado.

Yo siempre he usado tabulador, porque me parecía mejor, además de ocupar sólo un byte, pero ahora mismo me estoy replanteando mi estilo y a lo mejor me paso a los espacios, y a algún método de auto identación.

Como extra, os dejo este artículo: Tabs versus Spaces muy recomendable.

¿Qué programador futbolero no ha soñado nunca con hacerse su propio PCFútbol? Pues a alguien se le ocurrió en su día que podía ser una buena idea programar equipos de fútbol y que jugaran entre sí una suerte de copa en busca de la gloria, la fama y la satisfacción de hacer morder el polvo a esos engreídos de los contrarios… pues eso es la JavaCup 2008, que desde la asociación JavaHispano piden ayuda para publicitarla.

La revista Sólo Programadores, la organización sin ánimo de lucro javaHispano y Sun Microsystems hemos organizado un concurso que consiste en un torneo virtual de fútbol donde cada equipo será una clase Java que implementa una interfaz predefinida.

La verdad es que suena muy interesante, ¿no creéis?, y hasta hay premio monetario (ah, el vil metal). ¿A qué esperáis para programar a vuestros gladiadores futboleros?