Personal Website

My Web: MindEchoes.com

Saturday, October 24, 2009

LeeLoo

Esta Gata siempre pareciera querer hacer todo lo que hacen los demas... pero tomar mate??!!
El mate estaba solo en la mesa y LeeLoo aprovecho...

Thursday, October 22, 2009

nmap en Matrix Reloaded

Para dejar en evidencia que LINUX ES LO MEJOR... aca Trinity lo usa para hackear la Matrix:


(Trinity utiliza Nmap para buscar puertos abiertos de una máquina)


Y ahora mi maquina jeje:

Todo lo que Hollywood me enseño sobre la PC

1. Los hackers siempre se visten raro. Además, siempre tienen cara de hacker, excepto cuando son mujeres. En ese caso, parecen ex-modelos. Hollywood es tan riguroso en este sentido que puede uno fácilmente establecer algunos silogismos. Por ejemplo, en The Matrix , Neo –Keanu Reeves– no tiene cara de hacker, pero se viste raro. Por lo tanto, es un hacker. Trinity se viste raro y además la actriz empezó como modelo –Carrie-Ann Moss–. ¡Super hacker! Acid Burn, en la película Hackers de 1995, se viste muy raro y además Angelina Jolie también empezó como modelo. ¡Hacker diplomada! (Me apuntan aquí que Hugh Jackman no cumple estos requisitos, en Swordfish . Error, el personaje tiene cara de mutante, o de otro modo jamás habría participado en X-Men .)

2. Los escritorios de los hackers están muy desordenados y con no menos de dos pantallas, usualmente LCD de 32 pulgadas widescreen.

3. Los hackers sólo comen pizza, y lo hacen mientras hackean algo.

4. Los nerds siempre usan anteojos, si son hombres, y en el momento de mayor tensión, estas gafas se les rompen. Si se trata de una mujer, será bella pero torpe, como Sandra Bullock en La Red . En ambos casos, tienen gravísimas dificultades para encontrar pareja.

5. Una persona puede leer el diario sólo con la luz que emite un monitor. Además, esta luz es constante, aún cuando esta persona esté moviendo ventanas y abriendo y cerrando programas.

6. Las pantallas de los hackers están repletas de ventanas, y en varias de ellas se listan cosas incomprensibles todo el tiempo.

7. Windows no es usado ni por empresas ni por organismos del Estado ni por hackers. En las películas, sólo se ven interfaces que no corresponden a ningún sistema operativo conocido. (Excepción honrosa, en The Matrix Reloaded , Trinity usa una notebook que está corriendo Linux y un programa llamado NMap .)

8. Toda contraseña es fácil de adivinar. Basta crujir los dedos, entrecerrar los ojos y pensar un poco. En ocasiones, hay que pensar muchísimo, los involucrados realmente experimentan un castigo físico extremo y teclean un montón de código (al parecer, C). Nunca usan un programa para quebrar contraseñas.

8bis. Si el punto anterior no es enteramente cierto, entonces podría significar que las computadoras modernas sólo admiten un número limitado de posibles contraseñas. En otras palabras, no hay mayor diferencia entre una estación de trabajo de última generación y un cajero automático.

9. Además, los sistemas de seguridad aceptan que un hacker ingrese 350.000 claves equivocadas sin bloquearse. ¡Pan comido!

9bis. Eso sí, cada vez que ingresa una contraseña inválida, recibe el mensaje de “Access Denied”, nunca otro.

10. Toda la superficie del planeta tiene conexiones Wi-Fi de alta velocidad con Internet y todos los organismos del mundo tienen sus servidores conectados a la gran Red. Así, el héroe no tiene problema de ingresar a una base de datos sensible de la Agencia Nacional de Seguridad de los Estados Unidos a las 4 de la mañana desde un auto estacionado junto a un puente del siglo XI sobre el río Garonne, en Toulouse, Francia.

11. A pesar de esto, los hackers invariablemente optan por ir a una casilla telefónica para invadir un sistema.

12. Borrar de manera segura todo un disco duro de 250 GB cuando están llegando las fuerzas policiales a la casa de un hacker (o del protagonista, como en Blade ) toma sólo 5 segundos. En cambio, copiar un pequeño archivo de texto con los resúmenes de las cuentas bancarias secretas de un traficante de drogas requiere tres exasperantes minutos. El indicador de progreso de esta lenta operación aparece en pantalla con música de suspenso.

