¿Qué hacer ante estos casos?

Primero, para conocer la codificación de un archivo en Linux, el comando es file:

[CODE]
$file archivo.txt
archivo.txt: UTF-8 Unicode text
[/CODE]

Segundo, para cambiar el tipo de codificación, por ejemplo, de ISO-8559-1 a UTF-8 (si fuese al revés o utilizando otra codificación creo que los argumentos son muy naturales y no necesitan más explicación):

[CODE]
$iconv –from-code=ISO-8559-1 –to-code=UTF-8 archivo.txt -o archivo_convertido.txt
[/CODE]

En esta guía pretendo abarcar todo lo que necesitamos para empezar a escribir aplicaciones para Android: desde la instalación del JDK hasta la exportación del paquete APK e instalación en el dispositivo móvil.

Los siguientes 10 pasos relatan mi experiencia, derivada de: Installing the SDK, Installing the ADT Plugin y Hello, World

1 – Instalar el Development Kit de Java (JDK). Para el caso de Debian, Ubuntu, Mint o cualquier otro “debian based”:

sudo apt-get install openjdk-6-jdk

2- Descargar Eclipse, Eclipse Classic preferentemente.

3- Descargar el SDK Starter Package de Android

4- Descomprimir ambos, Eclipse y Android SDK en alguna carpeta específica, yo lo hice en mi carpeta ~/devel

5- Correr Eclipse: ~/devel/eclipse/eclipse

6- Instalar el plugin de Android para Eclipse: ADT (Android Development Tool) . Para hacer esto, realizar los siguientes pasos en Eclipse, Help > Install New Software….

Hacer Clic en Add (arriba a la derecha) y completar con los siguientes datos:

• Name: ADT Plugin
• Location: https://dl-ssl.google.com/android/eclipse/

Luego, del diálogo Available Software, seleccionar Developer Tools y continuar (Next). En la próxima ventana verás la lista de herramientas que serán descargadas, continuar (Next). Finalmente, leer y aceptar el acuerdo de licencia y terminar (Finish). Cuando la instalación haya terminado, reiniciar Eclipe.

Para más adelante, por actualizaciones, seleccionar Help > Check for Updates.

7- Configurar el ADT Plugin

Seleccionar  Window > Preferences…  y luego, del panel izquierdo: Android.

Lo primero que aparecerá es un diálogo preguntando si estamos de acuerdo con mandar estadísticas de uso a Google. Luego, nos solicitará: path del SDK, hacer clic en Browse y buscar el path donde descomprimimos el SDK (en mi caso, ~/devel/android-sdk-linux), aplicar y listo.

8 – Agregar plataformas y otros paquetes

El último paso antes de crear nuestro proyecto Hello Android es instalar varios paquetes y plataformas para las cuales desarrollaremos. Para esto hay una herramienta disponible en el directorio tools del sdk, en mi caso: ~/devel/android-sdk-linux/tools/android. Se puede ejecutar la misma desde Eclipse: Window > Adroid SDK Manager

Con seleccionar Tools y la API de la plataforma para la que quieres desarrollar bastaría. No obstante, puedes ver los paquetes recomendados.

9 – Nuetro primer proyecto: Hello Android!

Crear un AVD (Android Virtual Device): Window > AVD Manager y New... Se abrirá un díalogo donde completar el nombre del AVD y la plataforma (por ejemplo: Android  2.3.3).

Crear un nuevo proyecto: File > New > Project y si el ADT fue bien instalado, debería aparecer una carpeta Android de donde debemos seleccionar Android Project y completar con los siguientes valores:

• Project name: HelloAndroid
• Build Target: seleccinar una plataforma igual o menor a la del dispositivo virtual (AVD).
• Application name: Hello, Android
• Package name: com.example.helloandroid (o tu propio namespace privado)
• Create Activity: HelloAndroid

Y luego, Finish.

Creado el proyecto, podemos ver las primeras líneas de código en el archivo HelloAndroid.java (HelloAndroid > src > com.example.helloandroid). A las mismas, les agregamos algo de código para que se vea así:

[JAVA]
package com.example.helloandroid;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class HelloAndroid extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView tv = new TextView(this);
tv.setText(“Hello, Android”);
setContentView(tv);
}
}
[/JAVA]

