Mostrando entradas con la etiqueta programación. Mostrar todas las entradas
Mostrando entradas con la etiqueta programación. Mostrar todas las entradas

Mavenizar un proyecto Web existente usando project-mavenizer

martes, 29 de julio de 2014

Aunque personalmente no me gusta el anglicismo Mavenizar, es el tema que abordaré para esta guía.

Explicaré cómo mavenizar un proyecto Web que no cumple con la estructura de directorios estándar de Maven. Estos proyectos no estándares pueden ser aquellos que han sido construidos hace ya un tiempo atrás, legados, o aquellos generados usando las herramientas de un IDE como Eclipse y por lo cual no se ajustan a los requerimientos convencionales de Maven. En ocasiones he 
mavenizado algún proyecto ya existente que he tenido que modificar para aprovechar los beneficios de algunos plugins de Maven y así evitar reinventar la rueda en su código.
Además, esta guía tiene el objetivo de explicar el funcionamiento de una herramienta de código abierto para llevar a cabo la tarea de mavenización. La herramienta es project-mavenizer. Con esta herramienta podremos generar un archivo de configuración POM que pueda utilizar la estructura no estándar del proyecto existente, en vez de modificar la estructura del proyecto para que se ajuste a las convenciones de Maven.

La guía de project-mavenizer la podemos encontrar también en inglés, nivel Tarzán, en GitHub.

Descargar y descomprimir la herramienta

  1. Descarga la herramienta desde GitHub. Este es un archivo ZIP llamado project-mavenizer-pack.zip que contiene:
    • La herramienta de mavenización project-mavenizer-0.0.1.jar.
    • Un proyecto Web de ejemplo llamado NonStandardWebProject que no cumple con el estándar de directorios de Maven.
    • El archivo sample.properties que deberás editar, y opcionalmente renombrar, para poder usar con tu proyecto.
  2. Descomprime el archivo project-mavenizer-pack.zip en una ubicación bien identificada; por ejemplo en C:\mavenizator\project-mavenizer-pack\.

Agregar tus configuraciones

  1. Deberás editar el archivo C:\mavenizator\project-mavenizer-pack\sample.properties y seguir las instrucciones que vienen en el mismo. En resumen es asignar los siguientes valores:
    • Asignar un nombre al proyecto, digamos miproyectomaven. Este será también el nombre del archivo WAR generado.
    • Asignar la ubicación de la carpeta de tu proyecto. Para el caso de nuestro ejemplo de prueba es C:\mavenizator\project-mavenizer-pack\NonStandardWebProject.
    • Asignar la ruta a la carpeta con el contenido Web del proyecto. Para nuestro ejemplo, C:\mavenizator\project-mavenizer-pack\NonStandardWebProject\WebContent.
    • Asignar la ruta a las carpetas con código fuente y recursos para el classpath del proyecto. En el archivo sample.properties vienen unos ejemplo.
    • Asignar la ruta a la carpeta que contiene todas las librerías usadas en tu proyecto. Ve el ejemplo en el archivo.

Mavenizar el proyecto Web

  1. Abre una ventana de comandos y navega hacia la carpeta que descomprimiste. En los siguientes ejemplos estaré usando MS-DOS.
  2. Desde tu ubicación en línea de comandos, ejecuta lo siguiente: c:\mavenizator\project-mavenizer-pack> java -jar project-mavenizer-0.0.1.jar.
Deberás ver algo similar a esto:
C:\mavenizator\project-mavenizer-pack> java -jar project-mavenizer-0.0.1.jar 
Set the properties file name:sample.properties 
Loading /C:/mavenizator/project-mavenizer-pack/sample.properties 
Generated file is: C:/mavenizator/project-mavenizer-pack/NonStandardWebProject\pom.xml 
C:\mavenizator\project-mavenizer-pack>


Probarlo

  1. Ahora puedes usar tu proyecto como un proyecto Web Maven. El pom.xml generado en el proyecto tiene las configuraciones necesarias para correr la aplicación usando un Tomcat embebido. Para correrlo, desde la ventana de comandos navega a la carpeta del proyecto Web y ejecuta c:\mavenizator\project-mavenizer-pack\NonStandardWebProject > mvn clean tomcat7:run.
  1. Si puedes ver algo similar a Starting ProtocolHandler ["http-bio-9966"] y sin errores previos entonces abre el enlace http://localhost:9966/miproyectomaven/ desde un navegador de Internet.

Después de ejecutar el comando se deberá haber generado un nuevo archivo pom.xml en la carpeta raíz del proyecto. Sería c:\mavenizator\project-mavenizer-pack\NonStandardWebProject\pom.xml.


Prueba la herramienta, espero que te sirva y, si quieres, puedes mejorarlo pues es de código abierto. El código está disponible en https://github.com/jesfre/project-mavenizer.



Cómo convertirse en un desarrollador de aplicaciones Web modernas

miércoles, 4 de junio de 2014

En este artículo busco resumir mi experiencia en cuanto a los pasos o la trayectoria que normalmente se seguiría para llegar a dominar el desarrollo de aplicaciones Web.
Aunque yo aprendí de forma distinta, ya que me tuve que meter de lleno al desarrollo e ir aprendiendo al paso, lo más normal y muy efectivo es siempre iniciar de cero. Pero, para aquellas personas que ya tienen bases o experiencia, puede que haya sido distinto. Lo siguiente, sin embargo, lo comprendí después de haber estado enseñando a mi futura esposa cómo desarrollar aplicaciones Web y viendo la forma en que ella aprendía.

Primero: Identifica qué es lo que sabes y comienza por lo básico, lo que aun no conoces.
Haz un análisis de los conocimientos que tienes actualmente. Normalmente, si estas estudiando una carrera, estarás aprendiendo algún lenguaje de programación, y cualquiera que este sea te será muy útil. Entre las cosas básicas que deberás aprender están:

HTML: Luego de aprenderlo, también deberás comprender lo que es XHTML.
El protocolo HTTP: Deberás entender qué son las peticiones, tipos y cómo se procesan.
CSS: Qué es, cómo se agrega al HTML y cómo se usa.
Javascript: Ees una de las herramientas más importantes para tí como desarrollador de aplicaciones Web modernas; debes aprender qué es, cómo se agrega al HTML y cómo funciona. Aquí deberás hacer uso de tus conocimientos de programación; si no tienes ningún conocimiento de programación, no te preocupes ya que encontrarás muchos tutoriales que también te ensañan las nociones de la programación a través de Javascript.

De todas estas puedes encontrar infinidad de manuales y tutoriales en todo Internet.

Segundo: Determinar hasta dónde quieres llegar.
Ten en cuenta que para desarrollar aplicaciones Web deberás aprender distintas tecnologías, algunas ya las he mencionado, y dependiendo de la complejidad con la que has de desarrollar las aplicaciones y el tipo de aplicaciones Web.
De acuerdo a la complejidad necesitarás aprender lo siguiente:

XML (ya habrás entendido un poco al leer acerca de XHTML)
Un lenguaje para el servidor (aquí comienza el dinamismo de las aplicaciones Web) como Java, PHP, lenguajes de .Net, etc. Esto ya dependerá de varios factores como el proyecto y tus gustos. Ten en cuenta que al decidirte por una tecnología para el servidor, habrás de aprender además otras tecnologías necesarias para el desarrollo de tus aplicaciones.

Tercero: Paciencia y entusiasmo.
Puedo decir que este es el flujo de aprendizaje común para comenzar a desarrollar aplicaciones Web. Puedes comenzar haciendo pequeñas páginas usando HTML y CSS, luego agregarle alguna intereactividad con Javascript, y posteriormente agregarle complejidad.
Pero como siempre, para llegar al lugar que quieres, deberás tener paciencia y estar dispuesto a leer y hacer "pininos" conforme aprendas nuevas cosas. Ten en cuenta que no te servirá mucho si devoras un libro Javascript sin hacer ejemplos, ya que esto se trata de leer, entender y poner en práctica. Tal vez este último punto lo puedo resumir en, pasión.

Espero te sirva.

Problema al crear nuevo módulo de un proyecto Maven

miércoles, 12 de septiembre de 2012

Al estar creando un nuevo módulo para un proyecto Maven usando Spring Source Tool Suite 2.9.2.RELEASE surgió el siguiente error:

Could not calculate build plan: Failed to parse plugin descriptor for org.apache.maven.plugins:maven-resources-plugin:2.4.3 (C:\Users\jruiza\.m2\repository\org\apache\maven\plugins\maven-resources-plugin\2.4.3\maven-resources-plugin-2.4.3.jar): error in opening zip file
Failed to parse plugin descriptor for org.apache.maven.plugins:maven-resources-plugin:2.4.3 (C:\Users\jruiza\.m2\repository\org\apache\maven\plugins\maven-resources-plugin\2.4.3\maven-resources-plugin-2.4.3.jar): error in opening zip file
El problema surge porque STS viene configurado por defecto para usar la librería de Maven embebida, sí, la que viene con el IDE, y esta tiene sus propias configuraciones como la ruta del repositorio de librerías. Al ser así, Maven intenta encontrar el repositorio en la ruta por defecto establecida, que es C:\Usuario\.m2\repository\ pero mi repositrio existe en otra ruta, por lo tanto ocurre este error.
Para solucionarlo simplemente modifiqué las configuraciones de la instalación de Maven y el repositorio.

Desde el menú superior: Window>Preferences>Maven>Installations
Aquí agregué una nueva instalación de Maven, la cual estoy usando en lugar del que viene embebido con STS.
Desde el menú superior: Window>Preferences>Maven>User Settings
Aquí seleccioné el archivo de configuración de Maven que requiero usar. De esta forma toma la ubicación del repositorio de Maven que tengo configurado en el archivo.


Una vez hechas estas configuraciones volví a intentar crear el nuevo modulo de Maven y funcionó correctamente.


Primeros pasos con Java Web Start (2): La consola de Java

miércoles, 14 de julio de 2010

En un post anterior hacía una introducción a Java Web Start. Ahora quiero comentar acerca de una característica que proporciona Java, y esta es su consola. La consola de Java viene con la instalación del JRE. De acuerdo al sitio ayuda de Java,

La consola de Java ofrece información acerca de la versión del entorno de ejecución de Java (JRE), el directorio de inicio del usuario y los mensajes de error que aparezcan durante la ejecución de un applet o una aplicación.
Pues bien, lo que nos interesa en este momento de la consola es la posibilidad de mostrar los mensajes de error que se lanzan durante la ejecución de una aplicación; para este caso nos será de mucha ayuda al momento de probar y depurar nuestras aplicaciones Java Web Start ya que podremos ver con más detalle los errores que sucedan durante la ejecución de nuestras aplicaciones.
Por defecto la consola de Java no se muestra, por lo tanto habrá que habilitarla siguiendo los pasos que se describen en la misma página y que a continuación presento.
Habilitación de la Consola de Java para la plataforma Windows, para las versiones de Java 6.0, 1.5.0
  1. Haga clic en Inicio.
  2. Seleccione Configuración.
  3. Seleccione Panel de control.
  4. Haga doble clic en el icono de Java.
  5. Haga clic en la ficha Avanzado.
  6. Haga clic en el signo + situado junto a Consola de Java. (Img. 1)
  7. Seleccione Ver consola y haga clic en Aplicar.
Img. 1. La Ventana de configuración

Una vez hecho esto, si ejecutamos nuestra aplicación Java Web Start o cualquier otra podremos ver una ventana como la mostrada abajo en la que veremos los errores que lance la aplicación.


Para otras versiones de Java o la visualización de la consola en navegadores como Firefox y otros pueden ver la página de ayuda de Java donde se explica.

Comenzando con Java (3) - La variable JAVA_HOME (Windows)

domingo, 21 de marzo de 2010

Normalmente cuando estamos comenzando a usar Java nos encontramos con que tenemos que agregar el JAVA_HOME (el directorio de instalación de Java) a las variables de entorno de Windows. Pues bien, para esa "primera vez" me he dado a la tarea de escribir este pequeño tutorial. Para este tutorial debemos tener presentes los siguientes conceptos:

Variables de entorno
Autoexec.bat
PATH: Que es donde el intérprete de comandos buscará los comandos de ejecución que escribamos en la consola, siempre y cuando no usemos una ruta específica para llamar al comando.

La idea del JAVA_HOME es que agreguemos una nueva variable de entorno a nuestro sistema. En este caso JAVA_HOME es el nombre de facto, aunque podría ser cualquier otro, lo importante es que además lo agreguemos al PATH para que Windows pueda reconocer los comandos de Java. Incluso podríamos no definir la variable JAVA_HOME y hacerlo todo directamente sobre la variable PATH, pero por convención y practicidad es mejor definirla, esto te será más claro conforme sigas usando Java.
Para agregar la nueva variable de entorno hay dos caminos a seguir.

El primero es usando la ventana de Propiedades del sistema de Windows.
(La forma en que siempre lo hago)

1. Hacer la combinación de teclas Inicio(la tecla de la ventanita) + Pausa para abrir la ventana de Propiedades del sistema.



2. Dentro de la ficha Opciones avanzadas, oprimir el botón Variables de entorno, lo que abrirá una nueva ventana titulada Variables de entorno.


Nota: Dentro de las variables de entorno tenemos las Variables de usuario y las Variables del sistema, las primeras funcionan mientras la sesión del usuario para la cuál está definida está abierta, las otras funcionan para todos los usuarios y se necesitan permisos de administrador para definirlas. Preferentemente yo siempre uso las Variables de sistema, a menos que haya una situación particular que requiera que use las variables de usuario.

3. En la sección de las Variables del sistema haremos clic sobre el botón Nueva, esto nos abrirá un pequeño cuadro de diálogo donde agregaremos los siguientes valores:
* en la caja Nombre de variable: JAVA_HOME
* en la caja Valor de variable: la ubicación donde hayas instalado el JDK, en mi caso C:\Archivos de programa\Java\jdk1.6.0_18 y hacer clic en Aceptar.


4. Buscar la varibla de sistema llamada Path y hacer clic en Modificar.
5. En el campo Valor de variable de la ventana de diálogo Modificar variable de sistema agregaremos nuestra nueva variable de entorno al final del valor existente separándolo por un punto y coma (;) de la siguiente forma: ;%JAVA_HOME%\bin;

De esta forma estamos haciendo referencia a la carpeta bin (donde están los comandos de ejecución) de la instalación de Java usando la variable JAVA_HOME que hemos creado en los pasos anteriores. También podríamos haber escrito directamente la ruta de la instalación del JDK en el Path, pero como lo he dicho antes, es preferible hacerlo de esta forma.

Después de estos pasos simplemente deberemos hacer clic en el botón Aceptar de cada ventana y tendremos agregada nuestra nueva variable de entorno.

Otra forma es haciéndolo directamente desde la ventana de linea de comandos:

1. Hacer la combinación de teclas Inicio + R para abrir la ventana Ejecutar, y escribir cmd y hacer clic en Aceptar. Esto abrirá una ventana de linea de comandos.


2. En la ventana de linea de comandos escribir: set JAVA_HOME=, nuevamente, en mi caso la ruta de instalación es "C:\Archivos de programa\Java\jdk1.6.0_18"

Nota
: Las comillas no son necesarias a menos que tengamos espacios en blanco en nuestra ruta, como en este caso.

3. Posteriormente, en la misma ventana, habrá que agregar esta variable al Path de esta forma: set Path=%Path%;%JAVA_HOME%\bin;


Con esto habremos agregado la nueva variable de entorno, pero solo estará disponible mientras permanezca abierta la sesión de la linea de comandos. Para hacer permanente nuestras variables de otra forma, podemos agragarlas al Autoexec.bat para que se carguen siempre que arranque el sistema.

Agregar las variables de entorno en el Autoexec.bat

1. Abrimos una ventana de Ejecutar como en el paso uno de la sección anterior y escribimos sysedit y hacemos clic en Aceptar.
2. En la ventana de AUTOEXEC.BAT agregamos las lineas
@echo off
JAVA_HOME="C:\Archivos de programa\Java\jdk1.6.0_18"
Path=%Path%;%JAVA_HOME%\bin;


Y después de guardar el archivo, preferentemente, reinicia el sistema.

Nota: Gracias a un comentario, debo remarcar que en versiones posteriores a Windows ME las variables de entorno se deben agregar por medio de la ventana de Propiedades del sistema y no por la modificación del archivo autoexec.bat, aunque aun es posible.

La prueba

Para comprobar que verdaderamente se ha agregado la nueva variable de entorno abre una ventana de línea de comandos y escribe java -version, y el resultado de ejecutar esta línea deberá ser algo similar a esto:


Para más inromación sobre comandos del DOS, el Autoexec.bat y en general sobre las variables de entorno, dejo estos enlaces:
Variables de entorno
Environment variables
Autoexec.bat (inglés)
Autoexec.bat (español)
Config.sys y Autoexec.bat
How do I set or change the PATH system variable?

Comenzando con Java (2) - El IDE

martes, 16 de marzo de 2010

En la sección anterior de esta serie de Comenzando con Java vimos cómo comenzar apoyándonos en tutoriales y les dejé algunos videotutoriales muy buenos que me he encontrado en la red. Ahora toca seleccionar nuestro editor de desarrollo.

La selección de nuestro primer IDE (Integrated Development Environment, Entorno Integrado de Desarrollo) es muy importante pues nos ayudará a resolver problemas comunes, acelerar nuestro aprendizaje y adaptarnos poco a poco a una forma particular de trabajo.

Debemos seleccionar el IDE de acuerdo a nuestras necesidades, por ejemplo, si lo necesitamos solo para el uso académico, aprendizaje de ciertas herramientas y/o tecnologías del mundo Java, si lo necesitamos para uso profesional, ya que en ciertas empresas dicen al desarrollador cuál IDE usar, etc.

Como este tutorial lo he escrito para quienes aun están aprendiendo a programar en Java, les recomiendo usar un IDE
Lo que yo recomiendo es verificar que el IDE:

  • sea intuitivo
  • tenga resaltador de código
  • tenga depurador
  • tenga autocompletado (no indispensable si estás aprendiendo)

Aunque llegarás a usar otras herramientas muy prácticas y otras muy complejas conforme avances en tu aprendizaje.

Por ejemplo, yo aprendí usando un editor muy simple: TextPad, y también vi a compañeros aprendiendo con JPadPro.

Uno muy utilizado en la academia para la enseñanza de la programación en Java es BlueJ, la cual también recomiendo mucho.

También puedes aprender con uno más profesional como Netbeans (comentarios a parte) que es un IDE muy completo y ampliamente usado en entornos profesionales. Es gratuito y puedes descargarlo en su versión más ligera para comenzar a programar. También puede usar la versión Classic de Eclipse. Consulta sus páginas respectivas o la Wikipedia para leer más al respecto y decidir por un IDE.

Pero existen muchos más en el mundo Java, para todos los gustos, solo he comentado los más comunes.


Enlaces:
Netbeans (Wikipedia| descarga)
Eclipse (Wikipedia| descarga)
BlueJ (Wikipedia| descarga)
TextPad (Wikipedia)
JPadPro

"An instance of the program seems to be already running" en Netbeans

lunes, 8 de marzo de 2010

Actualmente estoy usando Netbeans 6.7.1 para desarrollar una aplicación Swing ya que me gusta el Matisse que viene con este IDE. Pero ya han sido varias ocasiones en las que la computadora se ha apagado abruptamente, lo que ha causado que Netbeans no se cierre correctamente; y después de reiniciar e intentar abrir nuevamente el IDE me muestra una ventana de alerta con el siguiente mensaje:

"An instance of the program seems to be already running with your user directory. Either a previous session of the program did not exit correctly, or another instance of the program is running on a different computer and using the same user directory.

"If another session of the program is running with the same user directory, please click Cancel to prevent the corruption of the user directory. If you are sure that no other instances of the program are running with your user directory, click OK to continue."

Para solucionar este problema debemos tener presente que Netbeans guarda distintas carpetas de configuración, estas son el Directorio de instalación, Directorio de usuario y Directorio de proyectos. Pues bien, para solucionar este problema en particular lo único que he hecho ha sido borrar el archivo lock que se encuentra en el directorio de usuario; en mi caso C:\Documents and Settings\Jorge Ruiz\.netbeans\6.7\lock

Las carpetas comentadas se crean durante la instalación de Netbeans y el usuario puede modificarlas, por lo tanto, es importante leer bien los diálogos antes de hacer clic en el botón Next de la instalación. Para más información sobre estas carpetas puedes leer el blog de soporte de Netbeans. Espero que la solución de mi caso les sirva...

Invocar programas ASM desde Java paso a paso

miércoles, 27 de enero de 2010

Hace ya varios meses envié un tutorial al portal de JavaHispano donde explicaba cómo hacer para invocar funciones escritas en lenguaje ensamblador desde Java. Y como ya pasaron más de tres meses desde entonces, ya puedo usarlo en mi blog :D.
Aquí les dejo el Contenido y las dos primeras partes para que se den una idea; también les dejo el código fuente y el documento PDF del tutorial.

Contenido

  1. Introducción
  2. ¿Cuándo usar JNI?
  3. Requerimientos de software
  4. Configuración del ambiente de trabajo
  5. La programación
  6. La ejecución
  7. Conclusión
  8. Referencias y lecturas

1. Introducción
En el sitio de java.net existe un pequeño tutorial titulado Invoking Assembly Language Programs from Java1 pero está en inglés y no es muy sencillo para algunos nuevos programadores Java o ensamblador. En java.net explican cómo funciona la invocación de un programa ASM desde Java y qué hacer para lograrlo, pero no explican cómo hacer cada paso. Por lo tanto me he dado a la tarea de facilitar la comprensión de estas técnicas para los hispanohablantes que dan sus primeros pasos con JNI; ya que conocer un poco del funcionamiento de JNI y la invocación de aplicaciones en ensamblador es fundamental cuando se tienen aplicaciones que necesiten operaciones que consuman mucho proceso del servidor y se necesite implementar un pequeño programa a bajo nivel para ejecutar tales operaciones, y de esta manera disminuir el tiempo de espera que a veces suele ser crítico.
También con JNI tenemos la capacidad de invocar funciones y procedimientos escritos en otros lenguajes, como C/C++ o en nuestro caso ASM, por ejemplo, cuando se tienen sistemas legados y se necesite utilizar alguna función del código legado será necesario desarrollar aplicaciones que puedan ejecutar estas funciones. Para más información de JNI y sus capacidades se puede consultar el manual para programadores disponible en el sitio de Sun2.
Cabe señalar que este no es un tutorial introductorio a JNI o al API, por lo tanto se limitará a mencionar solo algunos conceptos necesarios. De forma rápida, comenzaremos con determinar el software que usaremos y de dónde obtenerlo, pero no nos detendremos a aprender el funcionamiento de ellos. Posteriormente agregaremos algunas variables de entorno y comenzaremos con la programación. Para esto, se presentan los programas y cómo compilarlos, sin embargo estará disponible el código fuente usado en el tutorial. Al finalizar el tutorial el lector deberá ser capaz de cargar una librería DLL en cualquier aplicación Java y usar los procedimientos de cualquier librería nativa.

2. ¿Cuándo usar JNI?
En algunas ocasiones, a algunos desarrolladores les tocará encontrarse en situaciones en las que una aplicación hecha completamente en Java no cubrirá todos los requerimientos para tal. Algunos ejemplos de estas situaciones pueden ser:

  • Cuando a pesar de querer escribir toda la aplicación en Java para permitir la compatibilidad entre plataformas, exiten características de la plataforma que son necesarias para la aplicación y no son soportadas por la librería estándar de Java. Esto es referido como dependencia de la plataforma.
  • Cuando ya se tiene una librería escrita en algún otro lenguaje y se desea hacerla accesible a nuestro código Java, por ejemplo, al tener que trabajar con código legacy. en estos casos las librerías se cargan dentro del mismo proceso de la apliación por medio de JNI, aunque existen otros mecanismos más eficientes que funcionan en procesos separados.
  • Si se quiere implementar porciones de código en un lenguaje de bajo nivel como ensamblador para disminuir el tiempo de procesamiento. Por ejemplo, en aplicaciones que necesiten renderizar gráficos 3D que requieren más tiempo de procesamiento, habrá que escribir una librería para gráficos en lenguaje ensamblador para tener un mejor rendimiento3.
  • En casos en los que quiera cargar una librería nativa en un proceso existente para evitar el costo de iniciar un nuevo proceso y cargar la librería en el mismo4.
  • También será oportuno usar JNI cuando se quiera utilizar algunas funcionalidades de un programa Java desde un código nativo.

Documento Invocar programas ASM dese Java paso a paso
Código fuente
El tutorial en Javahispano


Convirtiendo fechas entre zonas horarias (2)

sábado, 12 de diciembre de 2009

En mi anterior post titulado Convirtiendo fechas entre zonas horarias puse un ejemplo de cómo poder convertir una fecha/hora de una zona horaria local a una distinta. Pero trabajando con el mismo proyecto encontré que debía convertir una fecha de la zona horaria UTC a la local, y entonces mi líder técnico me dió una solución sencilla cambiando solo una línea del código de ejemplo del post anterior, justo para hacer lo que necesitaba en ese momento:

En la tarea que estaba realizando leía un archivo de texto con el dato "fecha" como una serie de números: "20090921"+"1230", que representa el 21 de Septiembre de 2009 a las 12:30; por lo que tuve que usar el formato de fecha "yyyyMMddkkmm". Esta fecha que recibía del archivo representaba una fecha/hora en el horario GMT. Y esta hora la debía pasar a mi zona horaria local que es CST o UTC-6 (Tiempo del centro).

public void cambiarZonaHoraria( String fecha, String patron, String tz ) {
SimpleDateFormat format = new SimpleDateFormat( patron );
format.setTimeZone(TimeZone.getTimeZone( tz ));
try {
System.out.println( format.parse( fecha ) );
} catch (ParseException pe) {
pe.printStackTrace();
}
}


Lo que hace es muy sencillo:
  • Primero crea una nueva instancia de SimpleDateFormat con el parámetro "patron" que le dice a la instancia que el texto que se le va a enviar está en ese formato, en mi caso "yyyyMMddkkmm".
  • Luego, lo más importante de lo que intentamos hacer, le asignaremos a nuestro objeto format el TimeZone en el que está la hora que queremos convertir, en mi caso era GMT.
  • Posteriormente, simplemente usamos el método parse(String) para convertir nuestro texto a un Date en la zona horaria local, en mi caso CST; por lo que el resultado final de este ejemplo es que el texto "200909211230" con el formato "yyyyMMddkkmm"lo cual representa "2oo9/09/21 12:30" en GMT pasa a ser "2009/09/21 6:30" en CST ya que son 6 horas menos a la referencia del Tiempo Universal Coordinado o UTC.
Solo debemos recordar cachar las excepciones o hacer un throw de ellas.

Convirtiendo fechas entre zonas horarias

domingo, 6 de diciembre de 2009

En cierto proyecto en el que estoy involucrado tuve que convertir algunas fechas en el huso horario UTC (GMT) a la zona horaria CST (Tiempo del centro) que es el que usa la mayoría de los estados en México. Como el proyecto está enteramente basado en tecnología Java, me di a la tarea de encontrar formas de hacer esto con librerías para Java.

Encontré que hay algunas librerías, como las de Quartz, implementan alguna clase para la conversión de zonas horarias. Pero en mi caso, necesitaba no depender tanto de librerías de terceros o fuera del API de Java.

Encontré que con las clases TimeZone y DateFormat puedo hacer la conversión usando las siguientes sentencias.


public void cambiarZonaHoraria(Date fecha, String to) {
DateFormat dateFormat = new SimpleDateFormat();
TimeZone tz = TimeZone.getTimeZone(to);
dateFormat .setTimeZone(tz);
System.out.println(dateFormat.format(fecha));
}


Lo que se hace básicamente es

  • crear una instancia de SimpleDateFormat con el formato de fecha local
  • crear una instancia del TimeZone con el nombre corto de la zona horaria que se especifique por el parámetro "to"
  • se asigna la nueva zona horaria al objeto dateFormat
  • haciendo uso del método format() del objeto dateFormat se hace la conversión de nuestra fecha a una cadena que representa la nueva fecha en la zona horaria que hemos creado, y esta fecha se imprime en pantalla.
De la misma forma se pueden hacer conversiones entre distintos husos y zonas horarias.
Ahora, cabe señalar que para crear un TimeZone se usa el nombre corto de la zona horaria. Aquí dejo un listado de zonas horarias con sus nombres e IDs que he obtenido ejecutando este pequeño programa que encontré en Java Developers Almanac:

import java.util.Date;
import java.util.TimeZone;

public class ListadoZonasHorarias {

public static void main( String[] args ) {
Date fecha = new Date();
// Obtiene el ID de todas las zonas horarias
String[] zoneIds = TimeZone.getAvailableIDs();

System.out.println(" ID | Nombre corto | Nombre largo |Diferencia horaria \n");
for (int i=0; i<zoneIds.length; i++) {
// Ontiene el TimeZone dependiendo del ID e imprime el ID
TimeZone tz = TimeZone.getTimeZone(zoneIds[i]);
System.out.print(tz.getID() + "\t|");

// Obtiene e imprime el nombre corto y largo de la zona horaria
String shortName = tz.getDisplayName(tz.inDaylightTime(fecha), TimeZone.SHORT);
String longName = tz.getDisplayName(tz.inDaylightTime(fecha), TimeZone.LONG);
System.out.print(shortName + "\t\t|");
System.out.print(longName + "\t|");

// Obtiene e imprime la cantidad de horas de diferencia al huso GMT
int ro = tz.getRawOffset();
int horas = ro / (60*60*1000);
int minutos = Math.abs(ro / (60*1000)) % 60;
System.out.print(horas + ":" + minutos);
System.out.println();
}

}
}

Espero que les pueda servir como a mí. Saludos.

An internal error occurred during: "JSP Content Validator".

lunes, 31 de agosto de 2009

En la oficina en donde trabajo usamos Myeclipse como IDE y constantemente cuando editamos archivos XML o JSP en algunos proyectos, usando MyEclipse 6.0.1 GA, comunmente nos lanza una ventana emergente cada vez que intentamos guardar este tipo de archivos con los siguientes errores:

An internal error occurred during: "JSP Content Validator".
org/eclipse/wst/sse/ui/internal/reconcile/validator/ValidationHelper
An internal error occurred during: "JSP Semantics Validator (JSF)".
org/eclipse/wst/sse/ui/internal/reconcile/validator/ValidationHelper
An internal error occurred during: "JSP Syntax Validator".
org/eclipse/wst/sse/ui/internal/reconcile/validator/ValidationHelper
Y como ya se me acabó la paciencia, estuve investigando y al parecer son muchos los que tienen el mismo problema, sin embargo encontré una solución rápida pero nada atractiva, la cual es desactivar las validaciones de JSP y JSF.

Para hacer esto debemos abrir la ventana de preferencias que está en el menú MyEclipse-->Preferences...

Y desactivar las casillas para

  • JSF Application Configuration Validator,
  • JSP Content Validator,
  • JSP Semantics Validator,
  • JSP Syntax Validator

Con esto tendremos solucionado provisionalmente el error de las validaciones que muestran esas molestas ventanas emergentes cada vez que queremos guardar una archivo JSP o XML.

Comenzando con Java (1)

Como lo prometido es deuda, y para no reinventar la rueda, decidí que en vez de grabar un video tutorial y aburrirlos con mi voz, mejor les daré acceso a algunos videos que otros ya han hecho de manera muy profesional.

1. Los primeros videos son unos que me encontré mientras buscaba cómo poder ayudar a unos compañeros a los que les dí tutorías. Son unos videos que comienzan desde los aspectos básicos de Java pasando por el IDE, conceptos, bifurcaciones, iteraciones, vectores y algunos ejemplos.

http://www.videoaprendizaje.com/index.php?topic=536.0

2. Los siguientes son una serie de videos muy profesionales con el propósito de ser un curso hacia la certificación SCJP del Ing. Julio César Fuenes Ochoa liberado bajo licecia Creative Commons. Se pueden descargar dos versiones del mismo autor, de dos sitios distintos.

http://locx24.wordpress.com/2009/02/23/curso-en-videotutoriales-de-java-se-50/

http://www.kootbox.com/component/option,com_remository/Itemid,27/func,select/id,6/orderby,2/page,1/

En fin, espero que disfruten de estos videotutoriales y les sea de mucho provecho. Sigan visitándonos, pronto pondremos videos con propósitos más específicos. Si tienen peticiones puden enviarlas o seguirnos vía Twitter.


Publicado originalmente en http://swcoders.com

¿PHP o Java?

domingo, 23 de agosto de 2009

A veces algunos amigos me preguntan qué lenguaje de programación deberían aprender, y yo les digo -el que quieras-. Pero sinceramente es un poco más complicado, porque les debería preguntar primero -Bueno, ¿qué es lo que quieres hacer?-

Pero tal vez la pregunta debería redefinirse y ahora explico porqué…

Porque recuerdo que en una clase nos dejaron la tarea de comparar las tecnologías PHP, Java y .NET. Sin embargo yo creo que ambas tecnologías, PHP y Java, no pueden compararse, y no quiero decir que PHP no le llegue a los talones a Java, no me malinterpreten.

Debemos tener presente qué es PHP. PHP es una tecnología de programación para Web; para eso fue creado. Sin embargo Java es una plataforma tecnológica con el que se pueden hacer aplicaciones Web, de escritorio, móviles, y un largo etcétera. Tal vez, la comparación que debería hacerse es “¿Qué necesito para lo que quiero hacer, PHP o JSP/Servlets?”. Ya que los JSP y Servlets son un conjunto de APIs de Java que permiten programar aplicaciones para Web. Además de estos, Java cuenta con decenas de otras definiciones con los que se pueden hacer infinidad de cosas.

Por eso, si me preguntan -¿Qué lenguaje de programación deberían aprender?-, yo podría preguntarles -¿Qué es lo que necesitas hacer?- Porque con JSP y Servlets puedes hacer lo que harías con PHP y mucho más.

Ahora, no quiero caer en que se puede programar en Java igual que se haría con PHP, porque también hay que reconocer que existe una curva de aprendizaje mayor en el lenguaje Java que en PHP. Y sin mencionar que cuando uno quiere hacer cosas más complejas y robustas tendrá que aprender a usar algún framework para lograr su trabajo.

Por fuera de todo eso, lo que siempre recomiendo es, aprende Java, ya que los programadores Java tienen una gran demanda en México y muchos países y son muy bien pagados. Hay mucha documentación gratuita y profesionales dispuestos a ayudar.

Por eso, únete a nosotros y síguenos constantemente para ir aprendiendo Java. Próximamente comenzaremos con los videos…


Publicado originalmente en http://www.swcoders.com.

¿Cómo puedo aprender Java?

jueves, 13 de agosto de 2009

En el blog de http://www.swcoders.com hace algún rato publiqué un post donde explico cinco sugerencias sobre cómo aprender a programar en Java, y para cualquier lenguaje de programación funciona igualmente. Pues este es un copy&paste del mismo:

En varias ocasiones mis amigos me han preguntado sobre cómo podrían comenzar a aprender a programar en Java. Pues lo que siempre les he respondido es “leyendo y haciendo“. Cuando aprendí a programar en Java fue gracias a unos amigos que me decían lo mismo, pero ¿de dónde leer?, lo que estos amigos me decían, y lo que yo respondo ahora a los que me hacen la pregunta es que “Google tiene todas las respuestas“, bueno, aveces no todas.

Es que para aprender a programar en cualquier lenguaje y para ser aficionado a la programación, la persona debe ser un investigador nato. Y si has llegado aquí es porque estás buscando aprender, y estamos para facilitarte el aprendizaje.


Leyendo. Hay muchos tutoriales esparcidos por toda la Web, solo es cosa de saber buscar. Pues si pones “tutorial OR manual Java” en cualquier buscador obtendrás cientos de guías de aprendizaje de Java. Solo es cosa de que te sientes un fin de semana con café y frituras frente a la computadora. Si eres más tradicional, pues hay cientos de libros muy baratos en mercadolibre.com, aunque también los hay en formato electrónico. Un lugar al que siempre voy es a www.g2p.org que te ayuda con los hacks de google para buscar en los índices de servidores buscando lo que tú quieras.

Haciendo. Muchos tutoriales tienen ejemplos de práctica básicos con los que puedes comenzar a jugar. En los mismos tutoriales te explican cómo configurar tu ambiente en Windows o Linux para poder programar en Java.

No temerle al inglés. Un factor de miedo que veo en muchas ocasiones en algunos amigos que quieren aprender a programar es que muchos libros y tutoriales que consiguen están en inglés. Pero para ser aficionado a la informática en general, debes aprender a no temerle a los idiomas, y no me refiero a que seas políglota; pero como mínimo, deberás estar aprendiendo a leer el inglés mientras aprendes a programar. Pero no temas, actualmente hay muchísima información y tutoriales en Español muy profesionales y sencillos con los que puedes aprender.

Foros. También puedes suscribirte a foros donde puedes hacer preguntas respecto de tus dudas y te aseguro que más de un programador Java estará dispuesto y tendrá la respuesta que buscas. Algunos son: Foros FIT, javahispano.org, programacion.com, programacionweb.net, forodejava.com.

Podcasts. Los podcast son un medio con el cuál puedes mantenerte actualizado sobre las últimas noticias y nuevas herramientas acerca de Java. Esto te ayudará a abrirte la mente a muchas cosas que existen en el mundo Java que tal vez desconozcas. El podcast que escucho con más frecuencia es el de javahispano.org, y el de javaposse.com, en inglés.


La nota original esta aquí.

Te invito a darte una vuelta por SWCODERS y ver el material y tutoriales que hay.

Cómo catalogar a un desarrollador de software

lunes, 11 de agosto de 2008



15 consejos para obtener el ascenso que quieres, e incrementar el salario que te mereces

¿Cómo catalogas a un desarrollador de software? Es una pregunta fantástica. Hay muchas teorías por allí, y hay muchas formas en las que los equipos de Recursos Humanos lo hacen y te ayudarán a dirigir el estudio de rendimiento. Sin embargo, ¿qué hace realmente a un gran desarrollador? Y si eres un Desarrollador de Software, ¡cómo puedes mejorar hoy tu carrera! Abajo les presento mi biblia para catalogar a los desarrolladores en mi equipo. Siguiendo estos consejos e ideas, podrás mejorar tu estado de "buen desarrollador", a "gran desarrollador".

1. Tiempo que invierte escribiendo código grandioso.
¡No me refiero a la cantidad, sino a la calidad! Sin embargo un giro a esto es: Me refiero a la cantidad, y la calidad. Muchísimas veces encontrarás uno de estos dos escenarios.

En el escenario A, tienes a un desarrollador que escribe código como loco, y las cosas parecen funcionar... entonces comienzan a suceder errores, y tú no sabes porqué, parece que llevará toda la vida arreglarlos. ¡O ellos arreglan 10 y causan 5 más! Pero obtuviste bastante código...

En el escenario B, tienes a un desarrollador que parece inteligente. Lo entrevistas y él lo sabe todo de todo, puede hablar teóricamente de arriba a abajo. Pero por alguna razón, tú le has asignado tres tareas, y tres semanas después, ¡él aun está trabajando en algo que debió haber terminado en 3 días! Y estás confundido. ¡Él es tan inteligente! Conoce todo acerca de generics, multi/threading, ¡y puede explicarle de punteros a tu abuela y hacer que ella se emocione y quiera codificar! ¿Por qué no esté terminado nada?

¡En el escenario de tus sueños, obtienes código grandioso! El código grandioso está hecho por un gran desarrollador que es súper inteligente, conoce lo que es código de calidad, y escribe código como Tony Hanks maneja su patineta. ¡Se ve tan natural! Es muy entretenido verlo/a. Además, lo consiguen a una velocidad cegadora. Saben cuánto tomará cada problema, y no se detendrán por buscar cuál es la mejor solución del mundo con múltiples threads y capas para escribir un juego de pong. Lo errores no existen porque ellos escriben pruebas unitarias para ellos mismos, y solo codifican en sus sueños. Estos chicos valen lo que pesan en ORO.

2. Interpretación del problema.
Hay un problema con millones de formas de resolverlo. Algunas personas son solamente pensadores rápidos y pueden salir con múltiples soluciones instantáneamente. Sin embargo, lo que un gran desarrollador haría es definir totalmente el problema antes de hacer cualquier cosa. Un gran desarrollador escribirá un documento o pizarra con el problema. Ellos enviarían un correo electrónico a su gerente y dirían cosas como "¿Podemos tener una junta para que le pueda explicar cómo entiendo yo el problema?" Luego ellos comienzan dando varias soluciones, etc.

Vea, un gran desarrollador conoce que la forma en la que ellos ven e interpretan el problema, probablemente no es la forma en la que el creador del problema quiso que fuese entendido. Este es un punto importante, ten eso en mente. Un gran desarrollador buscará entender completamente el problema antes de intentar proponer una solución. ¿Entiendes el problema al 100%? ¿no? ¿99%? ¡Ve, haz más preguntas y asegúrate que está 100% claro!

3. Cómo se aborda el problema
¿Una vez que tengas claramente definido el problema, solo comienzas a codificar? ¡Error! Un gran desarrollador mirará la disposición, y comenzará a pensar en varias opciones, y basado en el problema, pensará en el mejor enfoque para resolver el problema. Yo veo esto como un juego de ajedrez; puedes saber cómo se mueven todas las piezas, conocer todas las reglas del juego, ¿pero sólo comenzarás a mover las piezas? ¡Claro que no! Debes analizar el tablero, crear tu plan de juego, mirar a tu oponente, y ver qué es lo que él o ella hace usualmente. Es el mismo caso cuando abordas un problema.

Observa el problema, imagínate cómo necesita ser el resultado, el tiempo del que dispones, la calidad que se espera, las herramientas de las que dispones para trabajar, etc. Entonces, comienzas a resolver el problema.

4. La confianza en el código
Como gerente, cuán confiado puede estar en sus códigos. Puede decirle a algunos desarrolladores "Necesito esto completamente para el Viernes" y llega el viernes, recibe un email diciendo "He revisado el código en el branch y está listo para las pruebas" y tú sabes que el equipo de aseguramiento de la calidad encontrará muy pocos errores, o ninguno. Por otra parte, hay algunos desarrolladores que en lugar de eso le enviarán un email diciendo "Aún no he terminado, estará listo para el Lunes a primera hora en la mañana." Y estás 95% seguro que estará plagado de errores, y que no será utilizable durante días, sino es que semanas, hasta que los errores sean eliminados completamente del código.

Resumiendo: ¡La más alta fiabilidad que puedes tener de los desarrolladores, es que están muy cerca de ser grandes desarrolladores! Imagínate siendo tu manager, y el peso que quitas de su hombro si no tiene porqué preocuparse por tu código.
5. Confianza en la solución
Una cosa es sentirte confiado en el código. Si tienes a un gran desarrollador en tus manos, estás confiado en la solución. Los grandes desarrolladores serán grandes arquitectos. Ellos son capaces de analizar el problema entero, e imaginarse cómo necesita ser solucionado el problema. Ten en cuenta que no es solo codificar con código grandioso, !se trata también y principalmente de la arquitectura que le das a la solución! Este es un punto importante, y que realmente separa a los buenos desarrolladores de los grandes en el mundo del software.

6. Satisfacer los requerimientos del usuario
Al final del día, puedes tener el mejor código, y la mejor solución posible, con toda la mejor arquitectura, ¿pero logra satisfacer los requerimientos del usuario? ¡Posiblemente no! Y has fallado completamente. Ahora, hay varios grados de falla, pero un gran desarrollador dará en el blanco consistentemente. Ellos encuentran lo que el usuario necesita exactamente, crean una propuesta, le muestran al usuario lo que obtendrán paso a paso durante la marcha con ediciones semanales sin errores, y seguirán la construcción desde la última versión. ¡Los requerimientos están justo como deben estar y el usuario baila de contento!

7. Mantenerse actualizado
Los grandes desarrolladores están actualizando constantemente sus habilidades independiente y proactivamente! Tienen sed de nuevos conocimientos y perfección como un gato con la leche. No esperan a que su director venga a darles tareas, les ofrezcan tomar cursos, o les den libros para ser más eficientes. ¡Ellos van y consiguen esas cosas por sí mismos!

Encuentran las conferencias a los que quieren asistir, y envían correos electrónicos como "Estaría encantado de ir al Tech-Ed este año. Aprenderé [insertar razones aquí], y estaré capacitado para contribuir a [insertar proyectos aquí]. He hecho provisión para ahorrarles [dinero/razones métricas aquí]. ¿Si fuera posible, la empresa me ayudaría a pagar el viaje?" Si alguien me enviara esto, no solo le podría ayudar a pagar, ¡sino que le pagaría el viaje entero!

Los grandes desarrolladores acuden siempre a los grupos de usuarios, como un grupo de usuarios .net por ejemplo, o un grupo de usuarios Java. Asisten a los encuentros locales, y hacen lo que sea para alimentar su cerebro. ¿Has leído todos los últimos blogs y revistas? Haz una lista con tus 5 blogs de desarrollo favoritos. ¿Puedes hacerlo? ¡Deberías poder hacerlo como si fueran actividades de un club de boy scouts! Actualízate, esto abrirá tu mente, tendrás la siguiente gran idea y serás recompensado.

8. Contribuye al equipo
Puedes ser uno de los mejores, o aún el mejor programador, arquitecto y más brillante chico en el equipo, pero en lo que a mí respecta, sino estás dispuesto a compartir y contribuir con tu equipo, estás perdiendo la mitad de tu valor, sino es que más. Un gran desarrollador hace grandes a los otros alrededor de él. fíjate, un buen desarrollador consigue ser cada vez mejor, pero no comparte el conocimiento que obtiene, o cómo lo obtiene.

Aprende nuevas cosas, aprende acerca de las nuevas tecnologías, pero no deja que otros sepan de ellas. Un buen desarrollador termina sus proyectos a tiempo, pero cuando la presión es mucha, no está allí para su equipo. Un gran desarrollador está en contacto con todos los proyectos que tiene el equipo y está listo para ayudar cuando se necesite. Ellos dirán cosas como "Me enteré que el equipo A está trabajando en [proyecto], y creo que puedo ayudar, ¿no crees?"

9. Haz grandiosas actas de juntas
Esto es increíblemente importante! No hay peor cosa que llamar a una reunión, tomar tiempo para explicar nuevos conceptos, nuevas ideas, lluvia de ideas, venir con grandes diseños, y no tener nadie que tome notas de las reuniones. Incluso si tienes a alguien designado para esto, quisiera ver a todos con pluma y papel (de preferencia la notebook del desarrollador). Un gran desarrollador hace grandiosas actas en las reuniones; escribe todos los acuerdos de la reunión, y al final de los encuentros puedes escucharlo decir "Entonces solo para confirmar, mis tareas son: . ¿Me falta algo?"

Luego, un gran desarrollador enviará el acta a su manager, listando la fecha de la reunión, el tema, y quién lo atendió. Siguiendo esto, tendrás las tareas en la parte superior, con el abanderado de la tarea. Bajo eso, encontrarás las notas detalladas de la reunión. Un buen desarrollador no toma notas de las reuniones, dice 'Si' cada vez que agregas una tarea a su lista... y espera que su memoria le funcione bien. Luego te envía un email para revisar sus cambios, y te molestas cuando ves que se le olvidaron algunas cosas, pero obtuvo el 90% si está bien. ¡Este es un enorme desperdicio de tiempo! Y sin ninguna razón. Toma grandiosas actas de reuniones.

10. Esté dispuesto a aprender y aceptar críticas constructivas
Si has leído esto, entonces estarás tomándolo todo e intentarás implementar alguna de mis sugerencias en tus labores de desarrollo diarias. Mira, otra área importante es la habilidad del desarrollador para aprender de otros, y aceptar críticas. Sé una persona dispuesta a aprender, debes ser como una esponja, y absorber enormes cantidades de conocimiento rápidamente! Tu jefe está allí por alguna razón. Seguro, ellos pueden ser unos programadores a la antigua, pero también estuvieron en las trincheras, y han estado en cientos de batallas, y tienen heridas y miedos. Ellos tienen el instinto para hacer grandes decisiones, y hacerte grande. Están en la posición en la que están porque quieren verte tener éxito, y desean hacerte crecer.

Por supuesto, este es el entorno de trabajo ideal, pero eso puede pasar donde tú quieras si eres un gran desarrollador. Te garantizo absolutamente, y te prometo, que lo mejor es cultivar esta habilidad, hacerte extremadamente enseñable, tomar notas de las sugerencias y críticas, y ponerte el objetivo de mejorar, y es la mejor oportunidad para convertirte en más de lo que te hayas imaginado posible. Si por otra parte, escoges pensar de tí mismo como "la élite", y que no tienes más que aprender, siempre estarás estancado en donde estás. Si no estás creciendo, ni siquiera estás en el status quo, estás muriendo! Crece!

11. Siempre disponible cuando se necesite.
Esto es dar y recibir. Si trabajas para una gran empresa, ellos serán flexibles contigo. Nunca deberían preguntarte acerca de las horas de cita con el doctor que no pudiste programar después de las horas de trabajo, por la hora de entrada o de salida, o tu hora de comida. Ellos deberían animarte a ir al gimnasio a la hora del almuerzo, pagar por las comidas cuando sales con el equipo, etc. Deberían darte algunos días libres después de algún día o proyecto pesado. Y la lista sigue y sigue.

Sin embargo, con todas esas ventajas, vienen responsabilidades, inexcusablemente! En momentos difíciles, un gran desarrollador te sugerirá que el vendrá el fin de semana si se necesita. Se queda hasta muy tarde como sea posible y tan tarde como se necesite para asegurar que el trabajo se termine. Escucha, los grandes desarrolladores toman responsabilidad de sus creaciones. Ahora, claro que esto no es necesario, pero esta es la marca de un gran desarrollador. Algunas personas solo quieren trabajar sus 8 horas diarias, y ser buenos desarrolladores, pero ellos nunca serán grandes. Los grandes desarrolladores están con los jugadores del equipo hasta el final, y ven su trabajo como un arte, y a su equipo como una familia.

12. Vestir profesionalmente a diario
Nunca sabes cuándo puede venir un cliente a una visita. Nunca sabes cuándo serás llamado a una junta, ya que no todo es planeado. Y cuando ese momento llegue, debes estar listo para el baile! Un buen desarrollador viste ropa normal de lunes a viernes, incluso con jeans negros, y tenis que parecen zapatos de vestir. Un viernes casual lleva shorts, tenis, y una playera. Cuando la visita llega el viernes con una nueva cuenta enorme, no puedes llamarlo para ir a una comida porque él no está vestido apropiadamente.

Un gran desarrollador viste ropa de negocios de lunes a viernes. Ellos visten para tener éxito. Claro, si no tienes habilidades, no serás ascendido a manager o líder de equipo solo porque vistas muy bien. Pero si tienes grandes habilidades, y vistes de traje y corbata, entonces te has catapultado de rango, no se puede negar. Los 400 dólares que gastaste en un conjunto decente y corbata te será devuelto con los años. ¡Te lo prometo!

13. Habilidad de comunicación
Esta es otra categoría crítica! Hay muchos buenos desarrolladores allí afuera, pero no hay muchos grandes desarrolladores, ¿Por qué? Porque todos los buenos desarrolladores son terribles comunicadores. Hay varios niveles de comunicación, desde un correo electrónico hasta encuentros SCRUM, todas las formas de reuniones ejecutivas y tu habilidad para contribuir en un nivel ejecutivo. Tú llegas a ser "El show" cuando te presentas a cientos de personas para mostrarles el nuevo software. Si bien no es necesario llegar a las etapas finales, debes al menos estar dispuesto a comunicar tus ideas clara y efectivamente en las reuniones. Mientras mejor sea tu comunicación, más lejos llegarás.

Resumiendo: Si quieres ser un ejecutivo, debes tener un 9 o 10 en comunicación. Aun cuando tomes notas de las reuniones, o envíes reportes de estado, necesitas comunicarte extremadamente bien. No digas solo "Arreglé el error 1371" en tu reporte diario. Expláyate; explica cuán complicado fue resolver el problema, cuánto tiempo te tomó, o cómo lo resolviste rápidamente. Explica la tecnología que usaste, y porqué estás seguro que el problema no volverá a suceder. Tus reportes de estado no deberían ser algo malo que no te guste hacer. Los reportes deben ser una parte emocionante de la semana donde consigues mostrarle todo a tu manager.

14. Objetivos en cuanto a habilidades
Los buenos desarrolladores pueden hacer las cosas e ir haciendo diariamente lo que les digas que hagan. Realmente no ven a futuro y tampoco saben lo que quieren estar haciendo dentro de uno, cinco o 10 años. Algunos buenos desarrolladores saben lo que quieren... pero no tienen un plan real para conseguirlo. Un gran desarrollador tiene sus metas fijadas para un año, los siguientes cinco años, y sabe también dónde estará en 10 años.

Los grandes desarrolladores además lo llevan a otros nivel, no solo piensan en sus objetivos, sino que también los visualiza. Pueden ver exactamente lo que estarán haciendo dentro de cinco años, y el nivel en el que lo estará haciendo. Y todavía más, un gran desarrollador crea un plan detallado para su siguiente año, lo completa con cursos que tomará, proyectos que completará, y relaciones que construirá.

15. Habilidades organizacionales
El componente final que realmente conjunta todo es la organización. Puedes ser el mejor desarrollador en el mundo, pero si no eres organizado, caerás y te hundirás. Eventualmente te abrumarás y finalmente te hastiarás. Los grandes desarrolladores mantienen un escritorio extremádamente limpio, cuidan sus laptops y escriben claramente. Anotan constantemente en su calendario de Outlook sus tareas y reuniones. Tiene un apartado en la bandeja de entrada para acordar con mensajes de correo a reuniones y nuevas asignaciones. Mantienen carpetas de archivos y pueden sacar instantáneamente proyectos, notas de reuniones y otros detalles cuando se les pida que lo saque.

Bonus Tip: Pasión!
Uno de los miembros de mi equipo leyó la entrada y me recordó algunas cosas que todas las personas simples en mi equipo tienen. Pasión! Sin pasión en los que haces a diario, no serás un gran desarrollador, o grande en niguna cosa. Esto es también la principal razón por la que las personas no tienen éxito. Un desarrollador apasionado superará al mejor desarrollador técnico si éste no se apasiona por su trabajo, su rol, y su proyecto. Piensa en esto, si has leido hasta aquí, ¿estarás haciendo un esfuerzo para hacer los cambios que he listado? Parece simple, pero sin la pasión para hacer esas cosas, realmente te comprometerás hoy y tendrás éxito?

¡Entonces ahí lo tienes! Esos son los punos principales con los cuales evalúo a mi equipo de desarrollo durante las revisiones de los procesos. Pon atención, proveo a los miembros de mi equipo del mejor entorno como me es posible, y por lo tanto espero que sean grandes desarrolladores, o si tú mismo eres un desarrollador, por favor usa esta lista para hacer los cambios que sean necesarios, y catapulta tu carrera y la de tus compañeros.
Sigue estos consejos, y obtendrás el escenso que buscas, el aumento de salario que estabas esperando, y sobre todo estarás feliz con tus logros. Inténtalo y cuéntanos de tus resultados en los comentarios de abajo. Me agradará escuchar de tí. ¡También si tienes otros puntos que creas que deberían ser agregados, hazmelo saber!



Traducido del original en Real World Software Development

Después de haber leído esto, me puse a reflexionar seriamente sobre mi estado actual como desarrollador de software. Soy fuerte en algunos puntos, pero muy débil en otros.
En cualquier área de desarrollo de software en la que te encuentres, ¿cómo te catalogas? ¿Te has propuesto mejorar?

Devolver el orgullo al nombre de "programador" para solucionar el déficit de programadores

miércoles, 30 de julio de 2008

Hace unas semanas atrás discutíamos en el foro de mi facultad acerca de las diferencias entre los títulos de "programador" y "desarrollador". En este foro comentaban maestros y alumnos acerca de esta distinción, entre los comentarios más frecuentes se encontraban que el programador simplemente codifica y el 'desarrollador' analiza, planifica, codifica y muchas otras cosas más. Esto me hace recordar la etapa del desarrollo de software de manera artesanal que tomó fuerza a finales de los 60's. Sin embargo, desde ese entonces, el desarrollo de software ha avanzado, aunque a pasos lentos que actualmente aun se sigue produciendo software a manos de técnicos y programadores artesanos.

Enrique Dans menciona el problema de la desvalorización de los programadores en su primer artículo referente al tema en Libertad Digital:

...el programador es considerado una especie de "obrero especializado", y sometido a una economía de salarios bajos, inestabilidad laboral, elevada rotación y fuerte incidencia de estrés.
Esta es la consideración que se tiene, cuando debería ser otra muy distinta.
Ser programador es un trabajo creativo, un papel indispensable en la economía de hoy que merece muchísimo respeto y que genera un elevado valor. Sin embargo, ¿dónde están los programadores? ¿Por qué no salen de las universidades, dispuestos a convertir esa hiperabundancia actual de ideas en código y a participar en esa revolución consistente en crear tantas actividades en el seno de la red? ¿Qué profesionales están generando las carreras de Informática o algunas Ingenierías, y por qué tienden a rechazar la idea de programar como si fuera un estigma o algo típico de obreros especializados?

En España, a este lado del túnel, se necesitan programadores. Y los programadores necesitan una reivindicación urgente de su profesión, que recupere el legítimo orgullo de quien crea, de quien desarrolla, de quien se responsabiliza de un todo, de quien se enamora de un proyecto y no se limita a ser un obrero en el mismo, sino un verdadero arquitecto. Se buscan programadores con orgullo y capacidad para serlo. Pero por lo que se ve, habrá que mirar debajo de las piedras.


Y México no escapa de este problema. Sumado a esto está la deserción de los estudiantes en las carreras de informática y sistemas computacionales, y las matrículas se reducen cada vez más. Como señala Emilio Osorio en la revista Software Gurú:
El desarrollo de software atrae cada vez a menos jóvenes, y muchos de estos cambian de carrera antes de graduarse... Mucho se ha hablado de las causas de esta crisis, algunos culpan a la falta de profesionalismo y experiencia real de los maestros, otros, al mal ejemplo que damos los que somos parte de esta industria: nuestras jornadas de trabajo, niveles de estrés y costumbres geeks no son muy atractivas para jóvenes de 18 años que sólo se quieren divertir.
Leyendo más acerca de porqué se ha infravalorado el título de programador he encontrado varias perspectivas. Una de estas alude a la poca importancia que le dan las empresas y casas de software a los programadores, viendo en ellos a simples máquinas mecánicas a los cuales se les dan unos planos de la construcción de un determinado software y produce código que hace lo que el analista le ha planteado. Tal como lo menciona Enrique Dans hablando acerca de la concepción común de un programador en la publicación de altianews de septiembre de 2007:
...mientras en nuestro entorno, la palabra “programador” define un trabajo de baja cualificación, casi mecánico, asociado al traslado de las especificaciones de un analista en líneas de código ejecutables por un ordenador, lo que las empresas necesitan no es eso, sino una noción más moderna del término: la de un profesional mucho más autosuficiente, con conocimientos de ingeniería del software, teoría de la computación, matemática, algorítmica e incluso nociones de estrategia de negocio, que desempeña una actividad de elevada cualificación y responsabilidad. Enrique Dans: “Programadores: cuando falla la base”
Otra de las rezones se da en el artículo mencionado son las instituciones académicas, ya que los profesores influyen en gran manera en los alumnos a despreciar el puesto de programador.
...mientras los profesores en las Escuelas Técnicas, insistiendo en el error y manifestando una clara incapacidad para formar a ese tipo de profesionales, se afanan en convencer a sus alumnos para que huyan de la programación como de la peste.
Ricardo Galli, creador de Menéame, también menciona este problema en su antiguo blog:

...más del 70% de los alumnos de las ingenierías informáticas están completamente desmotivados y/o desinteresados por su carrera, especialmente la programación.

Quizás se debe a que durante muchos años de habló que era la “carrera del futuro”. Quizás también se deba a que ser un buen programador es cada vez más difícil y que obliga a un esfuerzo intelectual muy importante. Quizás también se deba a la “falta de perspectiva” de cómo es la profesión en los centros importantes: mucho esfuerzo pero a la vez mucha autoconfianza y coraje.

Seguramente los profesores tenemos parte de esas culpas. Conozco a muchos que piensan que un “ingeniero no necesita programar”, conozco también a muchos que ya no se acuerdan de cómo se programa. Pero también conozco a muchos profesores que son unos monstruos programando y dando clases, pero esos justamente son los más “odiados” o ignorados por esa gran mayoría de alumnos que sólo desean aprobar las asignaturas de la forma más sencilla, segura y sin liarse demasiado el coco. Así muchas veces terminan festejando al profesor que les cuenta batallitas por que así sí que aprenden “cosas prácticas” y útiles.

Pero sí, los profesores –incluido yo–, somos parte importante del problema

Aunque los artículos hablan acerca del problema en España, en México he visto el mismo problema en mi propia universidad, tal vez no de forma tan extrema, pero si intentando convencer a los estudiantes de buscar un "nivel más alto" como lo es el Ingeniero de Software o "Desarrollador", los cuales según la concepción generalizada, programan menos y están más arriba en la escala jerárquica empresarial.

Otro problema son los sueldos de los programadores, que como ya he mencionado antes, las empresas desvalorizan la labor del programador, así que pagan bajos sueldos. Sin embargo, a estos mismos les urgen programadores.
...la empresa cree que necesita programadores a la vieja usanza, y pretende pagar dos duros a quienes son, en realidad, profesionales capaces de destilar ideas en código y convertir el proyecto en realidad. Y ante semejante estímulo, los profesionales simplemente rehuyen la confrontación y buscan otras metas. Y es que pasar de obrero a arquitecto no sólo requiere un nivel superior de cualificación. Supone, además, que existan incentivos para ello.
A diferencia, otros se arriesgan a opinar que no es que falten programadores, los hay, lo que hace falta es motivación. Se refieren a la motivación del programador, pero esto no es sino un reflejo de lo que tales programadores han aprendido durante su carrera y de la manera en la que ven el puesto de programador. Aunque lo que menciona Jordi Abad en su blog es muy cierto:
...el trabajo de programador está asociado a la base de la estructura jerárquica de una empresa. Esto implica: bajos salarios, mala reputación y comerse muchos marrones de las capas superiores de la pirámide. Es un trabajo muy poco agradecido. A pesar de ello se trata de un trabajo necesario e imprescindible por parte de una empresa que se dedica a programar software.
Ricardo Galli propone además sus propios puntos de vista referentes a las causas que generan estos problemas:
  1. Las empresas grandes que pueden pagar bien a los buenos programadores tienen obsoletas estructuras piramidales que lo único que logran es quemar a los buenos programadores en menos de un año.

  2. Las puntas de esas pirámides suelen ser aquellos que no quieren saber nada de programación y se dedican a ascender, delegando toda responsabilidad a los “analistas senior”, que a su vez delegan y culpan a los “analistas junior” y así abajo en la cadena hasta llegar al buen programador que está a punto de dejar porque ya está quemado.

  3. Empresas grandes que venden carne de ingenieros al kilogramo pagando salarios de becarios y haciendo verdaderas chapuzas porque al final nadie es el responsable. ¿Alguien recuerda al web del Congreso y tantas otras administraciones por ejemplo?.

  4. Las administraciones y grandes empresas, como tienen problemas en mantener a sus buenos programadores (por 1 y 2), contratan ingenieros al kilogramo a las que se dedican a venderlos.

  5. Las empresas pequeñas buscan programadores “básicos”, que sepan un poco de Visual Basic, con suerte Java, y montón de otras cosas como instalar MS Office o “un servidor Linux”.

  6. Muy pocas empresas tienen asumido que sus programadores requieren un entrenamiento inicial especializado en lo que va a hacer –que no puede brindarle ninguna universidad o ciclo formativo– y que esos programadores también necesitan una formación continua –vía cursos específicos o tiempo y tranquilidad necesario para trabajar en proyectos con técnicas y métodos más modernos y diferentes–.

  7. El problema de la disfunción metacognitiva, muy generalizada entre los informáticos.

  8. Existe una especie de presión a las universidades para que “formen profesionales adecuados al mercado del trabajo”. Ese mensaje ha calado profundo en muchos profesores, pero aún más entre los alumnos que exigen que se les enseñe Java desde primero –y nada más que Java– porque es lo que demanda el “mercado laboral” y que hace que pasen olímpicamente de otras asignaturas que marcan diferencias, por ejemplo álgebras o conceptos complejos de la “ciencia de la computación”.

  9. Quizás por #6, muy pocos programadores dedican tiempo a leer, aprender y navegar mucho por Internet, que se ha convertido en la fuente principal y fundamental para aprender las nuevas técnicas, tendencias y formas de llevar adelante proyectos. Existe una especie de sentimiento generalizado –que todavía no puedo comprender, con lo guapa y divertida que es la informática y programación– de “en mi poco tiempo libre me olvido del ordenador”…

Como bien lo ha dicho, he visto mucho de esto con mis compañeros de clases y colegas de trabajo. A muy pocos de ellos les llama verdaderamente la programación y muy pocos leen y se mantienen actualizados. En la región sur de México existen muy pocas empresas especializadas en desarrollo de software, y los que están, ofrecen bajos salarios y no tienen mejores prácticas de desarrollo. A esto también me quiero referir, a la centralización de las empresas en el Edo. de México, Monterrey y Guadalajara. Esto provoca que muchos jóvenes con deseos de superación y con grandes capacidades pierdan de la oportunidad de poder desarrollarse profesionalmente ya que vivien en otros estados.

También quiero citar a una publicación de
BusinessWeek en donde señala una importante consultora acerca del déficit de talentos en la India para el 2010.
Building showpiece campuses the size of many U.S. colleges is just one way big Indian employers are battling to hold on to budding engineers, designers, and finance specialists... Today, companies face high turnover, escalating salaries, and shortages of qualified workers and managers. Less than a quarter of companies surveyed in 2006 in India by McKinsey & Co. said they were meeting recruiting needs. By 2010, McKinsey predicts, India will face a shortfall of 500,000 staff capable of doing work for multinationals.
Con este problema en puertas, las empresas Indias están necesitando trabajadores para las multinacionales y atrayendo mano de obra de los países vecinos y de América Latina, con lo que deberemos afrontar más rápidamente este problema. Menciono esto porque, debido a los sueldos de un programador en México en comparativa con otros países, parece ser que hace falta concientizar de la importancia del programador, el cuál es la parte más activa e importante de una empresa. Como bien dos programadores crearon Google, Microsoft y Apple. En salarios, los programadores mexicanos se encuentran en el lugar 20 de los países con mejores sueldos (tablas de salarios en México), justo debajo de España y Corea, ocupando Hong Kong y Suiza los pirmeros puestos.

Parte de la solución reside en el cambio de mentalidad del profesorado y del gobierno. Por ejemplo, en Argentina, según el periódico La Gaceta, se está diseñando un programa de becas para las carreras de TI y así poder incrementar el número de matrículas y reducir las bajas para lograr afrontar los nuevos programas económicos del país.
El flamante programa contempla la entrega de 6700 becas, con una inversión total de 52 millones de pesos para el período 2009-2013 que serán destinadas a jóvenes de todo el país que estudien en universidades nacionales.
Las becas serán destinadas a quienes estudien las carreras de Ingeniería Electrónica, Ingeniería en Telecomunicaciones, Ingeniería en Computación, Ingeniería Informática, Ingeniería en Sistemas de Información, Licenciatura en Informática, Licenciatura en Análisis de Sistemas, en Sistemas y en Ciencias de la Computación.
Cambiando la mentalidad de los empresarios (los de más alto nivel jerárquico) , la academia, y estrechando la brecha academia-sector productivo es como se logrará incrementar nuevamente las matrículas en las carreras de TI y mejorar la economía nacional con base en el conocimiento.

Para finalizar quiero recomendar y citar una
entrevista al Dr. Carlos Montes de Oca en Software Gurú:
...el dueño de una fábrica de coches sale a las 6 de la tarde, y ahí tiene su fábrica, con su valor intacto; puede venderla y recuperar su inversión. En cambio, el dueño de una fábrica de software, a las 8 de la noche que sus empleados ya se fueron a su casa, está descapitalizado. Lo único que tiene son escritorios y unas máquinas depreciadas.
No perdamos el orgullo de ser programadores, las empresas están cambiando a darnos mayor importancia porque nos necesitan. Y no pretendamos llamarnos Desarrolladores (Developers) solo porque la gente que no programa crea que es un nivel más alto.