En el Presente tutorial mostraremos como crear un árbol en Processing, sin mas que agregar comencemos:

float ramas;
void setup()
{
  smooth();
  size(700,500);
  background(255);
  // Vamos a escoger un ángulo de 0 a 90 grados y convertir
  // Nuestra variable ramas a Radianes
  ramas= radians(30);
  // Inicia el árbol desde la parte inferior de la pantalla
  translate(width /4,height);
  strokeWeight(40);
  // Dibuja una línea de 50 píxeles
  line(160,160,160,-50);
  strokeWeight(30);
  // Dibuja una línea de 100 píxeles
  line(160,160,160,-100);
  // Mueve la funcion arbol al final de la linea
  translate(160,-100);
  // Inicia la funcion arbol
  arbol(150,20);
}
 
void arbol(float h,float s)
{
  // Cada Rama creada sera mas delgada que la anterior en cuanto a largo y grueso
  h *=0.7;
  s *=0.6;
 
  // Todas las funciones deben tener una condición de salida!!
  // Aquí, la nuestra es cuando la longitud de la rama es de 1 píxeles o menos
 
  if(h > 1)
  {
 
    pushMatrix(); // Guardar el estado actual de transformación (es decir, donde estamos ahora)
    strokeWeight(s*0.5); // Se adelgaza la linea a la mitad
    rotate(-ramas); // Rotar por ramas
    line(0,0,0,-h); // Dibuja la rama
    translate(0,-h); // Ir al final de la rama
    arbol(h,s); // Ok, ahora se llaman arbol para dibujar dos nuevas ramas!
    popMatrix(); // Cada vez que volvamos aquí, se restaura el estado anterior de la matriz
 
    // Repetir lo mismo, sólo se ramificara hacia la izquierda esta vez y eh cambiado algunos valores para que el lado izquierdo no sea igual al derecho!
    pushMatrix();
    strokeWeight(s*0.6);
    rotate(ramas);
    line(0,0,0,-h-10);
    translate(0,-h-10);
    arbol(h,s);
    popMatrix();
 
  }
}

El resultado seria el siguiente:

Para instalar Gnokii en nuestro servidor usamos el administrador de paquetes apt con la siguiente linea: apt-get install gnokii Si estamos sobre Ubuntu recuerden anteponer la linea sudo

Una vez instalado Gnokii tenemos que configurarlo, el primer paso es  entrar a la carpeta etc  con la siguiente línea de comando: cd /etc
Cuando estemos dentro de etc el siguiente paso será editar el archivo gnokiirc para esto utilizamos el siguiente comando: nano gnokiirc