12 bis. Hasta hace un tiempo, los robos de datos se hacían en antediluvianos diskettes. Ahora, se usan CD pero, eso sí, se los emplea como diskettes. No hace falta escribir el Lead-in ni el Lead-out , formatearlos, inicializarlos o todas esas tonterías que sólo necesitan realizar los que no son hackers.

13. Las Mac poseen aproximadamente el 90% del mercado de las computadoras hogareñas.

13 bis. No obstante esto, el mouse no existe. En las películas todo se hace tecleando frenéticamente, en general sin mirar lo que se escribe y sudando copiosamente.

14. Un disparo de arma de fuego en el gabinete de una computadora hace que el monitor explote y que el disco rígido se vuelva inservible. Vaya puntería.

15. Inversamente, una notebook destruida en una violenta explosión todavía conserva sus chips internos en perfectas condiciones y un experto puede acceder a los datos del fabricante sin problema.

16. Las notebooks jamás se quedan sin batería.

17. Los celulares, siempre.

18. En muchos lugares del mundo uno puede sacarle el celular a un desconocido que está hablando en la calle sin que lo muelan a uno a palos. Alcanza con decir: “¡Necesito su teléfono, amigo!”

19. Las transferencias de dinero entre cuentas bancarias se hacen en un suspiro y no hay límite. Por ejemplo, es posible traspasar 50 millones de dólares desde una cuenta en los Estados Unidos a otra en las Islas Caimán sin que a nadie se le ocurra preguntar nada.

20. Cuando una computadora hace zoom sobre una foto para ampliar un detalle, ocurren dos cosas. Primero, hace ruido de zoom (un chirrido como de cámara fotográfica); segundo, la resolución aumenta conforme a la ampliación sin perder nada de detalle.

21. El programa más avanzado de tratamiento de imágenes suele ser el Paint .

22. Las computadoras pueden encenderse apretando un interruptor en el monitor. La opción, que he meditado largamente, es que la máquina en realidad esté encendida y que el hacker sólo encienda la pantalla para a) ahorrar energía y proteger el medio ambiente o b) porque no sabe cómo activar DPMS.

23. Todos los sistemas operativos muestran una bomba en la pantalla cuando se cuelgan.

24. Los virus causan la aparición de calaveras en las pantallas de las máquinas infectadas.

25. Los hackers “malos” hablan por teléfono usando un auricular Bluetooth. Los hackers “buenos” hacen videoconferencia.

[Visto en: lanacion]

Tuesday, October 20, 2009

Reflexion en Java

Tanto andar programando QuickDB, no podia faltar un Post explicando como jugar un poco con la API de reflection en Java.

Reflexión es un componente de la API Java la cual permite al código Java examinar y "reflexionar" sobre los componentes Java en tiempo de ejecución y para usar miembros reflexionados.
La Reflexión se usa para instanciar clases e invocar métodos usando sus nombres, un concepto que permite la programación dinámica. Clases, interfaces, métodos, campos, y constructores pueden ser todos descubiertos y usados en tiempo de ejecución.

Vamos al Codigo!!
En la API Java de Reflexión tenemos 2 clases muy importantes:
  • Field
  • Method
"Class" no es parte de esta API, pero es de vital importancia igual!

Estas por lo menos son de las que mas se suelen utilizar para interactuar con objetos a traves de reflexión, aunque si nos ponemos a ver, muchas de las cosas que podemos obtener de un objeto del tipo Class son muy interesantes...

De forma rapida como podemos ver estas cosas??
Creamos una instancia de una clase cualquier y hacemos:

Para ordernar un poco lo que sigue, los ejemplos a continuacion van a consistir en:
  1. Imprimir el nombre de los atributos de una Clase
  2. Leer el valor de los atributos utilizando los Metodos Getters.
  3. Creando una instancia de un Objeto (combinado con lectura de atributo para caso que retorna NULL)
  4. Escribiendo datos en un objeto utilizando los Metodos Setters.
  5. Como se pueden leer atributos heredados de una Clase Padre.

Comencemos:
1)
Tomemos como ejemplo la siguiente Clase sobre la que se aplicaran los siguientes ejemplos:

public class Entidad {

private int id;
private String nombre;
private String otroAtributo;
private OtraClase otra;

public Entidad(){}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

public String getOtroAtributo() {
return otroAtributo;
}

public void setOtroAtributo(String otroAtributo) {
this.otroAtributo = otroAtributo;
}

public OtraClase getOtra() {
return otra;
}

public void setOtra(OtraClase otra) {
this.otra = otra;
}

}

Como se puede ver es una simple Clase con 4 Atributos (uno de ellos una referencia a otra Clase) y los respectivos metodos Getters y Setters para sus atributos.

Ahora queremos hacer un Ciclo cuyo fragmento de código puede ser parte del Programa que contiene a esta Clase o ajeno a esta mediante el cual podamos recorrer los atributos de la Clase e ir imprimiendolos por consola.
Esta es una de las Caracteristicas fundamentales de Reflexión, justamente el hecho de no tener la obligación de "conocer" a la Clase o el Objeto...
Los ejemplos del tipo "como setear un valor a un atributo" uno podria preguntarse: "para que quiero utilizar Reflexión cuando puedo hacer un [objeto.setAtributo(valor)]??"......
Es cierto... pero supongamos que estamos haciendo una Libreria que debe ser capaz de trabajar con todo tipo de objetos, tanto los creados por nosotros, como otras entidades de software que hagan uso de la misma funcionalidad, en ese caso es probable que gran cantidad de los objetos que interactuen con nuestra Libreria sean ajenos a nuestro conocimiento y podamos necesitar de la ayuda de Reflexión para este trabajo... cuando se entienden las caracteristicas y los usos que se le puede dar a esta API se pueden desarrollar cosas muy interesantes.

Imprimir el Nombre de los Atributos de una Clase:

import java.lang.reflect.Field;

public class App
{
public static void main( String[] args )
{

//Obtener Array con los Fields(Campos/Atributos)
//de la Clase
Field[] fields = Entidad.class.getDeclaredFields();

//Recorrer cada uno de los Campos en el Array
//e imprimir su Nombre
for(Field f : fields){
System.out.println(f.getName());
}

}
}
La Clase Field represta cada Campo o Atributo de la Clase.
El metodo "getDeclaredFields()" como se puede ver nos devuelve un Array con los respectivos Atributos de esa Clase, esta opción incluye los atributos public, protected, default (package) access, private, pero excluye los campos heredados.


2)
Supongamos ahora que queremos leer el Valor de estos atributos utilizando el Metodo "Get" de cada uno... y no sabemos cual es el nombre de estos metodos, pero asumimos que siguen la convencion de: "getNombre" donde cada palabra despues de "get" se escribe con la primera letra en mayuscula.
(esta idea de como realizar esta lectura la saque del Blog de Pablo Frias)

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class App
{
public static void main( String[] args )
{

//Obtener Array con los Fields(Campos/Atributos)
//de la Clase
OtraClase otra = new OtraClase();
Entidad entidad = new Entidad(5, "Diego", "Gato", otra);
Field[] fields = entidad.getClass().getDeclaredFields();

//Recorrer cada uno de los Campos en el Array
//e imprimir el Valor de cada Campo
for(Field f : fields){
//Obtener nombre de Atributo
String field = f.getName();

try{
//Obtener nombre de Metodo Getter
Method getter = entidad.getClass().getMethod("get" +
String.valueOf(field.charAt(0)).toUpperCase() +
field.substring(1));

//Llamo al Metodo especificado de este Objeto
//con un array con los respectivos Parametros
//En este caso al ser un Getter no recibe parametros
Object value = getter.invoke(entidad, new Object[0]);

System.out.println(value);
}catch(Exception ex){
ex.printStackTrace();
}
}

}
}
Como se puede ver en el Codigo, se crea un Objeto del tipo "Method" con el nombre del Metodo al que se lo intentara relacionar, y luego sobre ese objeto Metodo creado se invoca su operación asignada... en este caso obtener el valor del respectivo atributo.

