Relación Objeto – Mensaje:

Lo primero a comprender es como poder establecer una relación en la que yo tengo un objeto y le envío un mensaje ( es decir invocamos el método de un objeto ).

# Método I ( TAD ):

En C tenemos las queridas y amadas estructuras de datos, y quizás el patrón mas conocido es el TAD. Un TAD se define como una estructura de datos y sus funciones asociadas, como por ejemplo:

	typedef struct {
		char * name;
		int age;
	} t_person;

Y a esto tenemos sus funciones asociadas:

	char* person_getname(t_person*);
	int   person_getage(t_person*);
	void  person_walk(t_person*);

Ahora bien, modificando un poco el criterio de la sintaxis podria definir lo siguiente:

	struct Person {
		char * name;
		int age;
	};

	char* Person_getName(struct Person *);
	int   Person_getAge(struct Person *);
	void  Person_walk(struct Person *);

Esto mas que nada nos puede hacer pensar que Persona es nuestra clase y que getName es un método estático de la clase Persona y nosotros le pasamos la instancia de la clase. Quizás este puede ser una de las formas mas comunes de ver el código en C. Pero como todo suele tener varias problemáticas, las cuales veremos mas adelante.

# Método II:

Este método, también es uno de los mas conocidos y consiste en asociar las funciones con las estructuras de datos, haciendo que estas contengan los punteros.

	struct Person {
		char * name;
		int age;
		void (* walk) (void *_self);
		void (* run) (void *_self);
		void (* talk) (void *_self, void *otherPerson);
	};

	person1->age;
	person1->run(person1);
	person1->talk(person1, person2);

En este caso cuando nosotros creamos la estructura le asociamos los punteros a los métodos los cuales invocamos con una sintaxis que nos podría hacer pensar en objetos pero no lo es. La principal cuestión de este patrón es la recursividad, como se puede ver la invocación no tiene mucho sentido:

	person1->run(person1);

El hecho de acceder a la función run de person1 y tener que volver a pasarle la instancia lo vuelve algo poco amigable.

# Método II (BIS):

Una posible alternativa que se podría suponer que funciones es utilizar inner functions ( solo soportado por el GCC ) para solucionar el problema anterior:

	struct Person {
		char * name;
		int age;
		void (* walk) ();
		void (* run) ();
		void (* talk) (void *otherPerson);
	};

	static void * Person_init(void * _self){
		struct Person * self = _self;

		void inner_walk(){
			Person_walk(self);
		}
		self->walk = inner_walk;

		void inner_run(){
			Person_run(self);
		}
		self->run = inner_run;

		void inner_talk(void *arg){
			Person_talk(self, arg);
		}
		self->talk = inner_talk;

		return _self;
	}

	person1->run();

Pero lamento comunicar que esto no funciona, ya que el scope de las inner functions esta limitado a al stack de llamada, por lo que llamar a person1->run(); fuera del Person_init genera un seg fault porque el self al que llaman todas las inner ya no esta mas dentro del stack.

# Método III:

Esta forma es una combinación de sintaxis del Método II con el concepto del Método I, es decir utilizamos punteros a funciones dentro de nuestra estructura pero lo trabajamos como si fueran clases con métodos estáticos:

	struct PersonClass {
		void (* walk) (void *_self);
		void (* run) (void *_self);
		void (* talk) (void *_self, void *otherPerson);
	};

	struct Person {
		char * name;
		int age;
	};

	void  Person_walk(struct Person *);
	void  Person_run(struct Person *);
	void  Person_talk(struct Person *, struct Persona *);

	static const struct PersonClass PersonClass = {
			Person_walk,
			Person_run,
			Person_talk
	};

	struct Person *person1;

	PersonClass.run(person1);