Una vez que nos encontremos en el editor en la parte [global]  agregaremos las líneas correspondientes al tipo de cable que usa nuestro teléfono  en este caso quedara de la siguiente manera  (recuerda que esta configuración es para un Nokia 5610 que utiliza un cable tipo CA-101 para  ver las configuraciones de otro tipo de cables consulta http://wiki.gnokii.org/index.php/Cables)

[global]
model = AT
port = /dev/ttyACM0
connection = serial

Una vez que hayamos editado y guardado el archivo gnokiirc conectamos nuestro teléfono al equipo y elegimos la opción PC Suite y ejecutamos el siguiente comando: gnokii –identify

Una vez que hayamos editado y guardado el archivo gnokiirc conectamos nuestro teléfono al equipo y elegimos la opción PC Suite y ejecutamos el siguiente comando: gnokii –identify
Nos tendrá que mostrar  todos los datos de nuestro teléfono

Nota: Por razones de seguridad edite la parte del IMEI

Ahora está configurado y listo para enviar mensajes

Para probar la funcionalidad del envió de mensajes la sentencia a ejecutar es la siguiente:

echo “Hola mundo” | gnokii –sendsms numerocelular

Nota: por razones de seguridad he editado la pare correspondiente al numero telefónico

Una vez que se halla enviando el mensaje correctamente aparecerá un mensaje de que todo ha salido bien en caso contrario nos mostrara el mensaje failed

con esto damos por concluido este tutorial , cualquier duda o sugerencia estamos para ayudarles

La instalación de Processing es muy sencilla si se cuanta con los materiales necesarios, solo es cuestión de seguir unos simples pasos:

Paso 1: Descargar Processing

Descargamos el Processing de la pagina oficial y nos aseguramos que sea la versión para Mac OS X http://www.processing.org/download/, y se guarda donde sea mas conveniente.

Paso 2: Ejecutar el Archivo Descargado

Cuando la descarga se complete ejecutamos el archivo .dmg y aparecerá una ventana como la siguiente.

Paso 3: Instalación en Mac OS X

Arrastramos el icono de Processing encima de la carpeta Aplicaciones, cuando esta se habrá soltamos el icono dentro y esperamos que termine de copiarse.

Paso 4: Final de la Instalación

Una vez hecho lo anterior desmontamos el archivo .dmg, con clic derecho expulsar, luego nos dirigimos a nuestra carpeta de aplicaciones y ejecutamos el Processing.

Nota:

Lo que se utilizo para este tutoríal fue el Processing 1.0 y una MacBook Pro con Mac Os X

La instalación de geoserver resulta relativamente fácil, solo hay que seguir unos cuantos sencillos pasos para lograrlo.

Paso 1: Descargar Geoserver

Nos descargamos el geoserver del siguiente enlace: http://sourceforge.net/projects/geoserver/files/ y lo guardamos donde nosotros queramos.

Paso 2: Descomprimir el archivo

Descomprimimos el archivo con el comando unzip en este caso el archivo lo tenemos guardado en la capeta de Descargas.

Descomprimir el archivo

Paso 3: Copiar el Geoserver

Antes de copiar el geoserver, necesitamos logearnos como “root” para poder tener los permisos necesarios para hacerlo. Seguido de esto copiaremos nuestra carpeta extraída de geoserver a la dirección /usr/local/.

Copiar la carpeta de Geoserver

Paso 4: Agregar variables

Antes de ejecutar nuestro geoserver, es necesario establecer dos variables (JAVA_HOME y GEOSERVER_HOME), normalmente hay que definirlas siempre que queramos ejecutar el programa, para evitarnos esta molestia, la vamos a definir para que cuando cargue nuestro sistema se inicialicen.

En modo “root” abrimos el archivo .bashrc ubicado en nuestra carpeta personal, y agregamos las siguientes lineas.

export JAVA_HOME=/usr/lib/jvm/java-6-sun-1.6.0.20/jre
export GEOSERVER_HOME=/usr/local/geoserver-2.0.1

Donde JAVA_HOME es la ruta donde tenemos instalado java (recordemos que geoserver trabaja con java) y GEOSERVER_HOME es la ruta donde tenemos instalado el geoserver.

Abriendo el archivo .bashrc

Añadiendo variables al .bashrc

Paso 5: Ejecutar el programa

Una vez agregadas las variables, procedemos a ejecutar el geoserver, nos dirigimos a la carpeta donde lo instalamos, acedemos a la carpeta /bin y ejecutamos el archivo startup.sh (recuerden que todo en modo “root”).

Iniciando Geoserver

Iniciando Geoserver

Una vez iniciado Geoserver, abrimos nuestro navegador y accedemos a la dirección http://localhost:8080/geoserver/web/

Página principal de Geoserver

Listo!! tenemos instalado Geoserver en Ubuntu!

Nota: para este tutoríal se utilizó Geoserver2.0.1 y Ubuntu9.10.

Dudas, comentarios o sugerencias estamos para servirte, espero les sea de gran ayuda!!

Saludos!

Android es una plataforma de software para dispositivos móviles que incluye un sistema operativo, middleware y aplicaciones. Para desarrollar aplicaciones en esta plataforma, es necesario contar con el kit de desarrollo de software (SDK) para Android, el cual contiene las herramientas y las APIs necesarias para desarrollar aplicaciones usando el lenguaje de programación Java.

Aquí dejo los pasos para los impacientes:

1.- Instalación del JDK:

sudo apt-get install sun-java6-jdk

2.- Instalación de Eclipse:
Http://www.eclipse.org/downloads/

3.- Instalación del SDK de Android:
Http://developer.android.com/sdk/index.html
Exportar las herramientas del SDK en el PATH:

PATH=$PATH:~/android-sdk-linux_86/tools
export PATH

source ~/.bashrc

4.- Instalar el plugin ADT para Eclipse
Eclipse: Help->Software Updates o Help-> Install New Software
Nuevo plugin con dirección : https://www.dl-ssl.google.com/android/eclipse
En la sección de Available Software debemos seleccionar el paquete Developer Tools.

5.- Configuar nuestro plugin para que trabaje con el SDK.
Abrimos Windows->Preferences vamos a la parte de Android.
En SDK Location, damos clic en Browse y localizamos el directorio donde previamente se descomprimió el SDK.

6.- Agregando la plataforma Android y otros componentes:
Eclipse: Window-> Android SDK and AVD Manager
Clic en Available Packages y seleccionamos los paquetes que desamos instalar.

7.- Creación de un Dispositivo Virtual Android AVD
Eclipse: Window-> SDK and AVD Manager.
En Virtual Devices, clic en (New . . .) crear un nuevo AVD .
Escribimos un nombre y seleccionamos el platform Target adecuado.

A continuación se describen cada uno de los pasos a detalle, además se presenta el típico ejemplo Hola Mundo en Android.

1.- Instalación de JDK.
En primer lugar debemos saber que Android no soporta las versiones JDK 1.4 o anteriores, ni tampoco soporta la distribución del compilador GNU para Java (gcj) que tienen instalado algunas distribuciones Linux por defecto. Por tanto se recomienda instalar una versión JDK 1.5 o superior, en este caso vamos a instalar el JDK 1.6:

sudo apt-get install sun-java6-bin

Para el entorno de desarrollo completo instalamos:

sudo apt-get install sun-java6-jdk

En caso de tener una arquitectura de 64 bits debemos instalar el paquete ia32-libs.

2.- Instalación de Eclipse.

Se recomienda tener un entorno de desarrollo (IDE) para trabajar con Android. El más recomendado es Eclipse:

Http://www.eclipse.org/downloads/

Las versiones recomendadas para Android son:

• Eclipse Classic 3.5.1
• Eclipse 3.5 Galileo
• Eclipse for Java EE
• Eclipse RCP/Plug-in Developers
• Eclipse IDE for Java Developers

3.- Instalando el SDK de Android.
El SDK no es un entorno de desarrollo completo, solo incluye las herremientas necesarias para descargar el resto de los componentes SDK. Se puede obtener de la siguiente dirección:

Http://developer.android.com/sdk/index.html

Una vez descargado, se debe descomprimir en algún sitio del sistema, por defecto el nombre de la carpeta descomprimida es android-sdk-[plataforma del sistema].

Opcionalmente podemos agregar las herramientas del SDK a nuestra variable del entorno del sistema (PATH), para no tener que escribir la ruta completa al ejecutar dichas herramientas en la línea de comandos. Para ello, primero debemos modificar el archivo ~/.bashrc (donde el prefijo “~” significa la ruta de usuario dentro de /home) con cualquier editor de textos.

Agregamos al final del archivo las siguientes dos líneas:

PATH=$PATH:~/android-sdk-linux_86/tools
export PATH

Donde ahora el prefijo “~” significa la ruta donde se descomprimió la carpeta del SDK.
Salvalo y después ejecuta:

source ~/.bashrc

4.- Instalando ADT Plugin para Eclipse
Android ofrece un plugin para Eclipse llamado ADT, el cual está diseñado para brindar soporte en el desarrollo de aplicaciones con Android. Es ampliamente recomendado y es la manera más sencilla de iniciar con Android.

Para descargarlo e instalarlo vamos a hacer uso de Eclipse:
1.- Arrancar Eclipse y seleccionar:
Help->Software Updates o Help-> Install New Software
2.- En la sección de Software Available:
Add Site . . . o Add . .
3.- Debemos agregar un sitio de descarga y un nombre para nuestro plugin, el nombre puede ser cualquiera, por ejemplo “Android Plugin”, pero el sitio debe ser:
https://www.dl-ssl.google.com/android/eclipse

Si te causa problemas la descarga puedes probar con http://.

4.- Regresando a la sección de Available Software debemos seleccionar el paquete Developer Tools, el cual contiene Android DDMS y android Development Tools.

Damos clic en Next, aceptamos la licencia, esperamos su instalación y damos clic en Finish.

5.- Reinciamos Eclipse.

5.- Configurar el plugin para que trabaje con el SDK.
Ahora debemos configuar nuestro plugin para que trabaje con el SDK de nuestro equipo. Para ello vamos al Eclipse:

1.- Abrimos Windows->Preferences
2.- Seleccionamos Android de la parte izquierda del Panel.
3.- En el panel Principal aparece SDK Location, damos clic en Browse y localizamos el directorio donde previamente se descomprimió el SDK que descargamos.
4.- Damos clic en Apply y en OK.

6.- Agregando la plataforma Android y otros componentes:
Debemos tener al menos una plataforma en nuestro entorno de desarrollo de Android, para poder compilar nuestra aplicación y poder emularla con un AVD (Android Virtual Device). Primero vamos a Eclipse:

1.- Damos clic en Window-> Android SDK and AVD Manager
2.- Damos clic en Available Packages y seleccionamos los paquetes que desamos instalar.

EL SDK Tools debe estar instalado y al menos una Plataforma SDK. La documentación y los ejemplos son muy recomendables pero no son necesarios. Existen plataformas y APIs adicionales que nos brindan una manera más completa de desarrollar y correr nuestra aplicación.

Una vez terminada nuestra instalación podemos verificar los componentes instalados en nuestra directorio SDK.

Add-ons/ : contiene los complementos y las APIs que se hayan instalado en el entorno de desarrollo.

• Docs/: contiene la guía de desarrolladores y la documentación completa, en caso de no contar con una conexión a internet podemos abrir el archivo offline.html.
• Platforms/: Contiene las versiones de las plataformas en las cuales es posible desarrollar aplicaciones.
• Samples/: Contiene códigos de ejemplo.
• Tools/: Contiene las herramientas necesarias para desarrollar aplicaciones tal como el emulador, la herramienta android, adb, etc.

Una vez completada la instalación y comprobado que los archivos de instalación se encuentren en los directorios adecuados, estamos listos para comenzar a desarrollar aplicaciones.

7.- Creación de un Dispositivo Virtual Android AVD
Ahora debemos crear un Dispositivo Virtual de Android (AVD):

• Selecionamos window-> SDK and AVD Manager.
• En el panel de Virtual Devices podemos ver la lista de AVDs disponibles, damos clic en (New . . .) crear un nuevo AVD .
• Escribimos un nombre para nuestro AVD y seleccionamos el platform Target adecuado para nuestro proyecto. La imagen para la tarjeta SD es opcional.
• Damos clic en Create AVD.

Salvamos nuestro proyecto y ahora está listo para ser ejecutado. Debemos asegurarnos que el AVD creado tiene un target que satisface el Build Target de la aplicación, de lo contrario la aplicación será abortada antes de ser lanzada.

Para verificar que nuestro AVD ha sido creado correctamente:
1.- Damos clic en Window-> Android SDK and AVD Manager
2.- Damos clic en Virtual Devices.

Nuestro dispositivo Virtual debe aparecer como un AVD válido y disponible.

Hola Mundo con Android

En caso de tener instalado el plugin ADT, podemos crear fácil y rápidamente un nuevo proyecto:

1.- File->New->Project
2.- Seleccionamos Android-> Android Porject
3.- Nos aparece una ventana para seleccionar las características del nuevo proyecto:

• Project Name: Nombre de la carpeta del proyecto.
• Contents: Permite crear un nuevo proyecto en nuestro espacio de trabajo o en otra ubicación, también se puede crear uno a partir de un ejemplo.
• Build Target: Selecciona la plataforma para la cual será construido el proyecto, en caso de no conocer cual plataforma se debe seleccionar, se recomienda utilizar la mínima versión posible. Es importante recordar cual plataforma seleccionamos, ya que será la misma que usaremos para crear nuestro AVD más adelante.

• Properties:
  - Application Name: es el nombre de la aplicación es el título que aparecerá en la aplicación.
  - Package Name: es el nombre del paquete en el cual se guardarán nuestras aplicaciónes del proyecto, utiliza las mismas reglas del lenguaje de programación Java.
  - Create activity: es el nombre de la actividad principal de la clase.
  - Min SDK version: Indica el mínimo nivel API requerido para nuestra aplicación, en caso de no saber cual escribir se debera poner el mismo que en la plataforma SDK seleccionada en el Build Target.
  Dar clic en Finish.

El código de nuestro proyecto debe parecer algo así:

package com.example.helloandroid;
import android.app.Activity;
import android.os.Bundle;
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);
    }
}