3)
Ahora supongamos que en lugar de imprimir el Valor de cada Atributo, queremos imprimir el Tipo de dato que es.
Si en el caso de la Clase con la que estamos trabajando (Entidad), no se le setteara un valor para la referencia a la Clase "OtraClase", esta tendria por defecto NULL, y al intentar imprimir tanto su Valor como su Tipo de Dato nos arrojaria una excepción, para este podemos utilizar un metodo de la Clase "Method" que nos permite obtener el Tipo de Dato que devuelve ese Metodo, y llegado el caso de ser necesario para algun fin... en base a ese tipo de dato que nos devuelve, podriamos crear una instancia vacia de esa clase:

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class App
{
public static void main( String[] args )
{
Entidad entidad = new Entidad(5, "Diego", "Gato", null);
Field[] fields = entidad.getClass().getDeclaredFields();

for(Field f : fields){
String field = f.getName();

try{
Method getter = entidad.getClass().getMethod("get" +
String.valueOf(field.charAt(0)).toUpperCase() +
field.substring(1));

Object value = getter.invoke(entidad, new Object[0]);
//Si el objeto obtenido es NULL, intenta crear una
//instancia vacia de ese tipo de objeto.
if(value == null){
value = App.emptyInstance(value.getClass().getName());
}


}catch(Exception ex){
ex.printStackTrace();
}
}

}

public static Object emptyInstance(String type) {
//Este metodo crea una instancia de Class con el tipo
//de dato obtenido por parametro, y luego itera sobre
//los Constructores de esta Clase para intentar
//crear una Instancia en base a un Constructor Vacio
Object obj = null;
try {
Class clazz = Class.forName(type);

for (java.lang.reflect.Constructor con : clazz.getConstructors()) {
if (con.getParameterTypes().length == 0) {
obj = con.newInstance();
break;
}
}
} catch (Exception e) {
return null;
}

return obj;
}
}

4)

import java.lang.reflect.Method;
import java.util.ArrayList;

public class App
{
public static void main( String[] args )
{
Entidad entidad = new Entidad(5, "Diego", "Gato", null);
Field[] fields = entidad.getClass().getDeclaredFields();
String field = fields[1].getName();

try{
String setterName = "set" +
String.valueOf(field.charAt(0)).toUpperCase() +
field.substring(1);

//Crea Metodo Setter en base al Nombre establecido
//arriba siguiendo la misma convencio que para Get
Method setter = entidad.getClass().
getMethod(setterName, fields[1].getType());

//Crea un Array con los Parametros que se le pasaran
//al Metodo al ser invocado, la funcion se encarga
//de los casteos correspondientes.
ArrayList results = new ArrayList();
results.add("Otro Nombre!!");

//se invoca al Metodo del respectivo Objeto
//y pasando un Array con los Parametros
setter.invoke(entidad, new Object[]{results});


}catch(Exception ex){
ex.printStackTrace();
}

}

}
No mucho mas que explicar, se puede ver en los comentarios la funcionalidad de cada cosa y el comportamiento es bastante similar a lo que ya se venia explicando.

5)
Ahora para leer Atributos heredados de una Clase es otra historia, ya que al usar el metodo "getDeclaredFields" para obtener el nombre de los Campos, no nos devuelve aquellos que se esten heredando, pero por cuestiones de herencia, sabemos que estan ahi, y sabemos que estaran sus metodos publicos Getters y Setters tambien (de seguir esa practica), entonces... como podemos hacer para leerlos??:


import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class App
{
public static void main( String[] args )
{
OtraClase otra = new OtraClase();
Entidad entidad = new Entidad(5, "Diego", "Gato", null);

//De esta forma obtenemos un Array con los Campos
//de la Clase de la que se extiende Directamente, si
//a su vez quisieramos los atributos del Padre del Padre
//tendriamos que repetir este proceso de forma recursiva.
Field[] fields = entidad.getClass().getSuperclass().getDeclaredFields();

for(Field f : fields){
String field = f.getName();

try{
Method getter = entidad.getClass().getMethod("get" +
String.valueOf(field.charAt(0)).toUpperCase() +
field.substring(1));

//Armamos el Metodo Getter en base al Field obtenido
//de la Clase Padre, pero lo ejecutamos sobre la Clase
//Hija, ya que sabemos que heredara este Metodo, por lo
//tanto estara disponible aunque no podamos obtener
//directamente el nombre de su Campo
Object value = getter.invoke(entidad, new Object[0]);

System.out.println(value);

}catch(Exception ex){
ex.printStackTrace();
}
}
}

}