Bueno dejando de lado como inicializamos ( ya que lo voy a exponer mas adelante ), vemos que la forma de trabajar de esto es mas o menos similar a las anteriores pero rejunta un poco de cada una. El punto es ¿Porque hace PersonClass.run(person1); en vez de hacer Person_run(person1)?
La respuesta es simple, C no es un lenguaje que nos deje sobre-escribir funciones tal como se puede en otros lenguajes, y menos hacer sobrecarga de funciones por lo cual dentro de nuestro entorno de compilación solo puede existir un solo Person_run que tiene un único comportamiento predefinido. Cuando trabajamos con PersonClass.run, este resulta ser un puntero a una función por lo cual nosotros podemos optar por cambiar el puntero para que apunte a otra función y con eso logramos cambiar la implementación Esto seguramente nos puede resultar muy útil para de alguna forma mockear nuestras estructuras o realizar cierto tipo de herencia ( veremos mas adelante ).
Como detalle hay que tener en cuenta que el manejo de punteros a funciones bajo esta metodología no es de los mas performante que existe. Esto es porque el compilador no sabe resolver los punteros de las funciones para que queden de tal forma que sean contiguos. Esto nos podría generar que el IP del CPU valla saltando de lado a lado por la memoria generando una enorme cantidad de page fault, cosa que sin la utilización de punteros el compilador puede ordenar la memoria para minimizar esta situación

# Método IV:

Como ultimo método pediremos ayuda a las poderosas macros de C:

	#define INIT(var)	void var##_run() { Person_run(var); } \
				void var##_walk() { Person_walk(var); } \
				void var##_talk(arg) { Person_talk(var, (void*)arg); }

	#define NEW(var, type)	type *var = malloc( sizeof(type) ); INIT(var)

	NEW(person1, struct Person);

	person1_run();
	person1_talk(person2);

Tal y como se observa corremos con las ventaja de que en esta ocasión el pre-compilador nos ayuda a construir las invocaciones y finalmente podremos lograr una sintaxis en la que invocamos el método de una instancia. Nuestro principal problema acá es que nuestro scope es reducido ya que el NEW es local al bloque y si pasamos person1 como referencia a otra función dentro de esta otra deberíamos hacer INIT(person1). Por otro lado hay que tener en cuenta que eso obviamente nos genera una gran cantidad de código extra que si bien no es visible en la edición del código si lo puede ser cuando se compila.

Instanciación & Destrucción:

Hasta lo que mencione ahora otro de los factores a tener en cuenta en el modelo orientado a objetos es la instanciaciones de un objeto. A los fines prácticos cuando uno instancia una clase se reserva memoria para el objeto y se inicializa esta misma. Vamos a ver como logramos eso:

#ifndef CLASS_H_
#define CLASS_H_

	#include <stddef.h>
	#include <stdarg.h>

	struct Class {
		char * name;
		size_t size;
		void * (* ctor) (void * self, va_list * app);
		void * (* equals) (const void * _class1, const void * _class2);
		void * (* dtor) (void * self);
	};

	int Class_equals(const void * _class1, const void * _class2);

#endif

int Class_equals(const void * _class1, const void * _class2) {
	const struct Class * class1 = _class1;
	const struct Class * class2 = _class2;
	return strcmp(class1->name, class2->name) == 0
					&& class1->size == class2->size;
}

Acá tenemos definido lo que seria el molde de una clase genérica, lo que vamos a hacer es crear un tipo de clase, que para este caso vamos a tomar los String, y vamos a ver como manejarlo utilizando el Método III de relación entre objetos y mensajes.
Pero antes es necesario implementar nuestro mecanismo de construcion de objetos y para ellos vamos a tener:

#ifndef OBJECT_H_
#define OBJECT_H_

void * new (const void * type, ...);
int instanceOf (const void * obj, const void * class);
void delete (void * obj);

#endif /* OBJECT_H_ */

#include
#include
#include
#include

#include "Class.h"
#include "Object.h"

void * new(const void * _class, ...) {
const struct Class * class = _class;
void * p = calloc(1, class->size);
assert(p);
*(const struct Class **) p = class;
if (class->ctor) {
va_list ap;
va_start(ap, _class);
p = class->ctor(p, &ap);
va_end(ap);
}
return p;
}

int instanceOf(const void * obj, const void * _class) {
const struct Class ** cp = obj;
const struct Class * class = _class;
return strcmp((*cp)->name, class->name) == 0
&& (*cp)->size == class->size;
}