Para ejecutar nuestra aplicación debemos dar clic en el botón Run que se encuentra en la barra de herramientas de Eclipse, debe aparecer una cuadro de diálogo que permita seleccionar que tipo de aplicación queremos ejecutar y seleccionamos Android application.

En caso de no aparecer dicha ventana debemos crear una configuración de ejecución:

1.- Seleccionamos Run-> run Configurations o run-> open run dialog.
2.- Abrimos el menú Android application que aparece del lado izquierdo de la ventana, en caso de tener una configuración podemos seleccionarla, en caso contrario aparecerá una ventana de nueva configuración.
3.- Aparece una nueva configuaración en blanco con las siguientes tres pestañas:

• Android: Debemos seleccionar el proyecto que deseamos ejecutar y la acción por defecto que deseamos ejecutar en el proyecto, se recomiendo selecionar Launch default activity.
• Target: Selecionamos la plataforma que seleccionamos anteriormente en nuestro proyecto, se recomienda seleccionar Automatic y activar el AVD previamente creado.
• Common: En este apartado podemos dejar las opciones marcadas por defecto, pero adicionalmente podemos especificar que nuestra nueva configuración se muestre en los menús de Run o Debug.

4.- Por último damos un nombre a nuestra nueva configuración y damos clic en Run.