Estas son solo algunas de las cosas que se pueden hacer con Reflexión, quedan muchisimas cosas pendientes, y ni se hablo de las Anotaciones que pueden llegar a ser un recurso muy valioso para este tipo de Tareas... eso si... A no Abusar!! Todo trae aparejado alguna perdida de Performance... pero dependiendo de la situación pueden ser muchos mas los PROs que los CONTRAs...

Sunday, October 18, 2009

Bones

Para los que sean amantes de las series como yo... la semana pasada empece a ver la serie "Bones"... y ya voy por la mitad de la Segunda Temporada... la verdad MUY BUENA SERIE!! la trama central y los casos particulares de cada capitulo siempre son muy originales... al que este buscando algo para ver en el tiempo libre esta es una opcion muy recomendable!!!


Y se puede conseguir en:
Bones: Temporadas 1, 2, 3, 4 y 5

Wednesday, October 14, 2009

The Man From The Earth


Ayer estuve hablando de esta Pelicula, y la verdad que de tanto recomendarla me dieron ganas de volver a verla hoy...
Para los que no la conocen, es una pelicula de Ciencia Ficcion que transcurre completamente en el living de una cabaña, con solo 8 personas hablando... eso es todo lo que tiene la pelicula... cuando a mi me dijeron eso... dude mucho en verla... pero cuando la vi... me di cuenta que esta pelicula es el ejemplo de que una pelicula puede ser MUY MUY BUENA sin tener que caer en el uso de un monton de efectos y todas esas cosas que se suele ver en las peliculas de hoy en dia.
El argumento esta muy bien planteado... las personalidades de cada uno de los personajes estan perfectamente definidas... realmente es una pelicula que despues de verla todavia seguis pensando en un monton de cosas...

Un dato curioso de la pelicula:
En sólo dos semanas, ascendió del puesto 11.235 al número 5 en la clasificación de IMDb, a través de las descargas P2P, hasta el punto que el mismo productor ha agradecido su distribución por canales torrent

Monday, October 12, 2009

QuickDB - 0.8-SNAPSHOT

Release de la Version 0.8-SNAPSHOT de QuickDB
Esta version tiene mejoras de performance, y permite el trabajo con objetos simples, objetos compuestos, herencia, objetos con colecciones, etc. Tanto para el modo Intuitivo (sin necesidad de colocar anotaciones), como para el modo Por Defecto (no Intuitivo, haciendo uso de las Anotaciones).

Cada operación involucra solamente "lo que se desea realizar" y "a que objeto se le desea aplicar dicha operación" (sin necesidad de implementar ninguna Interfaz ni heredar de ninguna Clase).


Por ejemplo, para persistir un objeto solo se debe hacer lo siguiente:
AdminBase admin = new AdminBase(...); //Crear instancia de AdminBase (solo una vez)

MyEntity entity = new MyEntity(...); //Crear una instancia de mi Entidad
admin.save(entity); //Ejecutar la operacion (en este caso "save")

Capacidades de QuickDB
(ejemplo utilizando creación de tablas automatica, objetos simples, objetos compuestos, herencia y colecciones en relación uno-a-muchos)



Tambien esta disponible un video ejemplo de: relacion muchos-a-muchos

Saturday, October 10, 2009

Lo Que Los Gatos Realmente Estan Pensando!

Dando vueltas por unos Blogs encontre este video que realmente esta muy bueno!!
(y todos los que tengan Gatos se van a sentir bastante identificados jeje)

Tuesday, October 6, 2009

Mi Escritorio (Octubre)

Venia hace bastanteeeeeeeee con los mismos iconos y los mismos colores en la maquina... asi que me dieron ganas de cambiar un poco las cosas...

Los iconos son del pack Nostromo, y los colores son a mi gusto!


Monday, October 5, 2009

All We Got To Do!

Hugh Laurie cantando "All We Got To Do"! (con subtitulos)
Un Genio!!

Algunas Colecciones...

Algunos de los CDs que he recolectado con los años de mis primeros pasos con Software Libre... los encontre todos juntos y se merecian una foto! jeje

Ubuntu: 5.04 - 7.04 - 7.10 - 8.04 - 8.10 - 9.04