void delete(void * obj) {
const struct Class ** cp = self;
if (self && *cp && (*cp)->dtor)
self = (*cp)->dtor(self);
free(self);
}

Como se observa ahora tenemos un mecanismo de instanciación y destrucción que nos permite llamar a los métodos correspondientes de una clase y liberar su memoria. Pero ahora necesitamos nuestra clase String y definir sus comportamientos de destrucción y construcción.

#ifndef STRING_H_
#define STRING_H_

#include "Class.h"

struct String {
const void * class; /* must be first */
char * text;
};

struct StringClass {
void * (* clone) (struct String *);
int (* equals) (struct String *, struct String *);
};

void * String_constructor (void * _self, va_list * app);
void * String_destructor (void * _self);
void * String_clone (void * _self);
int    String_equals (void * _self, void * _other);

static const struct Class _String = {
"String",
sizeof(struct String),
String_constructor, Class_equals, String_destructor
};

static const void * String = &_String;

static const struct StringClass StringClass = {
String_clone,
String_equals
};

#endif /* STRING_H_ */

#include
#include
#include
#include

#include "Class.h"
#include "Object.h"
#include "String.h"

void * String_constructor (void * _self, va_list * app){
struct String * self = _self;
const char * text = va_arg(* app, const char *);
self->text = malloc(strlen(text) + 1);
assert(self->text);
strcpy(self->text, text);
return self;
}

void * String_destructor (void * _self){
struct String * self = _self;
free(self->text), self->text = NULL;
return self;
}

void * String_clone (void * _self){
struct String * self = _self;
return new(String, self->text);
}

int String_equals (void * _self, void * _other){
struct String * str1 = _self;
struct String * str2 = _other;
return strcmp(str1->text, str2->text) == 0;
}

Finalmente, ya tenemos nuestra “clase” String con un constructor, un destructor, un clonador y un comparador. Para una pequeña prueba:

int main(void) {
struct String *str = new(String, "Hola!!!!");
struct String *aux = StringClass.clone(str);

printf("%s\n", str->text);
printf("%s\n", aux->text);
printf("%d\n", StringClass.equals(str, aux));

return EXIT_SUCCESS;
}

Output:

Hola!!!!
Hola!!!!
1

FUENTE: http://docs.google.com/viewer?url=http://www.planetpdf.com/codecuts/pdfs/ooc.pdf

1. SQuirreL SQL Client

SQuirreL SQL is the most popular open source SQL clientClient. It provides a graphical Java program that will allow you to view the structure of a JDBC compliant database, browse the data in tables, issue SQL commands etc.

2. iSQL-Viewer

iSQL-Viewer is an open-source JDBC 2.x compliant database front end written in Java. It implements across multiple platforms features of the JDBC API. It does everything through a single interface. iSQL-Viewer works with most database platforms, including PostgreSQL, MySQL, Oracle, and Informix. iSQL-Viewer provides a variety of tools and features to carry out common database tasks.

3. LiquiBase

LiquiBase is an open source (LGPL), database-independent library for tracking, managing and applying database changes. It is built on a simple premise: All database changes are stored in a human readable yet trackable form and checked into source control.

4. Henplus

HenPlus is a SQL shell written in Java that works for any database that offers JDBC support. So basically any database. Why do we need this ? Any database comes with some shell, but all of them have missing features (and several shells are simply unusable). And if you work with several databases at once (if you are a developer, then you do this all the time), switching between these tools is tedious.

5. QuantumDB

QuantumDB is a simple but powerful database access plug-in for the

Eclipse Development Platform. QuantumDB allows you to:

• connect to databases using standard JDBC drivers
• review schemas, tables, views and sequences
• look up column, index and foreign key information
• issue ad-hoc queries or other SQL statements against the database

6. dbbrowser

DBBrowser is an open source (GPL license), cross-platform tool which can be used to view the contents of a database. It supports CLOBS and BLOBS. It is designed to work with Oracle and MySQL. The user should never have to write SQL to view the data although a SQL window is provided. Support for ER (Entity Relationship) diagrams, XMLTypes and more DBMS is planned for the next version.

7. Jackcess

Jackcess is a pure Java library for reading from and writing to MS Access databases. It is not an application. There is no GUI. It is a library, intended for other developers to use to build Java applications.

8. SQL Workbench-J

SQL Workbench/J is a DBMS independet frontend for SQL databases. It can be used in batch mode and has strong export and import capabilities. It also offers some extensions to SQL (Variable substitution, BLOB support with local filenames) that try to unify handling SQL databases. It can copy table data directly between two different servers (batch and GUI).

9. SQL Admin

SQL Admin is a Java client application to connect and send queries to different databases through JDBC. The main idea is to create a multiplatform and multidatabase thin client.

10. SQLeonardo

SQLeonardo is a powerful and easy-to-use tool that lets you query databases. When you work in SQLeonardo, you work in a graphical environment and working with data in this environment means you do not need to understand SQL, the standard programming language for talking to databases.

11. SQLMinus

SQLMinus is an SQL Client with many developer-friendly features including :

• auto-linking across tables
• dependency discovery
• simple, intuitive and powerful keys to sort columns and filter data
• tab-completion of table and column names
• expansion of abbreviations (as in vi)
• expansion of previously entered words (as in vim)

12. GUAM

GUAM is, as the name implies, a GUI frontend to allow easy administration of MySQL users. It is written in Java and uses the Swing toolkit. Since it is a pure Java application, it is completely cross-platform and should work on any platform that has a full Java implementation (and maybe even some of the cut-down implementations). GUAM is released under the GNU General Public License (GPL).

13. JSQLTool

JSQLTool is java swing SQL Tool used to view/edit database tables content and to execute sql scripts, by connecting to a database using JDBC/ODBC. JSQLTool supports multi-language and internationalization.

14. Vela

Vela is SQL and PL/SQL client with graphical user interface developed as a open source front end tool using JDBC and Java Swing. It supports Oracle Database. Vela is a Front-End tool for a Oracle developer. It supports most of the common developer tasks such as browsing database objects, viewing table definitions, viewing table data. It also supports editing and compiling SQL and PL/SQL scripts.

15. DbmJ

DbmJui is an attempt to clone DBMGUI, the database manager for MaxDB (formerly known as SAP DB). DBMGUI is written in VB so it can only run on Windows platforms. DbmJui uses the Java programming language. It can run on every platform where a JVM is available. Every version of DbmJui > 0.1.5 (only 0.1.90 for now) uses SWT. Linux/GTK2 and Win32 releases are provided.

16. ViennaSQL

ViennaSQL is a GUI SQL client written in 100% Java. ViennaSQL can communicate with any database that has a JDBC driver. It should run anywhere Java runs. I use it on Linux and Windows NT 4.0 with Oracles 100% Java JDBC driver. ViennaSQL runs each query in a separate thread so the GUI remains alive while a query is running.

17. Adit

Adit is another database interface tool built with Java. Adit is meant to be a lightweight tool for querying a database.

Some of the current features include:

• Connect to any database with a JDBC driver
• Save query results to a delimited file
• Save and restore SQL statements to disk
• View tables and field definitions
• Get information (properties) about a query

18. DataBase Java Console

DataBase Java Console (DBJC) is a console program that allows people to query a database with predefined SQL queries, or to make repetitive queries (with different parameters) for administration purposes.

19. QueryForm

QueryForm is a robust Java application that provides a powerful GUI front end for JDBC-enabled databases. It creates forms on-the-fly through which you can query tables and browse the results with just a few keystrokes or mouse clicks. It also lets you insert, update and delete table rows without typing any SQL statements.

20. SqlShell

SQLShell is a fully functional textual database frontend with features like tabcompletion, command history optimized display and many more. SQLShell uses JDBC to connect to your favorite database. SQLShell has been succesfully tested on windows and linux.

21. PKLite SQL Client

PKLite SQL Client is an Open Source Java program can connect to any JDBC compliant database. It has basic query and update functionality and some simple database information capabilities. The goal of this project was to create a lightweight SQL client (under 1 MB) that was portable, easy to install and be vender independent. There are still some issues to be worked out so that is can be completely database vender independent but with this new build it is able to connect to any database that has a JDBC driver and run on any OS that has a Java VM.

