miércoles, marzo 21, 2007

Siguiendo con Java

Acabo de leer un "interesante" articulo llamado Why I Am Not A Java Programmer

Hay que aceptar que hay cosas charras y que comparto como:

``Hello World'' should be one statement

There's more to life than OO

Bureaucratic privacy rules

No dynamic method generation


y blablabla.

Pero bueno, al final se habla de algo bien interesante. Una cita de Stroustrup que dice lo siguiente:

"The connection between the language in which we think/program and the
problems and solutions we can imagine is very close. For this reason
restricting language features with the intent of eliminating
programmer errors is at best dangerous."

Yo realmente siempre he creído en algo. Si bien es cierto que Java es un lenguaje con muchas restricciones, y que la forma de pensar es influida por las herramientas que usamos para programar, creo que diseñar soluciones con espacio de pensamiento reducido es también un reto intelectual. A veces la falta de recursos permite explotar el ingenio que solo surge ante la escasez.

Creo también que por mas multiparadigma que sea un lenguaje de programación, no hay mejor forma de ampliar los horizontes del pensamiento, que conocer asi sea superficialmente cuantos lenguajes de programación se atraviesen. A mi me sucedió esto cuando conocí los lenguajes funcionales, Haskell para ser exactos. Es difícil en un principio manejar la recursión, pero una vez dominada resulta muy útil...

Como siempre queda un texto sin conclusión ni nada.

lunes, marzo 19, 2007

Desatrasandome de java 1.4

Bueno, después de mucho tiempo, por fin me dio por programar otra vez en java. Y esta vez me puse a leer sobre las cositas nuevas en Java 1.5 (ya se que estamos en la 1.6, pero en la 1.6 no vi cambios que uno realmente utilice).

Los cambios son básicamente los siguientes:

Annotations.
Es básicamente un metalenguaje, es decir, viene siendo algo parecido al preprocesador de C.

Genéricos:
No mas Casts! ya las colecciones pueden usar algo parecido a los templates de c++.

Ej:

Vector <Integer >= new Vector<Integer>();

AutoBoxing Auto-Unboxing: Una de las cosas que le critico a java es no poder hacer 27.metodo_de_la_clase_Integer. Pues bueno. Pese a que este nuevo feature no lo permite hacer, facilita un poco las cosas para trabajar con la dualidad objeto-primitiva

Ej (Todos son sacados de Java5 in a nutshell):

Antes:
ArrayList<Integer> list = new ArrayList<integer>();
list.add(0, new Integer(42));
int total = (list.get(0)).intValue();


Ahora:
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(0, 42);
int total = list.get(0);

Iteradores: todavía se esta lejos de poder hacer un array.each{blabablabla} pero ya facilitan las cosas

Ej:
ArrayList<Integer> list = new ArrayList<Integer>();
for (Integer i : list) { ... }

(aqui particularmente la sintaxis me parece fea... pero desde que sirva :S

La parte de enumeraciones: Nunca he utilizado enumeraciones, se me olvidan que existen. pero bueno, a quien pueda interesar:

public enum semaforo{rojo,verde,amarillo}

Imports estáticos: A veces es cansón hacer la de java.util.paquete.Clase.constante, Pues bueno, puede uno hacer los imports estáticos:

Ej:

import static java.awt.BorderLayout.*;
...
getContentPane().add(new JPanel(), CENTER);

Salida con formato: Básicamente el printf:

System.out.printf("name count%n");
System.out.printf("%s %5d%n", user,total);

Entrada con formato: Entrada estandar siempre ha sido una mierd* en java... ya es menos mierd*.

Scanner s= new Scanner(System.in);
String param= s.next();
int value=s.nextInt();
s.close();


Y... para terminar! args variables!

void argtest(Object ... args) {
for (int i=0;i < args.length; i++) {
}
}

argtest("test", "data");

Si ya se, no es la gran maravilla pero algo es mejor que nada. A mi la verdad el desarrollo de java en estrategia bola de nieve no me gusta. Al final nadie es capaz de lidiar con una sintaxis tan llena de casos especiales, pero bueno.