El emulador de dispositivos debe crear todo lo necesario para que nuestra aplicación se ejecute en nuestro dispositivo virtual, lo cual lleva un poco de tiempo. La primer pantalla que debe aparecer es:

El lado izquierdo representa la pantalla del dispositivo virtual, el lado derecho representa una interfaz genérica de comunicación con el dispositivo, en este caso solo nos interesa la salida de pantalla, que después de unos segundos de carga, deberá verse así:

Una vez finalizada la carga del dispositivo virtual ya podemos interactuar con la plataforma Android.

Ahora vamos al código de nuevo y lo modificamos para que se vea algo así:

package examples.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("Hola Mundo ! ! ! ");
        setContentView(tv);
 
    }
}

Una interface de usuario en Android está compuesta por objetos llamados Views. Cada view puede ser un botón, una eqtiqueta, una imagen, etc. Todos ellos son una subclase de View, la clase TextView también es una subclase de View.

Con la función setText() definimos el texto del contenido. Por último la función setContentView() muestra el contenido de la actividad en la interfaz de usuario, si no se invoca esta función aparece una pantalla negra.

Nuevamente ejecutamos nuestra aplicación. Ahora el texto se deberá mostrar en panatalla una vez que el emulador ha dejado de cargar el dispositivo virtual.

Algunas veces es necesario oprimir un botón para desbloquear la pantalla, en este caso es el botón menú, es necesario desbloquearla para poder observar nuestra aplicación.

Si nos encontramos en el ambiente Android, podemos encontrar nuestra aplicación directamente en el menú de la plataforma, basta con dar clic en el icono para ejecturala.

De esta forma tenemos nuestra aplicación Hola Mundo en Android.

Hoy la histórica página de Sun Microsystems (uno de los sitios más antiguos de la www) ha dejado de aparecer y en su lugar existe una redirección hacia la página web de Oracle (http://www.oracle.com), esperemos que los proyectos libres que Sun apoyaba no se encuentren descobijados bajo la nueva administración.

Es curioso, muchas personas nunca pensarón que pasaría algo, así e incluso si vemos en la línea del tiempo, uno podría haber apostado que hubiera ocurrido lo contrario, son tiempos de cambio y espero de crecimiento, para la plataforma Java.

Vía Twitter, me llegó un enlace muy interesante sobre respaldos automatizados de bases de datos mysql utilizando Groovy (que es un lenguaje dinámico que se ejecuta en la máquina virtual de Java).

Está muy bien explicado, la dirección es:
Respaldos de MySql con Groovy, Amazon S3 y Grape

Aquí compartimos un código para generar el RFC utilizando Java
RFC

Draw an asterisk tree with Java
Uno de los ejemplos clásicos de uso de ciclos en los lenguajes de programación es utilizarlos para dibujar figuras con asteriscos.
En este caso tenemos la figura de este árbol.

         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
*******************
        **
        **
        **

El código es el siguiente:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
/**
 *
 * @author daniel
 */
public class DibujarArbol {
 
	public static void dibujar() {
		int nivel = 10;
		int a;
		int espacios;
		for (int i = 1; i <= nivel; i++) {
			StringBuffer f = new StringBuffer();
			espacios = nivel - i;
			a = i + (i - 1);
			for (int i1 = 0; i1 < espacios; i1++)
				f.append(" ");
			for (int i2 = 0; i2 < a; i2++)
				f.append("*");
			System.out.println(f.toString());
		}
		for (int j=0; j<3 && nivel-2<(nivel/2)+1; j++){
				System.out.print("*");
			}
			System.out.println("");
		}
 
 
	public static void main(String args[]) {
		DibujarArbol.dibujar();
	}
}