22. jisql

Jisql is a Java based utility to provide a command line interactive session with a SQL server. This application is conceptually modeled on the Sybase isql program with, obviously, strong similarities to Microsoft SQL/Server isql and osql (as Microsoft got SQL Server from Sybase). The program can act in a similar way to Oracles sqlplus and PostgreSQLs psql.

23. Datastream Pro

Datastream Pro is a database browser and data manipulation tool. It is intuitive, easy to use, reliable and stable. It supports almost any JDBC compliant database (tested on Oracle, MySQL, postgreSQL and HSQLDb). It is avaliable on both Linux and Windows. Datastream Pro allows you to browse and edit the data in your database. Run SQL queries and scripts, Simultaneously connect to multiple databases, has an easy to use connection wizard, Secure, personalised settings for connections and preferences and even has a built in text editor.

24. Execute Query

Execute Query is an operating system independent database utility written entirely in Java. Using the flexibility provided by Java Database Connectivity (JDBC), Execute Query provides a simple way to interact with almost any database from simple queries to table creation and import/export of an entire schemas data.

25. MyJSQLView

MyJSQLView provides an easy to use Java based user interface frontend for viewing, adding, editing, or deleting entries in the HSQL, MySQL, Oracle, and PostgreSQL databases. A query tool allows the building of complex SELECT SQL statements. The application allows easy sorting, searching, and import/export of table data.

26. DBSA

DBSA (DataBase Structure Analysis) is a tool for comparing schema snapshots. Differences are reported and an SQL patch can be generated. It includes a basic repository facility for schema history tracking

27. DBClient

https://dbclient.dev.java.net/

El evento se realizará en la Facultad de Ciencias Exactas y Naturales de la Universidad de Buenos Aires (UBA) y su entrada es libre y gratuita, pero es necesarioregistrarse antes. Para la conferencia se organizó también, y por primera vez, unconcurso de programación con premios que incluyen un iPod Touch de 8 Gb y una cámara Nikon Coolpix L20.

La lista de disertantes que presentarán sus charlas es realmente impresionante, y la personalidad más destacada es sin duda Daniel Henry Holmes Ingalls, pionero de la programación orientada a objetos y principal diseñador y arquitecto de cinco generaciones de entornos de Smalltalk. Smalltalk es un sistema completo que permite realizar tareas de computación mediante la interacción con un entorno de objetos virtuales, generalmente compuesto por:

• Una máquina virtual.
• Una imágen virtual que contiene todos los objetos del sistema.
• Un lenguaje de programación (también conocido como Smalltalk).
• Una biblioteca de objetos reusables.

Opcionalmente un entorno de desarrollo que funciona como un sistema en tiempo de ejecución.

Y como lo menciona la fuente de esta noticia, aunque quizás no relacionado con la conferencia en sí, esta charla de Dan Ingalls sobre el proyecto Lively Kernel, una plataforma para aplicaciones web con gráficos dinámicos, acceso de red, y herramientas de desarrollo que no requiere nada más que un navegador, no tiene desperdicio.

Via: http://www.vivalinux.com.ar/eventos/smalltalks-2009-buenos-aires

Un articulo muy intersante de leer, en resumidas cuentas esto es un poco de lo que ya sabemos y ya se viene sabiendo, Java es popular pero no quita que se este quedando atras. Hay que diferencias la plataforma de la JVM ( la cual es una masa ) con el lenguaje insignia que corre sobre esta ( el cual no es exactamente lo mejor que existe ).

Uno obviamente no puede comparar lenguajes en sentido de Java o Ruby, porque son mundo diferentes e incluso targets diferentes. Pero uno si puede ver como muchos lenguajes tienen un proceso evolutivo mucho mas rapido que Java.

Hace ya unos bueno 4 años que salio la JDK 6 ( si mucha gente no la conoce, una pena por ellos pero para los que utilizamos todo el potencial del lenguaje es mas que claro que ya se esta quedando vieja ) y recien a fines del proximo año veremos la JDK 7 ( que a traido mas decepciones que alegrías, no es que sea basura pero para muchos realmente se esperaba mucho mas ).