Si quieres dar un pequeño paso más, puedes editar la GUI. Hacer doble clic en el archivo main.xml (HelloAndroid > res > layout) y agregar un botón (button1) con el texto “Salir”. Fíjate que la GUI se desarrolla en un archivo XML, pero gracias al ADT contamos con un editor gráfico “Graphical Layout”.

Dejar el código, más o menos así:

[JAVA]
package com.example.helloandroid;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class HelloAndroid extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);
setContentView(R.layout.main);

Button boton = (Button) findViewById(R.id.button1);
boton.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
finish();
System.exit(0);
}
});
}
}
[/JAVA]

Correr la aplicación: Run > Run y seleccionar “Android Application”. Ten paciencia, el emulador se puede tomar unos minutos en iniciar.

10 – Finalmente, luego de probar el ejemplo en la terminal virtual emulada, nos resta correrlo en el movil real. Para esto, sobre el proyecto creado (desde Package explorer) hacer clic derecho y seleccionar Android Tools \ Export Signed Application Package y seguir el asistente. Los firmaremos, de momento, con una key de debug (solo disponible para debugging), los datos que puede solicitar el asistente se detallan a continuación:

Keystore name: “debug.keystore”
Keystore password: “android”
Key alias: “androiddebugkey”
Key password: “android”
CN: “CN=Android Debug,O=Android,C=US”

Para saber más acerca de como firmar una aplicación ver aquí.

Solo queda copiar el apk generado al teléfono móvil e instalarlo (teniendo previamente habilitado Orígenes desconocidos en los Ajustes de Aplicaciones)

