Charlas 4-12-2000 Ummet'2000

Charlas del 4/12/2000

Log de la conferencia. Se han suprimido las líneas correspondientes a entradas y salidas de diferentes personas en el canal durante la conferencia

[19:13] (fernand0) vale
[19:13] (fernand0) ejem,ejem
[19:13] (fernand0) Hola,
[19:13] (fernand0) tenemos el gusto de presentarles hoy aqui a
[19:13] (fernand0) Alvaro del Castillo y Diego Sevilla.
[19:13] (fernand0) Sobre Alvaro del Castillo podemos decir que entre sus múltiples
[19:13] (fernand0) actividades, es editor de barrapunto, y un conocido divulgador de temas
[19:13] (fernand0) sobre informática, que escribe frecuentemente en diferentes publicaciones,
[19:13] (fernand0) sin olvidar que desde barrapunto ha sido una de las personas que más
[19:13] (fernand0) apoyaron este congreso (http://www.barrapunto.com/)
[19:14] (fernand0) Sobre Diego Sevilla, podemos decir que está en la Universidad de Murcia,
[19:14] (fernand0) como profesor del Departamento de Ingeniería y Tecnología de Computadores,
[19:14] (fernand0) haciendo su tesis doctoral sobre componentes distribuíbles en CORBA, y
[19:14] (fernand0) además lleva la lista de CORBA en español. Información sobre la lista:
[19:14] (fernand0) http://moriarty.dif.um.es/mailman/listinfo/corba-comp
[19:14] (fernand0) Ellos van a hablar hoy aquí sobre CORBA.
[19:14] (fernand0) Agradecemos a todos ustedes su presencia aquí, así como la de los
[19:14] (fernand0) conferenciantes.
[19:14] (fernand0) La documentación sobre la conferencia puede encontrarse en:
[19:14] (fernand0) http://umeet.uninet.edu/conferencias/acsdsevilla/corba/index.html
[19:14] (fernand0) Y la conferencia será publicada en nuestra web tan pronto como sea posible
[19:14] (fernand0) Alvaro, Diego ....
[19:14] (acs) Hola, muchas gracias por vuestra asistencia
[19:14](MJesus) plas plas plas plas plas plas plas plas plas plas
[19:14](MJesus) plas plas plas plas plas plas plas plas plas plas
[19:15](MJesus) clap clap clap clap clap clap clap clap clap clap
[19:15](MJesus) clap clap clap clap clap clap clap clap clap clap
[19:15](MJesus) plas plas plas plas plas plas plas plas plas plas
[19:15](MJesus) plas plas plas plas plas plas plas plas plas plas
[19:15] (dsevilla) Hola a todos
[19:15] (acs) Bien, creo que empiezo yo ... con una pequeña introducción a CORBA
[19:15] (acs) Quizá es bueno que tangáis un navegador a mano ...
[19:16] (acs) Cuando hablemos de dibujos y gráficas ayudará mucho
[19:16] (acs) CORBA es un tema que cada vez se escucha más, y eso es algo bueno
[19:16] (acs) Detrás de esa palabra hay una arquitectura realmente impresionante
[19:17] (acs) Bueno, en cuanto queráis preguntar adelante ...
[19:17] (acs) Bueno, sigamos
[19:17] (acs) CORBA son las iniciales de Common Object Request Broker Architecture
[19:18] (acs) Detrás de esas palabrejas se esconde una de las partes más importantes de OMA
[19:18] (acs) OMA es la arquitectura para crear modelar sistemas utilizando objetos que creó la OMG
[19:18] (acs) http://www.omg.org
[19:19] (acs) OMA, además de CORBA, incluye cosas como UML, el lenguaje con el que se describen los sistemas orientados a objetos
[19:19] (acs) Centrándonos en CORBA, su principal objetivo es
[19:19] (acs) permitir distribuir de forma transparente objetos en una red de computadores
[19:20] (acs) Para ello ha logrado definir una arquitectura que lo logro de una forma elegante y que hace la vida del programador muy sencilla
[19:20] (acs) Tan sencilla que he podido impartir cursos de CORBA utilizando Java a gente que comenzaba a programar
[19:20] (acs) y en un par de días ya estaban realizando aplicaciones distribuidas ...
[19:21] (acs) Pero como todos sabéis, la magia no existe ... bueno al menos en las computadoras :-)
[19:22] (acs) Y para que todo sea tan sencillo ha sido necesario un trabajo de varios años por grandes expertos de sistemas distribuidos
[19:22] (acs) Más de 700 compañías han participado en OMG definiendo CORBA
[19:22] (acs) SUN, HP, IBM, Telfonica I+D, Orbix ...
[19:23] (acs) Casi todas las grandes menos Microsoft, que se lanzó con COM y su arquitectura propietaria que ha terminado evolucionando hacia .NET
[19:23] (acs) De .NET quizá os hable luego Diego, que está muy impresionado por esta arquitectura
[19:24] (acs) Seguiendo con CORBA, su historia comienza en los años 80 ...
[19:24] (acs) Inicialmente era algo poco útil en su versión 1.0
[19:25] (acs) Se definió una arquitectura para distribuir objetos pero las distintas implementaciones de los fabricantes no podían interoperar entre sí
[19:25] (acs) Esto era terrible ya que CORBA era una herramienta prácticamente cerrada
[19:25] (acs) Si trabajabas con un fabricante de CORBA, te veías atado a él
[19:26] (acs) Pero esta situación duro poco ... hasta la llegada de CORBA 2.p0
[19:26] (acs) CORBA 2.0
[19:26] (acs) Sin duda este fue el momento en el que CORBA realmente hizo realidad los sueños de cientos de desarrolladores
[19:27] (acs) Cualquier implementación de CORBA 2.0 era interoperable con cualquier otra ... fue como inventar el TCP/IP de los sistemas distribuidos de objetos
[19:27] (acs) Podías hacer un objeto CORBA, ponerlo a disposición de una implementación CORBA y que fuera accedido desde clientes que utilizaban implementaciones de otros fabricantes
[19:28] (acs) Pero quizá ha llegado el momento de explicar la arquitectura de CORBA ...
[19:28] (acs) Pero sin perder la idea de que el objetivo es la interoperabilidad universal y escalable, algo que se ha logrado !!!
[19:29] (acs) Uno de los libros más famosos de CORBA es el de los marcianos ...
[19:29] (acs) Client/Server Programming with Java and CORBA
[19:30] (acs) En el se ilustra la idea de esta interoperabilidad universal con dos marcianos que utilizan CORBA para comunicarse :-)
[19:30] (acs) Bien, pasemos a ver la arquitectura de CORBA y ver como logra estos objetivos
[19:31] (acs) Ha llegado el momento de que los que podáis vayáis a ....
[19:31] (acs) http://www.openresources.com/es/magazine/tutoriales/corba/entrega1/entrega1.html
[19:31] (acs) Creo que en Umeet está tambien ...
[19:32] (dre) http://umeet.uninet.edu/conferencias/acsdsevilla/corba/index.html
[19:32] (acs) hacia mitad de la página hay un gráfico que representa la arquitectura de CORBA ...
[19:32] (acs) http://www.openresources.com/es/magazine/tutoriales/corba/entrega1/image1.png
[19:32] (acs) esa es la imagen ...
[19:33] (acs) CORBA tiene dos partes fundamentales ... la del cliente que accede a los objetos
[19:34] (acs) y la de los propios objetos
[19:34] (acs) El objetivo es poner en contacto a ambas partes
[19:34] (acs) Y el problema está en que el cliente está en una máquina y el objeto a ser accedido en otra
[19:34] (acs) Y queremos que para el desarrollador el uso de los objetos remotos sea como si estuvieran en local ...
[19:34] (acs) ¿Cómo lograrlo?
[19:35] (acs) Bueno, pues hay que lograr que el cliente sea capaz de localizar al objeto, que de alguna forma le haga llegar
[19:35] (acs) la invocación que quiere realizar sobre el objeto y que le vuelva el resultado ...
[19:35] (acs) Quizá estos sean los mecanismos más básico a solucionar por CORBA ...
[19:36] (acs) Vamos por partes
[19:36] (acs) Tenemos al cliente que quiere realizar una invocación sobre el objeto que está en una máquina remota ...
[19:36] (acs) Un ejemplo de código podría ser ...
[19:37] (acs) modelo.setVista(interfaz);
[19:37] (acs) modelo es un objeto remoto
[19:38] (acs) Y esta invocación se realiza en el cliente, en este caso, un cliente Java ...
[19:38] (acs) Para el programador, una vez que ha llegado a tener la referencia al objeto modelo, es realmente sencillo su uso
[19:39] (acs) modelo es en realidad una referencia al objeto remoto, y dentro de él, están lo que se llaman los Stubs
[19:39] (acs) Los stubs son los cabos que permiten que el cliente se "enganche" CORBA
[19:42] (acs) perdonad
[19:42] (acs) el teclado se me ha bloqueado ... glups
[19:42] (acs) por donde ibamos, los cabos del cliente son los que enganchan al cliente con CORBA
[19:43] (acs) En la imagen aprecen con el nombre IDL Stubs
[19:43] (acs) Estos cabos se generan de forma automática y dependen de cada implementación de CORBA
[19:43] (acs) ¿Cómo se generan estos cabos?
[19:43] (acs) Bueno, pues ha llegado el momento de presentaros a OMG/IDL, una de las partes más interesantes de CORBA
[19:44] (acs) Para que un objeto pueda ser accedido por clientes, es necesario que estos sepan que puede hacer el objeto
[19:45] (acs) ¿Qué puede hacer un objeto? Pues eso se define gracias al lenguaje OMG/IDL
[19:45] (acs) IDL es un lenguaje de descripción de interfaces
[19:45] (acs) Con él se especifica que es lo que saben hacer los objetos
[19:46] (acs) No se dice como se hacen las cosas, simplemente que se puede hacer
[19:46] (acs) Es importante tener esto claro ... IDL es sólo para describir, no para implementar
[19:46] (acs) esto le permite ser independiente del lenguaje de implementación
[19:46] (acs) algo que es muy importante
[19:47] (acs) IDL es un lenguaje muy abstracto sin ninguna ligación de tipo arquitectural
[19:47] (acs) Una interfaz IDL es tan buena para ser implementada en Java, como en C, C++ o Perl ...
[19:47] (acs) Bien, retomando el tema de los cabos ...
[19:48] (acs) Los cabos permiten acceder a un objeto con una interfaz IDL concreta
[19:49] (acs) Nosotros definimos una interfaz IDL para un objeto y a partir de ella, generamos de forma automática los cabos para el cliente utilizando un compilador
[19:49] (acs) A partir de este momento, la interfaz IDL se particulariza para una determinada implementación de CORBA y un lenguaje concreto
[19:49] (acs) Una interfaz IDL como tal, puede ser implementada en cualquier lenguaje
[19:50] (acs) Sólo es necesario tener un compilador que pase de IDL al lenguaje que hayamos elegido
[19:50] (acs) Para ello, la OMG ha definido traducciones de IDL a diversos lenguajes: C, C++, Java, Ada, Cobol ...
[19:51] (acs) Una IDL puede ser pues utilizada desde todos estos lenguajes. Incluso desde algun otro como Python y Perl como luego veremos
[19:51] (acs) Supongo que esto os gustará mucho. Tenéis libertad para elegir que lenguaje de programación queréis utilizar.
[19:52] (acs) Bueno, vamos a poner un ejemplo de una interfaz IDL sencilla
[19:52] (acs) module Patrones {
[19:53] (acs) // Lo implemento en Java
[19:53] (acs) interface Strategy {
[19:53] (acs) string componer(in string frase);
[19:53] (acs) };
[19:53] (acs) // Lo implemento en C++
[19:53] (acs) interface Registro {
[19:53] (acs) void registraStrategy(in Strategy strategy);
[19:53] (acs) // Para facilitar la conexion
[19:53] (acs) void estasVivo();
[19:53] (acs) void finStrategy();
[19:53] (acs) };
[19:53] (acs) };
[19:53] (acs) En este módulo de IDL se definen dos interfaces ...
[19:53] (acs) Cada una de ellas deberá ser implmentada por un objeto CORBA ...
[19:53] (acs) Supongamos que ya tenemos esos objetos CORBA implentados y queremos poder invocar los métodos de esos objetos
[19:54] (acs) desde clientes a través de CORBA
[19:54] (acs) El primer paso es generar los cabos que nos permiten
[19:54] (acs) acceder desde el cliente a CORBA
[19:54] (acs) Para ello, si por ejemplo queremos utilizar Java, podemos utilizar JavaORB como implementación de CORBA ...
[19:55] (acs) Con esta herramienta, que es software libre ;-) (creo), viene un compilador de IDL a Java
[19:55] (acs) Es algo tan sencillo como: idl2java Patrones.idl
[19:55] (acs) El resultado son un conjunto de clases Java que utilizadas desde el cliente, nos permiten acceder a
[19:56] (acs) CORBA de una forma casi transparente. Veamos como es el código de un cliente ....
[19:59] (acs) ops, no me tira el servidor ... sigamos ...
[19:59] (acs) mientras
[19:59](MJesus) :))
[19:59] (acs) Gracias al compilador de IDL a Java tenemos ya los cabos disponibles para usarlos desde Java
[19:59] (acs) Con ellos ya podemos programar el cliente
[20:00] (acs) Y ya puede acceder al servidor a través de la referencia al objeto remoto ...
[20:00] (acs) Pero, ¿qué es esa referencia al objeto remoto?
[20:00] (acs) ¿De dónde se saca?
[20:00] (acs) ¿Cómo se localiza?
[20:01] (acs) Bueno, pues esta referencia es el idenficador que permite llegar al objeto remoto.
[20:01] (acs) Con él, el cliente a través de CORBA puede llegar al objeto independientemente de su localización.
[20:02] (acs) ¿Cómo se consigue?
[20:02] (acs) Lo común es que esa referencia, que se conoce en terminología CORBA como IOR, contenga una dirección IP y un puerto donde localizar a ese objeto
[20:02] (acs) Pero eso es algo concreto de la mayoría de implementaciones
[20:03] (acs) En realidad un IOR es algo abstracto que debe permitir que el cliente llegue al servidor. Como se las apaña CORBA es ya un detalle de implementación.
[20:03] (acs) Pero hay algo importante: estos IOR deben ser válidos a través de todas las implementaciones de CORBA.
[20:04] (acs) Es decir, que si genero un IOR con ORBit, la implementación que usa GNOME de CORBA, debe ser válida para JavaORB.
[20:05] (acs) de esta forma, el cliente y servidor pueden ser desarrollador con distintos ORBs ... sólo deden ser compatibles con CORBA 2.0
[20:05] (acs) Esta IOR se genera cuando se crea el objeto CORBA en el servidor
[20:05] (acs) A ver si encuentro un IOR para que lo veáis ...
[20:06] (acs) IOR:010000001a00000049444c3a4d656e73616a65732f7365727669646f723a312e30000000020000000000000049000000010100000a0000003132372e302e302e31009904310000003132372e302e302e312f323332362f2d3234303336303137363a526f6f74504f412e504f41204d656e73616a6573005f300000000100000024000000010000000100000001000000140000000100000001000100000000000901010000000000
[20:07] (viper) ???
[20:07] * fernand0 que bonito!!
[20:07](MJesus) glub
[20:07] (acs) dentro de esta cadena está la clave para localizar un objeto dentro de CORBA
[20:07] (acs) :-)
[20:07] (WAPOWAPO) parece HEX ¿cuanto bytes son?
[20:07] (acs) Pero no os asustéis ... jamás tendréis que verlos :-))))
[20:07] (viper) QUE LOCO!!!
[20:08] (Ricardo) urf
[20:08] (Ricardo) :)
[20:08] (Ricardo) Doloroso
[20:08] (fernand0) ya los vimos
[20:08] (fernand0) :)
[20:08] (acs) :-)
[20:08] (acs) Es una cadena interna a CORBA y CORBA se las apaña ... con este tipo de cosas es muy bueno ;-)
[20:09] (acs) Dentro de esa cadena entre otras cosas suele estar la IP y el puerto en el que localizar el objeto ...
[20:09] (acs) Esta IOR hay que hacersela llegar al cliente
[20:09] (acs) ¿Cómo lo hacemos?
[20:09] (ldipenti) Una pregunta: CORBA tiene soporte para IPv6?
[20:09] (acs) Pues está el método artesanal: e-mail, ftp, scp, http ...
[20:10] (acs) Ops, pues no lo sé ... pero no importa mucho ...
[20:10] (acs) Me explico ....
[20:10] (acs) hola magaly ;-)
[20:11] (acs) El protocolo de comunicaciones que se use afecta a una parte muy concreta de CORBA: GIOP
[20:11] (acs) GIOP es el protocolo que permite que los distintos ORBs se comuniquen
[20:11] (Arthur) Que ventajas ofrece CORBA acs ?
[20:11] (acs) Si GIOP se implementa sobre IP, se conoce como IIOP
[20:12] (acs) Arthur, con respecto a qué?
[20:12] (Arthur) al manejo de los objetos ?
[20:13] (acs) Arthur, echa un ojo a http://www.openresources.com/es/magazine/tutoriales/corba/entrega1/entrega1.html
[20:13] (acs) IIOP es el protocolo que permite que los ORB se comuniquen ... y aún no hemos hablado del ORB ...
[20:13] (acs) Bueno, por donde ibamos ...
[20:14] (acs) Necesitamos que el IOR llegue del servidor al cliente de una forma escalable.
[20:15] (acs) Los métodos artesanales tienen límites ... y CORBA debe ser escalable más hayá de esos límites
[20:15] (acs) Para ello la gente de OMG creó un servicio CORBA llamado Servicio de Nombres (Naming Service)
[20:15] (acs) Es una especie de DNS para nombres de objetos de CORBA
[20:15] (acs) Utilizandolo, el cliente puede obtener de forma sencilla referencias a millones de objetos ...
[20:15] (acs) Y con ello queda resuelto el problema de escalabilidad :-)
[20:16] (dsevilla) (sólo una aclaración: IPv6 está soportado, al menos por ORBit. Mirad en http://orbit-resource.sourceforge.net/libiiop.html
[20:16] (acs) :-)))
[20:16] (acs) Una vez que invocamos una operación sobre un IOR, esta invocación se pasa al ORB
[20:17] (acs) El ORB es la parte más compleja de CORBA ...
[20:17] (acs) Imaginad
[20:18] (acs) Debe permitir miles de invocaciones simultáneas a millones de objetos remotos ...
[20:18] (acs) La tecnología para implementar esto no puede escapar de cosas como las hebras ...
[20:18] (acs) y los mecanismos internos de sincronización son complejos
[20:18] (acs) Hasta hace bien poco, había pocos ORB realmente estables
[20:19] (acs) Cuando comenzaban a usarse en serio ... se la pegaban.
[20:19] (acs) La complejidad de un ORB puede compararse a la del núcleo Linux, por ejemplo ...
[20:19] (acs) Bueno, quizá me he pasado ;-)
[20:19] (acs) Pero es muy complejo
[20:20] (acs) Si alguno estáis interesado en patrones de implementación de ORB, un tema apasionante, os recomiendo la doc de TAO
[20:20] (acs) Bien, el ORB recibe el IOR y la invocación ...
[20:21] (acs) A través de IIOP contacta con el objeto remoto, pudiendo pasar por pasarelas y otros cachivaches por el camino ...
[20:21] (acs) Una vez que contacta con el ORB remoto, perdonad no contacta con el objeto estrictamente, le pasa la referencia al objeto y la invocación
[20:23] (acs) Y espera a recibir la respuesta, que a través de los cabos se la devuelve al cliente.
[20:23] (acs) Centremonos en la parte en la que se entrega al ORB remoto la referncia al objeto y la operación a realizar ...
[20:23] (acs) Pensemos a lo grande, que es para lo que se hizo CORBA
[20:23] (acs) En el ORB pueden convivir miles de objetos ...
[20:23] (acs) ¿Cómo localizar el objeto adecuado?
[20:23] (acs) En el IOR (Interoperable Object Reference) se incluye la forma de localizar dicho objeto
[20:24] (acs) Una vez localizado el objeto, se utilizan los skeletons del objeto para acceder a él y pedirle que invoque
[20:24] (acs) la petición, asi como recibir los resultados ...
[20:25] (viper) perdon. Que son los skeletons???
[20:25] (acs) Los skeletons (esqueletos) son el equivalente de los cabos pero en el servidor
[20:25] (acs) De igual forma que generamos unos cabos para el cliente ...
[20:25] (acs) generamos unos esqueletos para el servidor ...
[20:26] (acs) que son los que permiten que la implementación del objeto se enchufe a CORBA
[20:26] (acs) Resumiendo ...
[20:26] (ldipenti) Para generar esos esqueletos se utiliza el mismo java2idl por ejemplo?
[20:26] (dsevilla) efectivamente
[20:26] (botijo) efectivamente es probablemente una profesion como otra cualquiera...ese es el problema y la realidad al mismo tiempo
[20:26] (acs) Sip, efectivamente
[20:27] (acs) el java2idl genera tanto los cabos como los esqueletos
[20:27] (acs) para implementar el objeto CORBA debemos utilizar los esqueletos
[20:27] (acs) Que son los que nos ocultn la parte fea de interactuar con CORBA ...
[20:28] (acs) Hola Lady :-)
[20:28] (acs) pues no, alguien lo vió?
[20:28] (acs) sigamos ...
[20:28] (acs) Resumiendo ...
[20:29] (acs) cliente<->cabos (stubs) <-) CORBA <-) esqueletos (skeletons) <-) Objeto
[20:30] (acs) Bueno, en realidad esto es a grandes rasgos ...
[20:30] (acs) La parte más bonita de CORBA para mi gusto no está en ese diagrama ...
[20:30] (acs) Que es el adaptador de objetos de CORBA ... POA
[20:30] (acs) Pero me da un poco de miedo meterme con él ...
[20:31] (acs) Os puede hacer pensar que CORBA es complejo .. cuando no lo es
[20:31] (acs) POA son las iniciales de Portable Object Adapter
[20:31] (acs) Y apareció con CORBA 2.2
[20:31] (viper) Podes sugerir algunos links para conseguir manuales/tutoriales de CORBA???
[20:32] (acs) Gracias a POA, por fin se logró que migrar una implementación de un objeto entre ORBs de fabricantes diferentes fuera posible
[20:32] (acs) Sobre los links, lo mejor es ir a http://ww.omg.org y bajarse el estandar de CORBA ...
[20:33] (viper) OK. GRACIAS
[20:33] (acs) Es muy legible y son las tablas de la ley
[20:33] (acs) Lo que pone ahí va a misa :-)
[20:33] (viper) como lo de RATIONAL
[20:33] (acs) Y el tutorial que acompaña a la conferencia está bastante bien :-)))))
[20:33] (viper) para UML
[20:34] (acs) bueno, vamos a meternos un poco con POA ... pero sólo un poco, para dejar tiempo luego a Diego
[20:34] (acs) A ver si os voy a quemar antes de tiempo :-))))
[20:34] (dsevilla) vaya! para mi lo más sencillo!
[20:34] (acs) POA es la arquitetcura que define como se organizan los objetos en el servidor, entre otras cosas
[20:35] (acs) pues a lo mejor me puedes echar una mano ;-)
[20:35] (dsevilla) Bueno, sigue y luego explicamos los detalles
[20:35] (acs) Los miles de objetos que tenemos en el servidor hay que organizarlos de alguna forma ...
[20:35] (acs) No queremos que todos los objetos se traten igual ...
[20:35] (dsevilla) el POA es un poco complejo y puede aburrir
[20:36] (acs) Pero vamos a dar las ideas ;-)
[20:36] (dsevilla) Efectivamente, el POA permite agrupar objetos implementación
[20:36] (dsevilla) y darles características parecidas
[20:36] (dsevilla) Por ejemplo, que su referencia sea persistente
[20:36] (dsevilla) (esto es, que se pueda acceder a ese objeto incluso si el servidor que lo creó no está funcionando)
[20:37] (acs) POA permite crear organizaciones similares a los directorios de ficheros para los objetos
[20:37] (dsevilla) en este caso, se volverá a cargar el servidor, se pondrá a funcionar y creará de nuevo el mismo objeto
[20:37] (dsevilla) También permite especificar, por ejemplo, que todo un conjunto de objetos sólo va a utilizar una única implementación
[20:38] (acs) Con esto podemos dar por cerrada la parte más básica de CORBA y su arquitectura.
[20:38] (acs) Junto a CORBA se han definido los servicios CORBA ...
[20:39] (acs) CORBA puede ser un poco tosco de usar sin una serie de servicios asociados ...
[20:39] (acs) es como usar TCP/IP sin DNS, FTP o HTTP ...
[20:40] (acs) Los servicios de CORBA proporcionan muchas funcionalidades básicas y se implementan sobre CORBA
[20:40] (acs) Uno de estos servicios es el que ya nombramos, el servicio de nombres
[20:40] (acs) Este servicio permite almacenar de forma organizada referencias a objetos
[20:40] (acs) Hay otros servicios como por ejemplo el de eventos
[20:40] (acs) Propagar eventos de forma distribuida es sencillo con este servicio ...
[20:41] (acs) otros servicios son el de transacciones, el de seguridad o el de peticiones a bases de datos ...
[20:41] (acs) Algunas implementaciones de CORBA ya implementan muchos de estos servicios
[20:42] (acs) por ejemplo JavaORB tiene el de nombres. eventos, transacciones ...
[20:42] (acs) En ORBit está seguro el de nombres, y el de seguridad se estaba implementado, y seguro que dispone de alguno más
[20:42] (dsevilla) si, también el de eventos
[20:42] (acs) Gracias diego, En OMG también os podéis bajar toda la especificación de los servicios
[20:43] (acs) Por último os quería hablar del uso real de CORBA
[20:43] (acs) Y nada mejor que hablar de GNOME ...
[20:43] (acs) el corazón de la arquitectura GNOME es CORBA, por donde pasan las comunicaciones entre los distintos programas de GNOME
[20:44] (acs) CORBA ha proporcionado a GNOME una infraestructura de comunicaciones impresionante
[20:45] (acs) Por ejemplo, el centro de control de GNOME tiene una interfaz IDL ...
[20:45] (acs) module GNOME {
[20:45] (acs) interface capplet {
[20:45] (acs) void try(in long id);
[20:45] (acs) boolean revert(in long id);
[20:45] (acs) boolean ok (in long id);
[20:45] (acs) void cancel (in long id);
[20:45] (acs) void help(in long id);
[20:45] (acs) void new_multi_capplet (in long id, in long newid, in unsigned long newxid, in long newcapid);
[20:45] (acs) void page_hidden(in long id);
[20:45] (acs) void page_shown(in long id);
[20:45] (acs) };
[20:45] (acs) interface control_center {
[20:45] (acs) long register_capplet (in long id, in capplet cap);
[20:46] (acs) void state_changed (in long id, in boolean undoable);
[20:46] (acs) void register_capplet_new (in capplet cap, in string name, in long capid, out unsigned long xid, out long newid);
[20:46] (acs) void show_control_center ();
[20:46] (acs) };
[20:46] (acs) };
[20:46] (acs) pero el más destacado uso de CORBA dentro de GNOME es Bonobo
[20:46] (acs) Bonobo es la arquitectura de componente de GNOME
[20:46] (acs) Bonobo se define como un conjunto de interfaces IDL
[20:47] (acs) Esas interfaces se han implementado en C y con Gtk utilizando como ORB a ORBit
[20:47] (acs) ORBit es una implementación de CORBA 2.2 que se hizo desde cero para GNOME
[20:47] (acs) La hizo Elliot Lee en red Hat
[20:48] (acs) Y es tan rápida que su uso en GNOME no ralentiza el entorno
[20:48] (acs) Nada turi
[20:48] (acs) Con el compilador de ORBit, se pasaron las interfaces IDL de Bonobo a C, generando los stubs y skeletons
[20:49] (acs) Se usaron los skeletons para implementar Bonobo
[20:49] (acs) Con GTk y C
[20:49] (acs) Y para atacar Bonobo. ..
[20:49] (acs) Se puede utilizar cualquier lenguaje que tenga soporte para CORBA
[20:49] (acs) Esto abre unas posibilidades enormes ... control desde Perl, Python, Java ... de los componentes Bonobo
[20:50] (ldipenti) No importa que el lenguaje no sea orientado a objetos? (como C)
[20:50] (acs) Utiliza el modelo de objetos de GTK
[20:50] (acs) Las posibilidades son aún mayores ... el uso de CORBA permite distribuir GNOME de forma trivial ...
[20:51] (acs) ¿Para qué queremos distribuir GNOME? Pufff, hay cientos de posibles aplicaciones que hay que explorar
[20:51] (acs) reparto d carga, visualización del escritorio en múltiples terminales ...
[20:51] (acs) Y creo que es un buen momento para pasarle el relevo a Diego ...
[20:52] (acs) Que nos va a hablar del modelo de componentes de CORBA
[20:52] (dsevilla) OK.
[20:52] (acs) que en cierto modeo debería sustituir a Bonobo, ¿no?
[20:52] (dsevilla) Depende.
[20:52] (dsevilla) CCM (el CORBA Component Model) es un modelo de servidor
[20:52] (dsevilla) esto es, especifica unos estándares en los que un objeto implementado con cualquier lenguaje
[20:53] (dsevilla) puede INSTALARSE en un SERVIDOR DE COMPONENTES
[20:53] (dsevilla) y EJECUTARSE sin ningún problema.
[20:53] (dsevilla) Bonobo es un sistema de componentes de escritorio (cliente)
[20:54] (acs) ¿EJB?
[20:54] (dsevilla) Si, muy similar a EJB
[20:54] (dsevilla) Para aquellos que lo conozcais... de hecho, se han basado en él
[20:54] (dsevilla) Pero han mejorado muchas cosas: soporte multilenguaje y multiplataforma
[20:54] (dsevilla) un modelo de persistencia mejor, eventos (que no tiene EJB), etc.
[20:55] (dsevilla) En fin... lo que permite es escribir sólo la implementación de la FUNCIONALIDAD y dejar que el sistema haga el resto:
[20:55] (dsevilla) * implementaría las factorías de objetos
[20:55] (dsevilla) (automáticamente)
[20:56] (dsevilla) * generaría el código para guardar y restaurar de forma automática el estado persistente de los objetos implementación
[20:56] (dsevilla) * Generaría el código necesario para instalarse en cualquier servidor de aplicaciones
[20:56] (dsevilla) * y se generaría finalmente una DLL que se puede instalar en cualquier equipo que soporte CCM
[20:57] (dsevilla) Si queréis, podeis ver las transparencias que hice sobre el CCM en http://www.ditec.um.es/~dsevilla/ccm/slide1.html
[20:57] (dsevilla) Son un poco complejas, pero intentaré explicaros...
[20:58] (dsevilla) Bueno, aunque existen una serie de servicios estándar de CORBA,
[20:58] (dsevilla) el estandar no define cuáles de ellos son obligatorios
[20:59] (dsevilla) esto lo define el CCM
[20:59] (dsevilla) Así, un componente escrito para el CCM, puede estar seguro de que tienes disponibles una serie de servicios siempre en la misma localización
[20:59] (dsevilla) Así que lo que se quiere conseguir es:
[20:59] (dsevilla) 1. Escribe sólo el código que implementa lo que quieres que el componente haga
[21:00] (dsevilla) 2. El sistema lo juntará todo en una DLL que será instlable en cualquier servidor de componentes
[21:00] (dsevilla) El componente especifica utilizando XML qué servicios requiere (persistencia, transaccioens, etc.)
[21:01] (dsevilla) Las aplicaciones, finalmente, se construyen ensamblando componentes.
[21:01] (dsevilla) Las aplicaciones dicen: necesito un componente que haga no sé qué cosa y tal otro que haga no se qué otra...
[21:01] (dsevilla) (todo esto especificando interfaces que requieren)
[21:02] (dsevilla) El servidor de componentes entonces carga en memoria la implementación de esos componentes requeridos y se los ofrece a la aplicación cliente
[21:02] (dsevilla) Mirad por ejemplo en http://ditec.um.es/~dsevilla/ccm/slide9.html
[21:02] (dsevilla) ahí tenéis un ejemplo de una red: clientes y servidores CCM
[21:03] (dsevilla) Un componente puede ser algo como esto:
[21:04] (dsevilla) component Button : GraphicControl {
[21:04] (dsevilla) provides Embeddable embed;
[21:04] (dsevilla) provides Printable print;
[21:04] (dsevilla) }
[21:04] (dsevilla) Es decir, un componente Button, hereda de GraphicControl
[21:04] (dsevilla) y ofrece los interfaces (además) Embeddable, con lo que se puede integrar dentro de un IDE
[21:04] (dsevilla) y printable, con lo que se puede imprimir
[21:05] (dsevilla) Es difícil explicar el CCM
[21:06] (dsevilla) pero básicamente, lo que intenta conseguir es que se puedan implementar unidades binarias que se puedan instalar en un servidor de componentes
[21:06] (dsevilla) sin tener que recompilar ni nada.
[21:06] (dsevilla) Esto permite que se cree un mercado de componentes
[21:06] (dsevilla) en el que empresas y particulares pueden "vender" componentes
[21:06] (dsevilla) Esos componentes pueden ser comprados por los clientes e instalarlos en sus servidores de aplicaiones
[21:07] (dsevilla) Esto es muy importante, ya que permite el sueño de escribir una vez y utilizar múltiples veces
[21:07] (dsevilla) además de no tener que implementar una y otra vez todos los servicios.
[21:07] (dsevilla) Al ser unidades binarias que se pueden traer y llevar e instalar fácilmente
[21:07] (dsevilla) permite crear lo que se llama un "mercado de componentes"
[21:08] (dsevilla) y básicamente, esto es todo lo que puedo contar...
[21:08] (dsevilla) CCM es muy complejo y tiene muchos entresijos. Aquellos que querais continuar,
[21:08] (dsevilla) podeis visitar la página que he hecho sobre el ccm
[21:08] (dsevilla) http://ditec.um.es/~dsevilla/ccm/
[21:09] (dsevilla) Bueno, Álvaro, quizá sería mejor que la gente nos preguntara y así aclarar las dudas que surjan...
[21:09] (dsevilla) porque el CCM es demasiado "conceptual" como para explicarlo en pocas palabras...
[21:09] (acs) perfecto ...
[21:10] (dsevilla) Bueno, así que... si queréis, contesto a cualquier pregunta...
[21:10] (dsevilla) aquí o en #qc...
[21:11] (ldipenti) Que tal es la performance de toda esta "burocracia" de objetos? :)
[21:11] (Ricardo) No
[21:11] (dsevilla) OH, el performance es muy bueno
[21:11] (Ricardo) Mejor preguntar ahora quí
[21:11] (dsevilla) el modelo de componentes permite especificar todas las características posibles de tus implementaciones
[21:12] (dsevilla) así que se generan stubs y skeletons (cabos y esqueletos) muy optimizados
[21:12] (dsevilla) y además, te genrera casi todo el código necesario
[21:12] (dsevilla) sólo te tienes que concentrar en el código de la funcionalidad real
[21:12] (dsevilla) el resto, como el uso de servicios de nombres, concurrencia, transacciones, etc. se encarga el
[21:12] (acs) El tiempo que se ahorra es brutal: reuso de código, menos pruebas ...
[21:13] (dsevilla) es igual que EJB, ¿quién conoce EJB?
[21:13] (ldipenti) Yo no se que es EJB...
[21:13] (WAPOWAPO) Enterprise Java Beans
[21:13] (dsevilla) Pues es el modelo de componentes de Java
[21:13] (ldipenti) pero pensandolo en un sentido de usar CORBA en Internet...creen que es posible a nivel de los tiempos de respuesta de hoy en dia?
[21:13] (acs) Yo miré alguna cosa de EJB hace algun tiempo ...
[21:14] (dsevilla) Yo creo que sí
[21:14] (dsevilla) De hecho, CORBA ha demostrado ser más rápido que CGI...
[21:14] (acs) desde luego
[21:14] (dsevilla) y ahora se utiliza CGI...
[21:14] (acs) La idea es cambiar HTTP/CGI por IIOP
[21:14] (acs) Netscape tiene soporte IIOP desde la versión 4
[21:14] (dsevilla) Tanto en el libro de Orfali como en mi proyecto http://ditec.um.es/cgi-bin/dl/proy.ps.gz se explica por qué
[21:15] (ldipenti) me bajare ese documento :)
[21:15] (dsevilla) Las peticiones de IIOP (que son las que comunican objetos CORBA) son como mensajes IP
[21:15] (dsevilla) se envían al objeto adecuado y éste produce una respuesta. Rápido y sencillo
[21:15] (dsevilla) No tienen que lanzar un nuevo proceso y producir una página web (como CGI)
[21:16] (dsevilla) La implementación se puede hacer con un applet que se comunique con un servidor CORBA con tráfico mínimo
[21:16] (acs) Sip, yo lo usé en el PFC y no tiene nada que ver con HTTP/CGI ...
[21:16] (acs) es mucho más dinámico
[21:16] (ldipenti) suena muy interesante!
[21:16] (dsevilla) El problema de CORBA es que en principio es difícil de explicar...
[21:17] (acs) Pero se ha llegado a extremos super sencillos para su uso ...
[21:17] (dsevilla) Sin embargo, con un par de ejemplos o así... se ve la diferencia
[21:17] (acs) Por ejemplo ...
[21:17] (dsevilla) Si te das cuenta, una vez que escribes el IDL (que es muy parecido a un interfaz C++), puedes utilizar
[21:18] (dsevilla) una implementación de ese interfaz desde cualquier lenguaje y desde cualquier host de internet
[21:18] (dsevilla) sin preocuparte de nada de red ni nada de eso.
[21:18] (acs) Perl y Python evitan el uso de compiladores de IDL lo que simplifica las cosas hasta límites insospechados ...
[21:18] (dsevilla) Tu haces llamadas locales objeto.método()
[21:18] (acs) http://barrapunto.com/escritorios/100/06/10/1113247.shtml
[21:18] (dsevilla) y el ORB se encarga de redirigirlas por la red...
[21:19] (dsevilla) Y con el CCM (componentes) todavía más sencillo
[21:19] (acs) Pero además, CORBA permite escapar de la interfaz web ....
[21:19] (dsevilla) porque sólo especificas el IDL que tus componentes implementan,
[21:19] (dsevilla) si quieres que los objetos se almacenen en una base de datos o no
[21:19] (dsevilla) y a correr: él te genera todo el soporte necesario
[21:19] (acs) puedes atacar los objetos CORBA desde el navegador, pero también desde clientes más simples ...
[21:20] (acs) El modelo de programación distribuida no tiene porqué pasar por navegadores !!!!
[21:20] (dsevilla) Por supuesto que no!!
[21:20] (dsevilla) Pero utilizar el mismo navegador con el que miras a internet es muy cómodo.. y esto también lo permite CORBA
[21:21] (dsevilla) Mirad por ejemplo en http://moriarty.dif.um.es/cqs-web/
[21:21] (acs) sip, pero limita la visión de la gente ...
[21:21] (trusmis) hablais de distribucion pero realmente corba no hace balanceo de carga no?, si da la casualidad de que todos las llamadas se hacen a los objetos de un ordena en un momento en concreto, los objetos no se van a lugares mas descargados no?
[21:21] (dsevilla) Pues se puede hacer sin ningún problema. De hecho hay servidores CORBA que lo hacen
[21:21] (acs) nop, eso no lo hace CORBA, pero sería trivial implementarlo ...
[21:22] (dsevilla) La dirección que os he dado es un cliente applet que accede a un servidor CORBA que le devuelve un "quote" del fortunes
[21:23] (dsevilla) Allí tenéis también el código del servidor y del cliente.
[21:23] (acs) ¿usa el ORB de Netscape?
[21:23] (dsevilla) No. Usa otro, por lo que, en principio, no funcionará con Netscape, sólo con IE :-(
[21:23] (acs) es decir, VisiBroker ...
[21:24] (dsevilla) Pero esto se soluciona instalando el plugin de jdk 1.3
[21:24] (ldipenti) ouch :(
[21:25] * ldipenti debe retirar...
[21:25] (ldipenti) gracias chicos por la conferencia! luego leere el resto en la web
[21:25] (ldipenti) me han dejado MUY interesado!
[21:25] (acs) :-)
[21:25] (dsevilla) En definitiva, utilizar CORBA, una vez aprendidos los cuatro conceptos fundamentales (que puede ser menos de un día)
[21:25] (ldipenti) Ya se el tema de estudio para estas vacaciones ;)
[21:25] (dsevilla) programar aplicaciones distribuidas es casi tan facil como escribir aplicaciones normales.
[21:25] (dsevilla) no te parece, álvaro?
[21:26] (acs) sip, desde luego ...
[21:26] (Ricardo) Hummm... Chicos, sé que aún queda tema para rato (y se podrá seguir hablando, si quieren), pero me temo que en algún momento tenemos que hacer "claqueta oficial" :)
[21:26] (dsevilla) muy bien... creo que la última frase es un buen colofón.
[21:26] (acs) ok, cuando digáis ...
[21:27] (Ricardo) Uséase que si me lo permiten, quisiera darle las gracias a dsevilla y a acs por su deferencia con Umeet al venir a darnos esta magnífica chalar/conferencia :)
[21:27] (Ricardo) Siéntanse libres de aplaudir ;)
[21:27] (acs) plas plasplasplasplasplasplasplasplasplasplasplasplasplasplas
[21:27] (dsevilla) plas plasplasplasplasplasplasplasplasplasplasplasplasplasplas
[21:27] (Martha) plas plas plas plas plas plas plas plas plas plas
[21:27] (Ricardo) clapclapclapclapclapclapclapclapclapclapclap
[21:27] (Ricardo) X)
[21:27] (dsevilla) ;-)
[21:27] (Ricardo) ;)
[21:28] (EfrenCA) plas plas plas plas plas plas ¡¡¡
[21:28] (ORLANDO) gracias !!
[21:28] (Ricardo) Siéntanse libres de seguir hablando :) Sólo era cuestión de liberar el canal :)
[21:28] (Ricardo) ;)))
[21:28] (dsevilla) bueno, gracias a vosotros por escuchar... se que me pongo un poco pesado... ;-)
[21:28] (acs) yo casi que voy a tener que partir ... ando ya cansado :-(
[21:28] (Ricardo) O:)
[21:28] (Ricardo) Venga acs
[21:28] (Princess) plasplas
[21:29] (acs) esto de teclear ....
[21:29] (acs) cansa más que hablar :-)
[21:29] (dsevilla) Bueno... dejadme hacer algo de publicidad... puedo?
[21:29] (dsevilla) Me refiero a cosas relacionadas con CORBA y de ambiente universitario ;-)
[21:29](MJesus) plas plas plas plas plas plas plas plas plas plas
[21:29](MJesus) clap clap clap clap clap clap clap clap clap clap
[21:29](MJesus) plas plas plas plas plas plas plas plas plas plas
[21:29](MJesus) clap clap clap clap clap clap clap clap clap clap
[21:29](MJesus) plas plas plas plas plas plas plas plas plas plas
[21:29](MJesus) clap clap clap clap clap clap clap clap clap clap
[21:29](MJesus) plas plas plas plas plas plas plas plas plas plas
[21:29](MJesus) clap clap clap clap clap clap clap clap clap clap
[21:29] (acs) claro !!!!!
[21:30] (Ricardo) Por supuesto dsevilla :)
[21:30] (acs) Que bonito aplauso :'-)))
[21:30] (dsevilla) Bueno, pues os podeis apuntar a la lista de CORBA y componentes software en español
[21:30] (dsevilla) http://moriarty.dif.um.es/mailman/listinfo/corba-comp
[21:30] (acs) eso, eso ...
[21:30] (dsevilla) y, si todavía os quedan fuerzas ;-), pasaos por la página del CCM:
[21:30] (Ricardo) :)
[21:30] (dsevilla) http://ditec.um.es/~dsevilla/ccm/
[21:31] * Ricardo no tiene fuerza ya casi ni de levantar su libro de CORBA
[21:31] (Ricardo) Es que pesa dos quintales el jodío! :P
[21:31] (dsevilla) En ella hay tutoriales que ayudan más a entender CORBA y el CCM
[21:34] (acs) Bueno chic@s has sido todo un placer ....
[21:34](MJesus) plas plas plas plas plas plas plas plas plas plas
[21:34](MJesus) clap clap clap clap clap clap clap clap clap clap
Y seguimos un buen rato más charlando...

Contact: