lunes

Todos estan invitados a la fiesta ... JQuery en NB6.1

Poco se ha hablado que la versión de Netbeans 6.1 tiene soporte para la sorprendente librería de javascript jquery. JQuery es una librería muy pequeña para desarrollar de forma simple y rápida javascript, además de que cuenta con una amplia gama de plugins para hacer casi cualquier cosa. En este tutorial hablaré del soporte con que cuenta NB61 para jquery y no tanto de la librería.

La nueva versión de netbeans cuenta con soporte para javascript, prototype y jquery.
Vamos a crear un proyecto web y a la par iremos viendo las características que aporta el IDE...


1. Crea un nuevo proyecto web


  • Menú File/New Project
  • Categories: Web
  • Projects: Web application
  • Next
  • Project Name: JQuerySupport
  • Click en Next








2. En la siguiente ventana deje los valores por default y de click en Next



3. Deje en blanco la lista de frameworks



4. Click en Finish

5. Descarga la libreria de jquery desde la página oficial

6. Agrega la librería a tu proyecto, para ello:
  • Crea un folder sobre la carpeta WebPages de tu proyecto (Click derecho sobre la carpeta Web Pages/New/Other/Categories: Other/File types: Folder
  • Folder name: js
  • Pegue la librería que descargó de jquery al nuevo folder js


Note que en la paleta de componentes se pueden ver todos los miembros de la librería:




7. Agregue la definición de la librería en el archivo index.jsp


8. Aquí viene lo interesante.
JQuery utiliza la sintaxis '$()' para crear a su vez un objeto de jquery (chainability), como se muestra en la siguiente imágen, el ide nos da sugerencias de qué objeto podría ir allí dentro, un resumen, sintaxis, parámetros y documentación. ¡ Realmente bueno !




9. Sugerencia de métodos: en el punto anterior comenté que la sentencia '$()' sirve para crear un objeto jquery. Como se puede ver en la siguiente imágen, el IDE nos da sugerencia de métodos.



10. El método ready de jquery sirve para ejecutar alguna instruccion cuando el documento esté listo, es similar al evento onload del body pero a diferencia de éste, se ejecuta cuando termina de construir el arbol dom (y no hasta que pinte todos los elementos de la página)
Agregue el siguiente script:

$(document).ready(function() {
alert("CARGADO");
});

11. Prueba jquery



Top 10 de las características más espectaculares de Netbeans 6.1 en el soporte para jquery.


1. Para cada elemento, nos sugiere la compatibilidad con navegadores ....


2. Coloreado de sintaxis:



3. La sugerencia en tiempo real de los elementos de la página:



4. No deje de admirar, agregue un div dentro del body, 'Sugerencia de los elementos hijo' ...


5. ¿ Sugerencia de atributos ? Si porfavor



6. Errores javascript en tiempo de desarrollo



7. Muestra posibles errores en el código fuente (warnings)



8. Acompletado de métodos javascript.



9. Ctrl + click ->Ir a la declaración del método


10. Go to type (ctrl + o)



¡ El único IDE que tu necesitas !

Envolviendo un pequeño obsequio


En este blog crearé un plugin para Netbeans 6.1 el cual ayudará a buscar el jar a partir del nombre de una clase. A mi parecer siempre ha hecho falta un plugin que haga esto, ¿cuántas veces no te has encontrado con un ClassDefNotFoundException o un NoClassDefFoundError por que no se encuentra presente un jar dentro del proyecto ?

El objetivo de este blog es crear un campo de texto en el toolbar del ide donde podrás anotar el nombre de tu clase y al presionar enter abrirá un browser con los posibles jar que la contienen.




Pasos

1. File/New Project/
  • [Categories]: Netbeans Modules,
  • [Projects]: Module
  • Click en next


2. Aparecerá una nueva ventana para indicar la ruta y nombre del proyecto.
  • Project name: JarFinderToolbar
  • Crea el proyecto como un standalone module ya que no será parte de una suite de módulos,
  • Click en Next.



3. Aparecerá la siguiente ventana en la cual deberás indicar el paquete de tu proyecto, así como el nombre que mostrará y la localización de los archivos de recursos...
  • Code Name Base: org.jarfindertoolbar
  • Module display name: JarFinder Toolbar
  • Localizing Bundle: org/jarfindertoolbar/Bundle.properties



4. Click en Finish
5. Ahora, crearemos el JPanel que contendrá el text field para la busqueda.
  • Da clic derecho sobre el proyecto
  • New
  • Other...


6. Elije la categoría Swing GUI Forms y en File Types: JPanel Form... click en Next


7. En el campo class name escribe JarFinderPanel y en package elige el que aparece en la lista, click en Finish.


8. Diseña tu JPanel similar al siguiente ...


9. Crea el evento key typed para el text field del diseño
  • Click derecho al textField/Events/Key/Key Typed.


10. Define el método keytyped del textfield como el siguiente:

private void jTextField1KeyTyped(java.awt.event.KeyEvent evt) {
int i = evt.getKeyChar();
if (i==10){//The ENTER KEY
// we display the jarfinder url.
try{
URLDisplayer.getDefault().showURL
(new URL("http://www.jarfinder.com/?class="+jTextField1.getText()+"&submit=search"));
} catch (Exception e){
return;
}
}
}

11. Has un reformat code (Alt+Shift+F)
12. Como netbeans trabaja por medio de módulos, deberás agregar una dependencia para la clase URLDisplayer.

13. Da click derecho a tu proyecto/Properties/Del lado izquierdo elige la categoría Libraries



14. Agrega la dependencia para la clase URLDisplayer


15. Has un fix all imports (ctrl + shift + i) y da clic en ok


16. Las librerías de tu proyecto deberán quedar con las de esta ventana.



17. Lo único que resta es agregar un acción para nuestro JPanel, para ello da click derecho a tu proyecto/New/Action...
  • Indica que siempre este disponible (Always enabled)/Click en Next
  • Aparecerá una pantalla donde deberás indicar en category: Edit
  • Desactivar el check Global Menu item
  • En la sección de Global Toolbar Button elegir Edit en toolbar y Redo-Here en position
  • Click en Next


18. En la siguiente ventana deberás indicar los datos para acción.
  • Class Name: JarFinderAction
  • Display Name: JarFinder Action
  • Icon: Debes elegir uno aunque no se vaya a mostrar
  • Click en Finish


19. Declara la siguiente variable dentro del archivo JarFinderAction.java
JarFinderPanel jarFinderPanel = new JarFinderPanel();

20. Sobreescribe el método getToolbarPresenter() y retorna la variable jarFinderPanel


21. Solo basta probar tu nuevo obsequio...
Clic derecho al proyecto
Install/Reload in Development IDE: Lo ejecuta sobre el ide en el que estes trabajando actualmente.



22. Escribimos una clase sobre nuestro plugin, por ejemplo: 'com.sun.tools.javac.code.Flags' ... damos enter

23. Precioso resultado, ahora sabemos en que jar podemos encontrar la clase


24. Lo único que hace falta es distribuir el módulo como plugin para que todos puedan usarlo.
  • Click derecho al proyecto
  • Create NBM
  • Ve a la pestaña Files
  • Carpeta build
  • Veras el archivo org-jarfindertoolbar.nbm
25. El plugin lo puedes descargar de la siguiente url




'Ahora tienes el obsequio, de ti depende si lo abres'

domingo

Mi carta para los reyes magos

En estos días he estado haciendo mi carta para los reyes magos, se que falta mucho tiempo pero ya no puedo esperar más para ver mis regalos...

Queridos reyes magos, yo se que me he portado mal (muy mal :P) este año pero se que ustedes siempre comprenden que un niño como yo se emociona mucho con los regalos que le traen, prometo que si me traen mis regalos me portaré mucho mejor para el prox. año (siempre decía lo mismo :) )

Me gustaría que Netbeans 6.1 rc3 tenga las siguientes características.

1. Que el editor de java cuando escriba '<' , automáticamente ponga el cierre <> ... lo mismo que hace con los paréntesis.

2. Agregar ligas cuando se estan subiendo los archivos del svn/cvs/mercurial, que aparezcan subrayados los nombres de los archivos para poder ir a ellos.

3. Cuando le hago refactor a una propiedad, no le hace refactor a sus gets y sets.

4. Posibilidad de agregar o eliminar carpetas de un repositorio desde Netbeans.

5. Quisiera ver si le pudieran un poco de colorcito a los comentarios, seria interesante poner en cursiva los TODO, o cambiarlos a otro color para asi reconocerlos de los simples comentarios.

6. Soporte para jquery (me dijo santa clause que ya tienen soporte para prototype y eso es genial por que la sintaxis ${} es igual ... pero digo, jquery tiene mucha popularidad y todos los niños lo estan pidiendo ... que les cuesta darle soporte?)

7. Crear un plugin para jarfinder http://www.jarfinder.com/ para saber a que jar pertenece cierta clase (este lo hago yo en los proximos días para que digan que me porto bien)

8. Poner marcas del lado derecho a los comentarios con TODO, así como lo hacen como los bookmarks pero ahora con los TODO

9. Librerias con rutas relativas (oh, esto ya me lo trajeron el día de mi cumpleaños, gracias !)

10. Ahora que sus templates soportan freemarker, ¿sería mucho pedir un plugin decente? (me tuve que rebajar a pedirle prestados sus juguetes a mi vecinito juan ... sus papás le compraron el 'jboss tools freemarker ide').

11.No quiero ser grosero con ustedes pero está re gacha la interfaz para JUnit.
  • No se ve el avance de los test (en %)
  • La consola de junit no tiene la misma potencia que la consula por default(output), no se tienen ligas para ir hacia los errores
  • Es tedioso estar cambiando entre la pestaña de junit y la de output console.
  • No se puede buscar texto dentro de la consola de JUnit.
  • No se sabe cuanto tiempo tardan todos los test.

12. Cuando estoy en un editor de xml/html y creo una etiqueta de apertura, deberia crearse automáticamente la etiqueta de cierre como le pasa a mi vecinito juan con su IDE, ya he buscado como cambiar este comportamiento y parece ser que no se puede.

13. Con este regalo sí me muero de felicidad. Extender el editor gráfico de jsf para que sea capaz de soportar controles como richfaces, icefaces, tomahawk, sandbox, etc ... en lugar de solo estar atados a woodstock. Yo se que ustedes pueden, hace unos cuantos años me dieron la sorpresa con el editor matisse, ahi puedo agregar componentes de distintos componentes. No me extrañaría levantarme mañana y ver los controles colgados de la paleta.

14. Soporte para hibernate. Gracias benditos reyes magos

15. Soporte para spring. Prometo portarme bien pero no me lo quiten.

16. En el editor html pone lineas amarillas cuando un elemento es deprecated, estaría de lujo si el IDE dijera qué debo usar como nuevo elemento (' lo que debo usar en lugar del deprecated')... oh ya me enteré que las sugerencias en javascript te dicen sobre qué navegador correrá tu script ... ¡ Te luciste pinche gaspar ! (Ya se me solto la primer groseria, espero no lean esta parte :S).

17. A veces me pongo a jugar con mis proyectitos web y estan llenos de imágenes que ya no uso. ¿Me podrían avisar de alguna forma qué imáges del proyecto web no están siendo ocupadas?
¿Sería mucho pedir para los css/js y demás recursos externos ?

18. Mejorar el editor jsp, darle la misma potencia que el editor de código fuente java.

19. Soporte para jetty

20. Soporte para comentarios multilínea, esto quiere decir que cuando seleccione código fuente y presione [ctrl + c ] entonces comente de la forma /* */ y no de la forma //

21. Editor grafico para jsp y un atari.

22. Soporte para trac.

23. Mi plugin para facelets se quedo sin pilas, corría para netbeans 6.0.1 pero ha muerto en la version 6.1.

24. Hacer el IDE Online (oh, espero y no solo sean rumores y me lo traigan despues del 2009)

25. Soporte para Bugzilla

26. Por favor, cuando tenga un proyecto sobre un repositorio de versiones y elimine un paquete ... también eliminenlo de la estructura de directorios (ya que se queda el iconito del paquete vacío y por mas que lo borro no desaparece), evitenme el trabajo de ir a la pestaña Files y borrar manualmente la carpeta.

27. Al poner la primer comilla del atributo src de un tag html, mostrar un mensaje para elegir por medio de un dialogo nuestro recurso. Algo así como lo hace dreamweaver.

28. Mostrar por medio de alguna marca las ligas rotas hacia recursos inexistentes, por ejemplo si una etiqueta apunta hacia una imágen que no existe, el IDE lo podría notificar?