Luego de instalar Ubuntu 12.04, gnome-shell y de personalizar todos los detalles de mi escritorio, me encontré con un detalle estético poco feliz, que no era de mi agrado (que conste que era simplemente una cuestión personal). El detalle: los botones Minimizar, Maximizar y Cerrar de Chromium alineados a la izquierda x-(

Como es la segunda vez que me encuentro con el mismo problema, y buscar la solución me demandó unos 10 minutos que no quiero perder la pròxima, dejo sentada aquí mi ayuda memoria:

Para cambiar la alineación de los botones minimizar, maximizar y cerrar a la derecha, simplemente ejecutar en una terminal:

gconftool-2 –type string –set /apps/metacity/general/button_layout “menu:minimize,maximize,close”

Si te gusta como quedaban a la izquierda (yo paso), puedes regresarlos de la siguiente forma:

gconftool-2 –type string –set /apps/metacity/general/button_layout “close,minimize,maximize:”

En uno u otro caso la actualización es inmediata, no se requiere reiniciar absolutamente nada.

Git fue diseñado por Torvalds con el objetivo de llevar el kernel de Linux en un repositorio confiable o como el propio Linus dijo “rápido, muy rápido, fácil, bonito y espectacular”.

Una de las referencias de Linus en el diseño de git fue CVS, pero como un ejemplo de lo que NO HAY QUE HACER, pues lo sufrió durante siete años en una compañía y allí aprendió a odiarlo con pasión. Linus tampoco quizo probar con SVN, pues el lema de SVN era “hacer CVS bien”, y eso ya lo condenaba, pues no había forma de hacer a CVS bien.

Dejando de lado las anécdotas anteriores, Git es utilizado por la mayoría de los desarrollos open source de la actualidad:

• El propio Git
• Linux Kernel
• Perl
• Eclipse
• Gnome
• KDE
• Qt
• Ruby on Rails
• Android
• PostgreSQL
• Debian
• X.org

Para quienes no saben lo que es un software control de versiones, básicamente, se puede resumir en un servidor donde se suben los archivos de un proyecto y a medida que se van modificando se van registrando y documentando estos cambios (versionando). En principio la idea es sencilla y más de un improvisado podría cuestionar el uso del mismo. No obstante, en la medida que un proyecto crece, la cantidad de archivos aumenta, los cambios y la cantidad de programadores también, resulta totalmente insostenible trabajar sin un control de versiones.

Trabajar sin control de versiones implica no saber donde está el último fuente, arrancar trabajando de una versión anterior y perderse los cambios de la que realmente era la última, no saber cuales son y quien realizó los cambios, no deshacer fácilmente los cambios realizados (downgrade), o no poder facilitar la transición a una versión totalmente nueva de un proyecto manteniendo el soporte a la anterior.

Una cosa más, la mayoría de los IDEs actuales tienen integración con Git, o si no la tienen, tienen algún plugin para hacerlo. Ahora, si no utilizas un IDE, tu caso es un poco más delicado

Sin más preámbulos, vamos a la práctica. En mis prácticas no utilizaré IDE, utilizaré un único archivo fuente y utilizaré el mismo equipo (dotado con Ubuntu Linux) como repositorio y cliente. Por lo tanto, primero, descargaré lo necesario: apt-get install git-core

Primer paso, en rol de “servidor”, creo el repositorio:
[CODE]
$ git init mi_repositorio
[/CODE]

Initialized empty Git repository in /home/luciano/mi_repositorio/.git/

En caso de no pasar el último argumento, en mi caso: mi_repositorio, el repositorio se inicializará en el directorio actual.

Ahora, en rol de “cliente”, supongamos que tengo mis desarrollos en este path:
[CODE]
$ pwd
/home/luciano/desarrollo
[/CODE]
Si quiero “sincronizar” mi directorio de desarrollo con el repositorio de git, debe hacer un “clone”, así:
[CODE]
$ git clone /home/luciano/mi_repositorio
Cloning into luciano…
done.
warning: You appear to have cloned an empty repository.
[/CODE]
Estamos arrancando de cero, por lo tanto el warning es ignorable

El argumento que cambiará del “clone” en el caso que el repositorio se encuentre en otro servidor, será el path del repositorio, que deberá ser antecedido por usuario@host, por ejemplo:
[CODE]
git clone username@host:/path/to/repository
[/CODE]

Un repositorio administrador por git cuenta con lo que se denominan tres árboles, el primero, el directorio local (directorio de trabajo). El segundo es un “directorio intermedio” a donde van a parar los archivos que se agregan al proyecto, finalmente el “HEAD” donde reside la última versión confirmada. Ahora, veremos como agregar un archivo al repositorio y como “commitearlo”.

Primero, creo un archivo fuente en mi directorio de trabajo:

[CODE]
$ pwd
/home/luciano/desarrollo
$ cd mi_repositorio
$ touch holamundo.c
[/CODE]

Observen lo siguiente, no hay nada que decir:
[CODE]
$ git status
# On branch master
#
# Initial commit
#
# Untracked files:
# (use “git add …” to include in what will be committed)
#
# holamundo.c
nothing added to commit but untracked files present (use “git add” to track)
[/CODE]

Ahora, agrego el archivo al repositorio:
[CODE]
$ git add holamundo.c
[/CODE]

Finalmente, commit:
[CODE]
$ git commit -m “revision inicial” holamundo.c
[master (root-commit) 2b983d9] revision inicial
Committer: Luciano
[/CODE]

Ahora, el estado nuevamente:
[CODE]
$ git status
# On branch master
nothing to commit (working directory clean)
[/CODE]

Un último comentario acerca de lo último, el commit quedó registrado con mi usuario (Committer) y mi host luciano@lucid.

Una opción, antes de lo anterior, es setear esos valores de la siguiente forma:
[CODE]
$ git config –global user.name “Juan Del Rio”
$ git config –global user.email juan@delrio.com
[/CODE]

Ahora, modifico el fuente y observo el estado de nuevo:
[CODE]
$ echo “/* holamundo program */” > holamundo.c

$ git status
# On branch master
# Changes not staged for commit:
# (use “git add …” to update what will be committed)
# (use “git checkout — …” to discard changes in working directory)
#
# modified: holamundo.c
#
no changes added to commit (use “git add” and/or “git commit -a”)
[/CODE]

Hay cambios sin “commitear”, por lo tanto, hago un nuevo commit:
[CODE]
$ git commit -m “agregue encabezado” holamundo.c

$ git status
# On branch master
nothing to commit (working directory clean)
[/CODE]

Para terminar (por ahora), si elimino el archivo:
[CODE]
$ rm holamundo.c

$ git status
# On branch master
# Changes not staged for commit:
# (use “git add/rm …” to update what will be committed)
# (use “git checkout — …” to discard changes in working directory)
#
# deleted: holamundo.c
#
no changes added to commit (use “git add” and/or “git commit -a”)
[/CODE]

Por lo tanto debo:
[CODE]
$ git rm holamundo.c
$ git commit -m “bye bye adios” holamundo.c
$ git status
# On branch master
nothing to commit (working directory clean)
[/CODE]

Por hoy esto es todo, a pesar de que es muy poco y aún no es lo suficiente para compreder las virtudes de un sistema de control de versiones, basta para saber como hacer “altas, bajas y modificaciones”.

En la próxima entrega, quedo comprometido en tratar los “push” a un servidor remoto, trabajar con “branches”, hacer “merges” y un poco más.

Por tal motivo, y ante un requerimiento del primer tipo (como “ayuda memoria”) quiero publicar algo que frecuentemente utilizo (o que cuando no es tan frecuente mi fragil memoria olvida):

¿Cómo hacer un loop infinito en un intérprete de comandos (sh, ksh o similar)?

Pongamos unas comillas al “infinito”, todo concluye al fin, nada puede escapar a un Ctrl+C o a un break (produce un abandono inmediato) dentro del bucle.

while :; do
  # Todo lo que quieras repetir infinitas veces
  echo "Hola Mundo"
  sleep 2
done

No olvides el sleep, sino pasarán cosas muy rápido

Otras opciones son utilizar las palabras especiales true (indica que una condición en verdadera) y false (indica que una condición es falsa) de bash:

while true; do
  ...
  ...
done

O:

until false; do
  ...
  ...

done

Recuerdo por entonces MySQL Migration Toolkit, una herramienta para realizar esta carga requerida. No obstante no era de mi agrado, y lo que buscaba por entonces era simplemente obtener un script SQL con el código DDL y DML necesario para el CREATE de los objetos de la base de datos y los INSERTs de los datos. A esa utilidad, hoy Linuxeando, le encontré el nombre: mdbtools.

MDBtools es un suite de herramientas (mdb-array mdb-header mdb-parsecsv mdb-schema mdb-tables mdb-export mdb-hexdump mdb-prop mdb-sql mdb-ver) que permiten, entre sus funciones, obtener  esquema de una base de datos y exportar en SQL los datos de la misma.

Veamos un ejemplo básico y sencillo que consiste en:

• Exportar el diseño de la vieja y querida Neptuno.mdb (conocida base de datos distribuida como ejemplo con Microsoft Access) en formato de sentencias de definición de datos SQL.
• Obtener el nombre de las tablas de la misma base de datos
• Exportar los datos de cada tabla bajo la forma de INSERTs SQL.

[CODE]
$ sudo aptitude install mdbtools

$ mdb-schema Neptuno.mdb mysql > Neptuno_schema.sql #donde mysql se puede reemplazar por otro dialecto: oracle, sybase o postgres.

$ for tabla in `cat Neptuno_tables.txt`; do mdb-export -R \; -I Neptuno.mdb ${tabla}; done > Neptuno_data.sql

$ rm Neptuno_tables.txt
[/CODE]

Fácil, sencillo y util… lástima que en mi caso llega tarde, no obstante en conocimiento perdura y nadie puede asegurarme que no me encuentre alguna vieja MDB en mi camino.

Vía: Wikipeando

La API de C es ditribuida con MySQL, no es más que una librería (libmysqlclient) que interfacea entre el programa y la base de datos.

La documentación provista por MySQL es muy completa (MySQL C API), no obstante, fiel a nuestra costumbre iremos a un ejemplo sencillo y concreto.

¿Qué necesitamos?

• Un servidor de base de datos MySQL, al cual conectarnos
• Un programa cliente
• La librería mysqlclient
• mysql-devel, headers con la firma de la librería
• gcc

Con cualquier variante de UNIX más la instalación manual de la distribución binaria (tar.gz) tendremos todo lo que necesitamos. Caso contrario habrá que instalar los paquetes necesarios que incluya los requisitos mencionados, por ejemplo mysql-devel.

Primero, sin ir al detalle en concreto de cada línea (no cuesta nada interpretar el código, pues está bien comentado) veamos el siguiente fuente:

[C]
/* mi_cliente */
#include
#include

main() {
MYSQL *conn;
MYSQL_RES *res;
MYSQL_ROW row;

char *server = “localhost”;
char *user = “root”;
char *password = “PASSWORD”; /* set me first */
char *database = “mysql”;

conn = mysql_init(NULL);

/* Connect to database */
if (!mysql_real_connect(conn, server,
user, password, database, 0, NULL, 0)) {
fprintf(stderr, “%s\n”, mysql_error(conn));
exit(1);
}

/* send SQL query */
if (mysql_query(conn, “show tables”)) {
fprintf(stderr, “%s\n”, mysql_error(conn));
exit(1);
}

res = mysql_use_result(conn);

/* output table name */
printf(“MySQL Tables in mysql database:\n”);
while ((row = mysql_fetch_row(res)) != NULL)
printf(“%s \n”, row[0]);

/* close connection */
mysql_free_result(res);
mysql_close(conn);
}
[/C]

Ahora si veamos la parte más interesa saber ¿cómo compilar?

Entre los argumentos a pasarle al gcc tenemos los directorios con las librerías, las librerías propiamente dichas, los directorios de encabezados (.h), y otras opciones más del compilador. Esto no representa ningún problema, menos aún con mysql_config  es un pequeño utilitario de MySQL que provee información para el compilador.

De esta forma:

• mysql_config –libs: devuelve los path de las librerías y las librerías propiamente dichas a linkear.
• mysql_config –cflags: devuelve, entre otros argumentos, los path de los headers.

Finalmente, podemos compilar de esta manera tan sencilla:

$ gcc -o mi_cliente $(mysql_config --cflags) mi_cliente.c $(mysql_config --libs)

Y luego ejecutar:

$ ./mi_cliente

Realmente, muy sencillo ¿no?

Vía: nixCraft

“El nuevo escritorio de GNOME eleva la elegancia a un nuevo nivel. Simple, bello, GNOME3 ha <barrido> el desorden existente para llegar a un escritorio sencillo, simple, facil de usar y más hermoso que nunca; con nuevo tema, nueva fuente y animaciones cuidadas.”

No obstante, ansioso, sin poder esperar su lanzamiento hice lo mismo que había echo tiempo atrás, Try it out!. El proceso es sencillo, bajar los fuentes y compilar… cosa que está bien aqui, que se resume en pocos pasos y que de no mediar problemas, apt-get install‘s de por medio se resume en:

• curl -O http://git.gnome.org/browse/gnome-shell/plain/tools/build/gnome-shell-build-setup.sh
• /bin/bash gnome-shell-build-setup.sh
• sudo rm -rf /usr/lib*/*.la
• jhbuild build

Finalmente, para ejecutar el nuevo shell:

• cd ~/gnome-shell/source/gnome-shell/src
• sudo ./gnome-shell –replace

Luego de eso, deberiamos poder empezar a disfrutar de un entorno nuevo, sencillo, cuidado y que representa la principal innovación en GNOME en años.

En este caso, quiero aportar a este blog (mi humilde base de conocimientos) una forma muy sencilla de eliminar archivos de más de N de días de antigüedad en forma automática (ideal para ejecutar por el programador de tareas), algo muy útil para purgar logs o borrar temporales inútiles. En mi caso, fue utilizado para eliminar imágenes periódicas de una cámara IP (JPEG posting) que al final del día unía en un video diario.

Luego de buscar y buscar y estando a punto de escribir un Windows shell script bastante artesanal me encontré con FORFILES, un comando de Windows, que permite de una forma sencilla de seleccionar uno o más archivos y ejecutar un comando sobre los mismos.

Está de más decir que lo primero que deberías hacer es ver como funciona FORFILES:

[CODE]
forfiles /?
[/CODE]

De todas formas, si eres algo perezoso, aquí va la solución al problema que da título a esta presentación:

[CODE]
forfiles -p “C:\donde\esten\tus\archivos” -s -m *.* -d -c “cmd /c del @path”
[/CODE]

Vía: stackoverflow

Como lo más destacado de este post, les dejo una cheatsheet de comandos de UNIX.

Y como plus, algunas cheatsheet varias, de esas que encontrarás miles en Internet. Son una hoja de referencia de vi/vim (a menos que trabajes hace tiempo con vi o vim, esta hoja te será muy útil inclusive para saber como salir del editor ).

Y además, otras dos hojas acerca de las equivalencias en colores RGB/Hexadecimal (para imprimir a colores) y otra de JQuery, estas últimas dos para webmasters por sobre todas las cosas.

Vía: PixelBeat