Estos features, mensionados solo son algunas de las cosas que realmente muchos esperabamos ver en Java 7 y que seguramente tendremos que esperar otros 4 años a Java 8 para quizas verlos. El impacto de estos es cierto que generarian cierta retrocompatibilidad ( quizas ) pero seria un paso mas para que el dia de mañana cuando una aplicacion/proyecto/sistema quiera aprobechar las nuevas cosas, nos permita mayor fluides en el desarrollo de este.

Java is Dead??

Yo creo que por ahora no, pero si en lo proximo 2 años no se hace algo, por darle mayor potencial al lenguaje definitivamente va a morir ( no es que desaparezca sino que realmente no va a resultar una buena opcion para el desarrollo y posiblemente empresas de ultima tecnologia, vease google, van a empezar a promocionar la utilizacion de otros lenguajes mas poderosos, faciles de usar, etc … vease python, ruby, etc … y esto no es algo nuevo ya que grandes lenguajes popularmente usados han desaparecido a lo largo de la historia justamente por su poca evolucion vease Visual Basic, C++, Cobol, etc… ). Obviamente no hablamos de que nos despertamos un dia y ya nadie usa Java, sino que hablamos de un proceso en el cual Java en sus años venideros simplemente va a empezar a dejarse de tomar como alternativa.

Ohh pero la grandes empresas apoyan al lenguaje, y??? queres pensarlo 100% empresa?? bueno esto es costo beneficio, si yo te digo tengo un lenguaje que me permite hacer lo mismo que Java pero en menos tiempo, de manera mas simple, mas legible y mas escalar, obvio que el cliente te dice donde firmo????? Porque defender un lenguaje que solo te complica las cosas no sirve de mucho que digamos.

# Soft, Weak and Phantom references in Java – http://www.rachvela.com/2009/11/soft-weak-and-phantom-references-in.html

Muy interesante para leer y tener en cuenta.

# Dependency Injection Makes Your Code Worse - http://java.dzone.com/articles/dependency-injection-makes

Me parecio interesante el comentario, sobre todo porque es casi un comentario muy cuestionable teniendo en cuenta de que muchos tendemos a utilizar inyeccion de dependencias. De por si creo que el autor no termino de entender el concepto y la utilización de inyeccion de dependencias. Yo creo que a fin de cuenta todo depende mucho del programador y como lo haga, si aplicas mal el patron de diseño y usas un framework malo seguramente vas a estar en un punto en donde vas a decir ….  de donde salio esto?? que esto??? y seguramente termines en un gran problema de dependencias. Pero si un programador con experiencia arma un buen modelado orientado a DI  seguramente no vas a tener mucho problema. Para Spring es feo, pero no hace que todos los IoC sean feos, Guice es muy bueno a mi criterio y bien aplicado es muy util y facilita varias cosas.

El reporte del error:

https://bugs.launchpad.net/ubuntu/+source/gtk+2.0/+bug/442078/comments/28

Starting from 2.18 on, GTK+ changed some of its internal behaviour (google for “client side windows”). This change is intentional, and needed for other development. It doesn’t make any difference to programs using GTK+ correctly, but it makes problems with programs that use GTK+ in weird ways, making wrong assumptions that only accidentally worked in the past. So, to ease the transition until those programs get fixed, an environment variable has been introduced to simulate the old behaviour.

La solucion consiste basicamente en declarar una variable de entorno antes del arranque de la aplicacion:

GDK_NATIVE_WINDOWS=true

En caso de querer arrancar el eclipse simplemente deberiamos crear un script al estilo:

run.sh

y dentro de este declarar:

export GDK_NATIVE_WINDOWS=true

/opt/eclipse/eclipse

donde /opt/eclipse/eclipse es el path al binario ejecutable del eclipse.

Es probable que esta misma solucion, arregle a otras aplicaciones que tambien usen SWT. En algunos lugares dicen de bajar las libs 2.16 ( las cuales si andan con SWT) y reemplazarlas por las 2.18 pero posiblemente se arruinen muchas cosas del sistema.