29. Refresh para los proyectos. En ocasiones no se actualiza el icono del proyecto, por ejemplo cuando tienes un error de compilación y se corrige ... el icono del proyecto (o del archivo) se queda con el error siendo que éste no existe. Para solucionar el problema tengo que cerrar y volver a abrir el proyecto :(

Pd. No olviden las pilas de mis juguetes

La potencia de Netbeans 6.1 para soportar una librería ... commons-logging

La mayoría de los proyectos en producción no utilizan la sentencia System.out.println(""), en lugar de ello utilizan un sistema de trazas basado en Log4J, el log predefinido de java o un wrapper como lo es Commons logging.

En este artículo explicaré cómo configurar el sistema de trazas para Netbeans 6.1 y utilizarlo de una forma muy productiva.

Pasos a seguir
1. Crear los code templates para los mensajes de consola...

1.1 Ve al menú Tools/Options/Editor/[Code templates]/New/Abbreviation=logd



1.2 En Expanded Text introduce lo siguiente:
log.debug("${cursor}");



1.3 Crea un nuevo code template llamado logdv, éste lo usaremos para imprimir en pantalla en modo debug la primer variable que encuentre hacia arriba (similar a soutv pero con un sistema de trazas.)
--------------------------------------------------
Abbreviation: logdv
Expanded text: log.debug("${EXP instanceof="" default="exp"} = " + ${EXP});
--------------------------------------------------

El resultado será algo similar a lo siguiente:



1.4 Repite el mismo proceso para los siguientes code templates
Mensajes de warning: logw, logwv
Mensajes de info: logi, logiv
Mensajes de error: loge, logev
Mensajes de fatal: logf, logfv

El resultado debería ser similar al siguiente:



2. Para utilizar el sistema de trazas en una clase, se necesita una variable que tenga una referencia a la clase, por lo tanto es necesario crear un code template para insertar la variable log como miembro de las clases:

------------------------------
Abbreviation: logv
Expanded text:
private static final Log log = LogFactory.getLog(${clase}.class);
-----------------------------


Resultado:



No todo es miel sobre hojuelas, punto en contra para Netbeans:

El IDE tiene un code hint para envolver un método que lanza excepciones con un try y catch
Para probarlo declare un método que lance cualquier excepción y mandelo a llamar desde cualquier otro método.
Después tipe [alt + enter] y verá un foco en la parte izquierda sugiriendo envolver el método con un try/catch como muestra la imágen.



Al ejecutarlo nos da el siguiente resultado:



Como te puedes dar cuenta, el sistema de trazas que esta ocupando es el que tiene por defecto el JDK y no el de commons logging, intentemos personalizarlo llendo al menú Tools/Options/[Java Code]/[HInts]/Error Fixes/Sorround with try-catch


Desafortunadamente no hay forma de indicarle al IDE que utilice el sistema de trazas de commons logging o mínimo de log4j... ¡ lastima ! ya será para la próxima versión. Aún así podrías crear un code template o una macro ;)

Lo único que resta es instalar log4j y commons logging en un nuevo proyecto.
1. Crea un nuevo proyecto java con el nombre LoggingTest




2. Expande tu proyecto y sobre source packages click derecho/New/ Other.../




3. Ve a la categoría other y elige properties file


4. En File name pon log4j



5. Introduce el siguiente código en tu nuevo archivo log4j.properties:

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=debug, stdout

6. Descarga (log4j y commons-logging)

7. Click derecho al proyecto y Clean and build.

8. Prueba el resultado:




Ahora tienes un Netbeans 6.1 completamente armado para utilizar commons-logging como wrapper para cualquier sistema de trazas, costó un poco de trabajo pero a cambio de ello serás mucho más productivo y veloz a la hora de escribir código fuente.

'A partir de ahora tu camino en Netbeans 6.1 deja huella'

Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 8)

Crea tus propios code templates.

Netbeans 6.1 cuenta con code templates para recorrer una lista, un iterador, un iterador con un while, poner un try catch, throws, public, private, String, static, if ... y un largo etc, pero no cuenta con un code template para recorrer el entry set de un mapa.
Después de un rato de trabajo he creado el siguiente code template:

1. Vaya al menú tools/Options/click en New/Abbreviation=mape

2. En expanded text introduzca lo siguiente:

for (${TYPE rightSideType default="Map.Entry"} ${ELEM newVarName default="entry"} : ${MAP mapeable instanceof="java.util.Map" default="entrySet"}.entrySet()) {
${TYPES rightSideType default="Object"} ${KEY newVarName default="key"} = ${TYPE_CAST cast default="" editable=false}${ELEM}.getKey();
${TYPES rightSideType default="Object"} ${VALUE newVarName default="value"} = ${TYPE_CAST cast default="" editable=false}${ELEM}.getValue();
${selection}${cursor}
}

3. Introduzca la siguiente instrucción:



En un artículo anterior creamos una macro que validaba si un objeto era nulo, ahora vamos a crear el code template para validar si un objeto es nulo, sigue los pasos anteriores y pon en abbreviation: ifnn y en expanded text:
if (${EXP instanceof="Object"} != null) { ${selection}${cursor} }

Prueba tu nuevo code template:



'Dame la llave y yo elijo la puerta'

Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 7)

Asignar el valor de retorno a una nueva variable

Desde las primeras versiones de Netbeans tuve la inquietud de los code templates, shortcuts, code hints y macros, una de las cosas que me decepcionaba es que el editor no tenia forma de generar el código para cachar el retorno de un método dentro de una variable.
Me explico con un ejemplo, imagina el siguiente método:

public static int metodoRegresaEntero() { return 1;}

Ahora imagina que dentro del método main mandas a llamar al método metodoRegresaEntero();
public static void main(String args[]) {
metodoRegresaEntero();
}

Siempre busqué una forma para que el editor hiciera lo siguiente:
public static void main(String args[]) {
int i = metodoRegresaEntero();
}

Mi sueño se ha hecho realidad con Netbeans 6.1 y me siento en las nubes, ahora lo puedes hacer de una forma muy simple...

public static void main(String args[]) {

/* Tipea [alt + enter] y aparecerá un pequeño foco del lado izquierdo, elige assign return value to new variable y por arte de magia el editor inferirá el tipo de dato de retorno y lo pondrá por ti*/

int metodoRegresaEntero = metodoRegresaEntero();
}

El editor es capaz de inferir los datos hasta de generics, presta atención a la siguente imágen en la cual toda la parte subrayada fué generada automaticamente por el editor siguiendo los pasos descritos anteriormente:




'Debes voltear atrás para conocer a tu oponente'

Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 6)

Este artículo va dedicado al archi ultra reconocido semicolon (;)

¿Cuántos lenguajes de programación han planteado la posibilidad de no repetir el símbolo (;) al final de casi todas las sentencias?
Esta característica no va a cambiar nunca en c, c++, java. Lo que sí puedes cambiar es tu IDE, Netbeans 6.1 cuenta con un poderoso editor de código que te hace la vida más fácil.

Para entender mejor esta característica, hablemos de la forma tradicional de insertar el semicolon al final de las sentencias:

1. Inserta una sentencia de código, por ejemplo
String s = " | "
2. Debes moverte hacia la derecha un par de casillas
3. Tipear ;

Lo veo simple, ¿cómo hacerlo más simple?

Ve al menú Tools/Options/[Key map]/Expande la carpeta other/Busca la acción Complete Line/

Por defecto el shortcut es [ctrl+semicolon] pero en nuestros teclados si queremos el ';' deberiamos presionar [ctrl + shift + ;], al tener [shift] dentro del shortcut cambia y por lo tanto no funciona. Consecuencia de esto los usuarios hispanos de netbeans por 'defecto' no podemos hacer uso de esta característica :(.
Para habilitarla solo cambia el shortcut de la acción, yo he puesto [ctrl + ñ]

Ahora que hemos cambiado el shortcut podemos hacer uso de él.
1. Inserta por ejemplo la siguiente instrucción.
String s = " | "
2. Tipea [ctrl + ñ], automaticamente se pondrá un ';' al final de la sentencia sin tener que recorrerte todo hasta la derecha.

Lo mismo puedes hacer para la acción "Complete Line and Create New Line", asignale el shortcut
[ctrl + shift + ñ], ahora aparte de agregar el ';' al final de la sentencia, se insertará un newline al final y empezaras en la siguiente línea.
Nota que esta característica no solo aplica a sentencias simples, en sentencias complicadas puede ser de gran ayuda...

class Nb61 {
public static void main(String[] args) {System.out.println("Duke in Netbeans 6.1 blogging contest");}
static{}
static{}
static{}
static{}
static{}
static{} ;;;
static{} ;;;;;
static{} ;;;;;;;
static{} ;;;;;;;;;
static{} ;;;;;;;;;;;
static{} ;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;; ;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;;;;;
static{} ;;;;; ;;;;;;;;;;;;;;; ;;;
static{} ;;;; ;;;;;;;;;;;;;;; ;;;
static{} ;;; ;;;;;;;;;;;;;;;;; ;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;; ;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;; ;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;; ;;;
static{} ;;;;;;;;;;;;;;;;;;; ;; ;;;
static{} ;; ;;;;;;;;;;;;; ;; ;;;
static{} ;; ;;;;;; ;;;; ;;;
static{} ;;; ;;
static{} ;;; ;;
static{} ;;; ;;;
static{} ;;; ;;
static{} ;;; ;;
static{} ;;; ;;;
static{} ;; ;;
static{} ;; ;;;
static{} ;; ;;
static{} ;; ;;
static{} ;;; ;;
static{} ;;; ;;
static{} ;; ;;;
static{} ;; ;;
static{} ; ;;
static{} ;; ;;
static{} ;;; ;;;
static{} ;;; ;;;;;;;; ;;;
static{} ;;; ;;;;;;;;;;;;;;; ;;
static{} ;; ;;;;; ;;;; ;;
static{} ;; ;;;; ;;; ;;
static{} ;; ;;;; ;;; ;;;
static{} ;; ;;; ;;; ;;
static{} ;; ;;;; ;;; ;;
static{} ;;;;;;;;; ;;; ;;
static{} ;;;; ;;;;;;;;;
static{} ;;;;;
static{}
static{}
static{}
}


'Duke ha aprendido a utilizar el semicolon en Netbeans 6.1, ahora corre más rápido que nunca... ya tiene tenis (;)-(;) y además compila'

Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 5)

La versión 6.1 de Netbeans cuenta con un editor mucho más mejorado que nunca, prueba de ello es el nuevo coloreado de sintaxis.
Gracias a este nuevo coloreado se puede distinguir entre variables estáticas (aparecen en cursiva), variables locales o variables a nivel de clase, atributos deprecated (los cuales aparecen subrayados).



Además de que cuenta con una interesante característica, si tienes un método con múltiples retornos y pones el puntero en el tipo de dato de retorno del método, puedes saber todas las sentencias de salida.




También puedes seleccionar una variable y conocer todas las coincidencias en tiempo real.



Lo mismo sucede con los métodos.




'Aprende a correr de noche, ilumina las salidas'

Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 4)

Desde la versión 6 tienes la posibilidad de reemplazar las variables de tu código fuente y ver los cambios en tiempo real, para conseguir este comportamiento posicionate sobre una variable de la clase, tipea [ctrl + r] y escribe ... verás el cambio 'al aire'.





'correr más rápido que el viento implica conocer los elementos en el aire'.

Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 3)

En esta ocasion hablare sobre los shortcuts osea los atajos del teclado que trae consigo el IDE para realizar las tareas mas comunes desde el teclado. Hablaremos especificamente de los shortcuts que trae consigo el editor y un top ten de los que más he utilizado.

Para modificar o agregar un shortcut, puedes ir al menú Tools/Options/[Key Map]

La lista etiquetada como profile sirve para cambiar el perfil de keymap, esto es muy útil para programadores que vienen de eclipse o de emacs, como ya saben todos los atajos fácilmente pueden cambiar el perfil y reutilizar los atajos que ya conocian.

Un par de reclamos ....

¿ Qué hay de los programadores que vienen de IntelliJ IDEA ?

¿ Qué hay de los que conocen los shortcuts en JBuilder y quieren migrar a Netbeans 6.1 ?

¿ Por qué se acordaron del viejo emacs y no de mi querido vi :'( ?
No todo esta perdido :), existe un plugin https://sourceforge.net/project/showfiles.php?group_id=3653 )


[Shortcuts Top 10]

1. Duplicar una línea [ctrl + shift + abajo], [ctrl + shift + arriba]
Tradicionalmente ¿ cómo pasas la línea superior a la línea actual ?

Cuando programaba con eclipse ...
Movimiento 1. Ir a la línea que quieres copiar
Movimiento 2. Apretaba [shift]
Movimiento 3. Apretaba [fin]
Movimiento 4. Apretaba [ctrl + c]
Movimiento 5. Apretaba [fin]
... empiezo a aburrirme :P
Movimiento 6. Apretaba [Enter]
Movimiento 7. Apretaba [ctrl + v]
... que bueno que termine, empezaba a darme dolor de dedos.
Movimiento 8. Frotar mis dedos

Ahora con Netbeans 6.1 ...
Movimiento 1. Ir a la línea que quieres copiar
Movimiento 2. Ctrl + Shift + abajo
Movimiento 3. Poner una carita de felicidad :)




2. Formatear el código fuente [alt + shift + f]
Para acomodar todo tu código fuente presiona [alt + shift + f], la característica más sobresaliente del reformat code de Netbeans 6.1 es la capacidad de eliminar los espacios en blanco que se encuentran a los costados de las sentencias. Por ejemplo si tienes espacios en blanco después de un System.out.println("");____,
al presionar [alt + shift + f] el IDE eliminara esos espacios por ti.

3. Fix all imports [ctrl + shift + i]
Fix all imports es una característica muy útil para reparar todos los imports que no se encuentran en el código fuente. Imagina que copias un trozo de código fuente de algun sitio pero no tienes a la mano los imports. Al presionar [ctrl + shift + i] aparecerá un dialogo para corregir todos los imports faltantes.



4. Insert code [alt + ins]
Esta nueva versión de Netbeans cuenta con una herramienta para crear constructores, sobreescribir métodos, agregar propiedaes, crear get/set de tus propiedades, crear el método hashCode(), equals() ...
Para mostrar el cuadro de diálogo presiona [alt + ins] y se feliz.



5. Seleccionar porciones de código, caminar[alt + shift + .], retroceder [alt + shift + ,]
En ocaciones es múy útil seleccionar el código fuente por porciones, imagina que necesitas seleccionar todo el for en el que estás trabajando pero es muy grande, lo que debes hacer es ir hacia arriba y buscar donde empieza el for, después ir abajo y buscar la llave de cierre del for.
Lo mismo sucede con los métodos, con los if, while, switch, etc.
Netbeans pone a tu disposición un shortcut para seleccionar porciones de código, si estas dentro de ese enorme for, solo tipea [alt + shift + .] y verás seleccionado todo el cuerpo del for, si lo vuelves a tipear verás seleccionado el for completo.

De esta forma puedes seleccionar mas y mas porciones de código hasta llegar a seleccionar todo el código fuente de tu clase.



6. Borrar la línea actual [ctrl + e]
Este es uno de mis preferidos, solo presiona [ctrl + e] y se borrará la línea en la que te encuentras actualmente

7. Agregar o eliminar comentarios [ctrl + shift + c]
Con Netbeans 6.1 tienes la posibilidad de comentar porciones de código fuente, lo único que debes hacer es posicionarte sobre la línea o seleccionar una porción de código fuente y tipear el comando [ctrl + shift + c], lo mismo debes hacer para descomentar.




8. Cerrar la ventana actual [ctrl + w]
Para cerrar la ventana actual, presione [ctrl + w]

9. Maximizar la ventana actual [shift + esc]
Existen varias formas de ampliar el área de trabajo, uno de los más útiles es con el shortcut [shift + esc], el cual maximiza la ventana actual.


Otra posibilidad es utilizando el modo fullscreen con [ctrl + alt + enter]

Y por último, puedes dar click derecho sobre la pestaña de la ventana de trabajo y elegir undock window lo cuál hará que la ventana salga del entorno como si de un programa distinto se tratara.



10. Cambiar de ventana [ctrl + tab]
Puedes cambiar entre ventanas con el simple comando [ctrl + tab]




'La luz es más rápida que el viento, pero si conoces los atajos del laberinto tu serás el primero ...'

sábado

Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 2)

Una de las características por default que hacen falta a Netbeans 6.1 rc2 (hasta hoy) es la posibilidad de tener un code template que valide si un objeto es nulo.

Sería fantástico tipear por ejemplo [ifnn + tab] y que buscara el primer objeto hacia arriba e insertara el siguiente código:


Desafortunadamente no se cuenta con el code template por default, podriamos crear un code template para agregar la característica, pero para ilustrar un nuevo tema casi no documentado, haremos uso de las macros...



- Start Macro -
Las macros, otra de las características de Netbeans que permite un desarrollo más veloz.
Es cierto que no son una característica nueva de Netbeans 6.1 y existen desde versiones anteriores pero quiero hablar sobre este tema ya que casi nadie habla de ellas y es una pieza fundamental en el rompecabezas de una serie de artículos llamados 'Corre más rápido que el viento con Netbeans 6.1', los cuales he creado con la finalidad de que los usuarios de otros entornos se sientan interesados por Netbeans 6.1

Una macro es un conjunto de acciones que pueden ser grabadas para reproducirlas posteriormente.
Para iniciar la grabación de una macro vaya al menú Edit/Start macro recording
Para detener la grabación de una macro vaya al menú Edit/Stop macro recording

Pasos para crear una macro que valide si un objeto es nulo
1. De acuerdo a la imagen anterior, posicionate sobre la variable obj y seleccionala.
2. Inicia la grabación de la macro
3. tipea [ctrl + c]
4. tipea [fin]
5. tipea [enter]
6. tipea if ( [ctrl + v] ) { [enter]}
7. Deten la grabación de la macro
8. Aparece un dialogo para poner el nombre de la macro, llamemosle if-not-null
9. Aparecerá un dialogo similar al siguiente:

Al final de la grabación debería quedarte un Macro Code como este:
copy-to-clipboard caret-end-line insert-break "if (" paste-from-clipboard " != null" caret-forward " {" insert-break

10. Pon un shortcut para que se ejecute la macro, yo he puesto (ctrl + alt + N)

11. Prueba tu macro, posicionate sobre una variable y seleccionala ... tipea (ctrl + alt + N)







Resultado:









No mas validaciones manuales para saber si un objeto es nulo

Ahora que sabes como crear una macro para validar si un objeto es nulo, ya sabras que puedes crear cualquier tipo de macro para evitar las tareas repetitivas.

'Dime como hacerlo y lo haré paso a paso, dame alas y volaré.'

- Stop macro -

Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1

Este blog lo he creado con la intención de participar en el concurso Netbeans IDE 6.1 Beta blogging contest y aportar un granito de arena a la comunidad de desarrolladores de Netbeans hispanos.

Quiero inaugurar con el primer artículo de una serie llamada 'Corre más rápido que el viento y llega antes que nadie con Netbeans 6.1', la serie la estoy creado con la finalidad de que los usuarios de otros entornos se sientan atraidos por Netbeans 6.1 ya que hablo sobre un tema poco conocido. Cómo desarrollar aplicaciones de una forma increiblemente veloz desde Netbeans 6.1 es el tema central ya que ésta característica fué una de las decisivas para que yo migrara a la plataforma y terminara amandola.

¿Cuántos programadores se preocupan en medir el desempeño de sus aplicaciones en milisegundos (que mejor si lo haces desde netbeans profiler) ?
Para mi, la respuesta es pocos...

¿Cuántos programadores se preocupan en medir su rapidez escribiendo código fuente?
Para mi, la respuesta es casi nadie

¿Cuántas veces al día repites la sentencia 'System.out.println("")' para imprimir una variable en tu código fuente ?
¿ Cuántas veces al día escribes el tedioso for(int i=0; i < ...), cuantas veces recorres un iterator ?

¿ Cuántos milisengundos tardas en escribir código fuente ?


¿ Se podría considerar este tema como la pieza que hacia falta en el rompecabezas de la programación ágil ?

Code templates
Los code templates es una característica de Netbeans que sirve para insertar pedazos de código fuente por medio de abreviaciones.
Una de las características más importantes es que una vez insertados se pueden modificar de acuerdo a la declaración del code template.

Por ejemplo:
Existe un code template para crear nuevos objetos el cual se ejecuta con el comando [newo + tab]
Al tipear [newo + tab] se insertará:





Una vez insertado el code template, se puede modificar ya que el cursor queda sobre la palabra [Object], si al insertarlo tipea String se modificará de la siguiente forma:

String obj = new String();

Modificar los code templates
Usted puede modificar o crear nuevos code templates llendo a Tools/Options/[Code templates]


















Tenga en cuenta que no solo existen code templates para java, usted puede cambiar el lenguaje desde la lista etiquetada como languages:

Top 10 de los code templates:

1. Imprimir en pantalla [sout + tab]
/* Tipea [sout + tab] Resultado ... */
System.out.println("");

2. Imprimir una variable en pantalla [soutv + tab]
Busca hacia arriba la primer variable y la imprime.
Ejemplo:
int variableLargaDeTipoEntero = 9;
/* Tipea [soutv + tab] Resultado ... */
System.out.println("variableLargaDeTipoEntero = " + variableLargaDeTipoEntero);

3. Recorrer automaticamente un array [fori + tab]
Busca hacia arriba el primer array y lo recorre.
Ejemplo:



4. Recorrer automaticamente una lista por medio de su iterator [forc + tab]
Busca hacia arriba la primera coleccion y la recorre
List listaStrings = new ArrayList();
/* Tipea [forc + tab] Resultado ... */
for (Iterator it = listaStrings.iterator(); it.hasNext();) {
String string = it.next();
}

5. Recorrer automaticamente una lista por medio de foreach [fore + tab]
List listaStrings = new ArrayList();
/* Tipea [fore + tab] Resultado ... */
for (String string : listaStrings) {
}

6. Recorrer automaticamente una lista por medio de su indice [forl + tab]



7. Crear el método main [psvm + tab]
/* Tipea [psvm + tab] Resultado ... */
public static void main(String[] args) {
}

8. Poner la palabra reservada public [pu + tab]
/* Tipea [pu + tab] Resultado ... */
public

9. Poner la palabra reservada private [pr + tab]
/* Tipea [pr + tab] Resultado ... */
private

10.Poner la palabra reservada String [St + tab]
/* Tipea [St + tab] Resultado ... */
String

En este artículo traté el tema de code templates pero aquí no termina el aprendizaje de la programacion veloz en Netbeans 6.1, en próximos blogs mostraré cómo puedes crear tus propios code templates, utilizar macros, hints y shortcuts.

'Ahora me arrepiento por tanto tiempo perdido en la obscuridad de un eclipse'