Existen ya unas versiones beta de algunas de las aplicaciones, las cuales tienen soporte para la 2.18. Por ejemplo segun tengo entendido para el Lotus Notes hay una version 8.5.1 que corre en Karmic Koala. La version 3.5.2 del Eclipse ya traeiria solucionado el problema.How to FIX SWT in Karmic Koala

• KDE Alcanza las 4 millones de lineas de codigo:  http://www.linuxpromagazine.com/Online/News/Code-Statistics-KDE-Costs-175-Million-Dollars
  Para mi cada vez KDE se acerca mas a ser la posta por encima de Gnome. Son mas copados, mas rapidos, mejo desarrollo y estan mejor administrados.

• Got the Wrong Bobo? http://gmailblog.blogspot.com/2009/10/new-in-labs-got-wrong-bob.html
  Otra tool fumada de Google para Gmail.

• Un blog interesnate sobre HTML 5:  http://carsonified.com/blog/web-apps/the-future-of-html-5/
  Esta interesante ver algunos de los ejemplos que demuestran lo que se puede hacer hasta ahora, seguramente con la introduccion de WebGL para la aceleracion de graficos atravez de navegadores se pueda lograr un rendimiento mucho mas alto sin gastar tanta CPU.

• Todo lo que siempre quisite saber de una inner class http://viralpatel.net/blogs/2009/10/inner-classes-in-java.html

• Java is Dead! …. is dead? http://muckandbrass.com/web/display/~cemerick/2009/10/01/Java+is+dead,+but+you’ll+learn+to+love+it

Fecha: 17 de noviembre de 9 a 20 ( Paseo La Plaza Av. Corrientes 1660)

URL: https://sites.google.com/a/mazalan.com.ar/devfest/home

Sólo algunos de los beneficios anunciados que FatELF traería a Linux incluyen:

• Ya no será necesario que las distribuciones tengan descargas separadas para varias plataformas.
• Ya no será necesario tener directorios /lib, /lib32 y /lib64 separados.
• Ya no será necesaria la librería de compatibilidad ia32.
• Soporte para binarios de 32 y 64 bits en un sólo archivo.
• Se podrá distribuir un único archivo que funcione en Linux y en FreeBSD.

Via: http://www.vivalinux.com.ar/soft/fatelf

Abarca proyectos tanto de Java como de .NET.

Es muy piola el rankeo que tienen sobre vulnerabilidades en aplicaciones web y sirve de referencia a la hora de pensar como segurizar nuestras aplicaciones.

Está orientada al aprendizaje ya que categorizan, definen y ejemplifican los diferentes tipos de ataques. Incluso desarrollaron una aplicación insegura, llamada WebGoat con el fin de que el que quiera aprender la ataque de diferentes formas, tratando que explote

Han desarrollado una herramienta para hacer pruebas de exploits, que se llama WebScarab, hecha en Java que (en muchos casos) actua de proxy en comunicaciones HTTP y HTTPS, permitiendo realizar acciones típicas de exploits. Cabe destacar que existen muchas herramientas de este estilo (pagas o no), como por ejemplo Metasploit.

Tambien desarrollaron frameworks para ayudar a la construcción de aplicaciones seguras.

Los siguientes artículos de wikipedia tienen una buena descripción de que trata OWASP y como no quiero reinventar la rueda, se los dejo para que profundicen:

• ingles
• castellano

La pagina oficial del proyecto es http://www.owasp.org

Aca posteo algunos links de JPA2.0 era algo previsible de cambio con algunas mejoras importantes como la API de criteria que tenia hibernate años atras, no se como no vieron ese feature, hacer queries con strings es casi como usar jdbc con el mapeo resuelto, por suerte parece ser un error corregido para esta nueva version, tambien vi que agregaron una api standard de cache, que es un must para que una aplicación sea mas o menos performante.

http://www.infoq.com/presentations/whats-new-and-exciting-in-jpa-20
http://en.wikibooks.org/wiki/Java_Persistence/What_is_new_in_JPA_2.0%3F
http://www.ibm.com/developerworks/java/library/j-typesafejpa/