Todavía existe mucha información empresarial en aplicaciones mainframe a la que se accede usando consolas 3270 ó 5250. Si estos datos del mainframe estuviesen disponibles en un formato que permitiese que se los combine fácilmente con otros datos, ya sea que se encuentren dentro de la empresa o que estén disponibles en Internet, los usuarios de negocios podrían contar con la capacidad necesaria para captar estos datos con el objetivo de solucionar problemas de negocios usando una interfaz de navegación moderna y con muchas opciones. En este artículo, describimos un caso de uso en el que información financiera muy valiosa se encuentra "trabada" en una aplicación de datos 3270 y un encargado de préstamos desea extraer dichos datos para crear una nueva aplicación mashup basada en la Web. Un mashup es una aplicación Web liviana creada al combinar información o capacidades de más de una fuente existente con el objetivo de ofrecer datos y funciones nuevas. Las partes útiles de las aplicaciones de pantalla verde (3270) se pueden aislar, contener y, luego de esto, usar en un marco mashup con el objetivo de ofrecerle datos nuevos al usuario de negocios.

En primer lugar, los contenidos en los mainframe se deben formatear como fuentes de datos antes de que un marco mashup los pueda usar. Este artículo ofrece una guía paso a paso sobre cómo generar fuentes Atom para contenidos mainframe usando Rational® Host Access Transformation Services (HATS). El artículo de developerWorks® titulado "Use HATS to generate Atom feeds for mainframe applications", escrito por Ramakrishnan Kannan, Prasad Nagaraj y Saikrishna Vaidyanathan, nos muestra cómo crear fuentes Atom a partir de datos 3270. Este artículo amplia dicho concepto al ofrecer otro ejemplo y crear una aplicación Web situacional usando IBM Mashup Center.

Generalidades del escenario

Una encargada de préstamos de servicios financieros que trabaja para un banco tiene datos a los que necesita acceder para determinar si el titular actual de una cuenta bancaria puede obtener un préstamo para comprar un auto nuevo. En una aplicación mainframe 3270 de pantalla verde, la encargada de préstamos puede ver los saldos actuales de las cuentas que desee. Luego de esto, usa la aplicación Web para obtener la calificación crediticia del titular de la cuenta en cuestión. Otra aplicación le permite determinar la cantidad de informes de robos de autos registrados en el área geográfica de la persona que solicita el préstamo. En la actualidad, el analista de préstamos tiene que trabajar con tres aplicaciones diferentes para acceder a la información necesaria para determinar si el titular de cuenta está apto para recibir un préstamo para comprar un auto nuevo. Este artículo se concentra principalmente en la extracción de datos de la aplicación 3270. Se asume que el generador de fuentes de IBM Mashup Center ya transformó a la calificación crediticia y a los informes de robos de autos correspondientes a un área geográfica determinada en fuentes de datos o que esta información ya es accesible usando un navegador Web.

En la actualidad, se accede a la información sobre el saldo de cuenta por medio de una aplicación 3270, como se puede observar en la figura 1.

Usando IBM Rational Host Access Transformation Services (HATS), usted puede crear una fuente Atom. Esta fuente de datos luego se combina con otros datos para crear una aplicación de panel de control compuesto (como se puede observar en la figura 2) para el encargado de préstamos.

Volver arriba

Explicación de la fuente Atom de HATS

A continuación, incluimos una guía paso a paso y ejemplos de plantilla de código que usted puede utilizar para extraer datos de la aplicación 3270 y colocarlos en una aplicación mashup.

Creación de un proyecto HATS nuevo

Cree un proyecto Rational Host Access Transformation Services (HATS) nuevo con la configuración predeterminada. Siga los siguientes pasos:

1. Ingrese el nombre del host en la ventana Connections Settings (Configuración de conexiones). Todos los demás campos se completan de manera predeterminada. Modifíquelos de ser necesario. Presione Finish (Finalizar). La Figura 3 le muestra un conjunto de configuraciones de conexión. Su configuración puede ser diferente.
   
   
   
   Figura 3. Ventana Create a Connection (Crear una conexión) de HATS
   
   
   

Registración de un macro

Registre un macro para consultar información haciendo lo siguiente:

1. Presione el botón derecho del mouse sobre su conexión principal y seleccione Open HATS Host Terminal (Abrir HATS Host Terminal).Luego de esto, haga clic sobre main (principal).
   
   

   Debería poder observar la pantalla 3270 que aparece en la figura 4.

   
   
   Figura 4. Pantalla de inicio de sesión en 3270 dentro del entorno HATS Host Terminal
   
   
   
2. Presione el botón Record (Registrar) que se encuentra en la parte superior de la pantalla y elija un nombre para su macro.
3. Pase por el proceso que desea usar y seleccione las líneas que desea extraer en cada página presionando el botón Add Extract Action (Agregar Extraer). Vea la figura 5.
   
   
   
   Figura 5. Área de selección para extraer los datos de 3270
   
   
   
4. Seleccione la opción Extraction Format (Formato de extracción). Extraiga esta región como una lista de cadenas para cada acción de extracción con el objetivo de que cada línea constituya un ingreso diferente en una lista posterior. Todos los demás valores se configuran de manera predeterminada. Presione Finish (Finalizar).
   
   
   
   Figura 6. Edición de la ventana Extract (Extraer)
   
   
   

Creación de un Integration Object (Objeto de integración)

Cree un Integration Object (Objeto de integración) desde el macro siguiendo estos pasos:

1. Presione el botón derecho del mouse sobre su macro y seleccione la opción Create Integration Object (Crear objeto de integración).
2. Abra la nueva fuente Java™ debajo de Integration Object (Objeto de integración). Ésta tiene el mismo nombre que el macro. (Vea el código de muestra en el listado A-1 que figura en el anexo de este artículo.)
3. Observe el HAOVariables definido cerca de la parte superior de la pantalla. Cambie el último argumento en cada una de sus instanciaciones de HAO_VARIABLE_SIMPLE a HAO_VARIABLE_ARRAY. Esta modificación le permite obtener el conjunto de líneas extraídas en vez de una única cadena que combina las líneas en cuestión. Cambie el argumento de la siguiente manera:
   
   
   • De:
     HAOVariable inquiry1 =
new HAOVariable("","inquiry1","inquiry1",false,"",0,0,63,7,HAO_VARIABLE_SIMPLE);
   • A:
     HAOVariable inquiry1 =
new HAOVariable("","inquiry1","inquiry1",false,"",0,0,63,7,HAO_VARIABLE_ARRAY);
4. Ahora, agregue un Captador de tipo vector para cada array que devuelve your_inquiry.oMultiValues. Por ejemplo, observe el código que figura en el listado 1.

                public Vector getInquiry1AsVector() {
                hPubErrorOccurred = 0; if (HPubTracingOn)
                { Ras.trace( className, "getInquiry1
                array: ", inquiry1.stringValue); } return (inquiry1.oMultiValues); }

Creación de páginas Web Modelo 1

Luego de esto, cree páginas Web Modelo 1 desde su Integration Object (Objeto de integración) presionando el botón derecho del mouse sobre su objeto de integración y seleccionando la opción Create Model 1 Web Pages (Crear páginas Web Modelo 1). Vea la figura 7.

Use la configuración predeterminada que aparece en pantalla y presione Finish (Finalizar) para crear una página JSP en Model 1 Pages (Páginas Modelo 1).

Modificación de la página JSP

Luego, modifique la página JSP para que envíe la fuente Atom. Siga los siguientes pasos:

1. Ahora, usted tiene una página JSP en Web Content - Model 1 Pages (Contenidos Web - Páginas Modelo 1). Haga doble clic aquí para dirigirse hacia la fuente.
2. Usando como guía el archivo JSP provisto, InquiryMacroOutput.jsp (como se puede observar en el listado A-2 en el anexo de este artículo), reemplace el código JSP por su propio código que envía una fuente Atom. No preste atención a las advertencias sobre la parametrización de ArrayList porque JSP no realiza ningún tipo de parametrización.

Prueba de la página JSP

Pruebe la página JSP dirigiéndose hacia su punto final y observando la fuente Atom.

Si usa el navegador Microsoft® Internet Explorer, su página debería incluir el texto que aparece en la figura 8.

¿Cómo agregar la fuente Atom nueva?

Para agregar la fuente Atom nueva a IBM InfoSphere™ MashupHub, siga los siguientes pasos:

1. Abra InfoSphere MashupHub y haga clic sobre New Feed (Fuente nueva) en la sección Create (Crear) de la página de inicio de MashupHub.
2. Seleccione el RSS o el Atom Feed (Registración) ya existente que figura bajo “departmental” en la lista que se visualiza, como se puede observar en la figura 9. Presione Next (Siguiente).
   
   
   
   Figura 9. Panel de creación de la fuente nueva dentro de IBM Mashup Center
   
   
   
3. Ingrese la URL de la página JSP que creó y luego presione Next (Siguiente). Vea la figura 10.
   
   
   
   Figura 10. Especifique la URL de la fuente Atom dentro de la ventana de creación de la fuente MashupHub
   
   
   
4. Elija Title (Título) y Description (Descripción) para la nueva fuente y todas las etiquetas que quiera asociar a la fuente en cuestión. Luego de esto, presione Finish (Finalizar).
5. Se acaba de guardar la fuente en InfoSphere MashupHub Catalog. Usted puede agregarla a IBM Lotus Mashups seleccionando la opción Add to Lotus Mashups (Agregar a Lotus Mashups).
6. Ingrese la ubicación de su servidor Lotus Mashups. Luego de esto, presione Next (Siguiente).
7. Además, también puede cambiar las siguientes opciones: Title (Título), Description (Descripción), Category (Categoría) o Feed Viewer (Visualizador de fuente). Luego de esto, presione Finish (Finalizar).

Creación de un mashup en Lotus Mashups usando su fuente

Siga estos pasos para crear un mashup en Lotus Mashups usando su fuente:

1. Abra Lotus Mashups y, opcionalmente, abra una página nueva para su mashup.
2. Presione el botón Go to Edit (Ir a editar) para comenzar a crear su mashup.
3. Seleccione su fuente de la barra de herramientas. De manera predeterminada, se visualiza en la opción Collaboration (Colaboración) en la barra de herramientas, como se puede observar en la figura 11. Arrastre la fuente hasta la página. Modifique el tamaño de ser necesario.
   
   
   
   Figura 11. Widget visualizador de datos dentro del Mashup Center que muestra los datos 3270 de la fuente Atom
   
   
   
4. Presione la opción Favorites (Favoritos) en la barra de herramientas y agregue OpenStreetMap y todos los demás widgets que desee usar en su aplicación mashup. En el caso de nuestro ejemplo, hay fuentes que brindan el Credit Report History (Historial del informe crediticio) y los Car Theft Reports (Informes de autos robados) correspondientes a un área geográfica determinada. Se usan los widgets OpenStreetMap y Website Displayer. Conecte los elementos de la tabla de datos 3270 con estos widgets nuevos para crear una aplicación personalizada con el objetivo de ocuparse de sus necesidades de negocios.
5. Cuando se hace clic sobre un elemento de la fuente, usted debería poder ver la información correspondiente relativa a los autos robados en el mapa y la información relativa a los informes crediticios en el widget Website Displayer (Visualizador de página Web), como se puede observar en la figura 12.
   
   
   
   Figura 12. Aplicación mashup completa del panel de control del encargado de préstamos
   
   
   

Volver arriba

Conclusión

IBM Mashup Center y Rational Host Access Transformation Services le permiten potenciar los datos que, actualmente, están trabados en las aplicaciones 3270 ó 5250 y usar estos datos para otras aplicaciones basadas en la Web. Este artículo ofrece una guía paso a paso sobre cómo extraer los datos 3270 y crear una nueva aplicación mashup situacional. Se brindan plantillas de código que usted puede personalizar con el objetivo de extraer datos desde una gran variedad de aplicaciones 3270.

Volver arriba

Anexo: Listas de códigos

import java.util.Vector; import
                com.ibm.HostPublisher.IntegrationObject.*; 
                import com.ibm.HostPublisher.Server.Ras;
                public class InquiryMacro extends HPubHODCommon
                { public static float
                getIOTemplateVersion() { return 7.0F; } 
                // Template version - HATS 7.0 public static
                String getIOTemplateType() { return "-DEFAULT"; } 
                // Template type - Host Default
                public static String getIOVersionInfo() { return "(IBM)"; }
                // Version info - IBM
                supplied public static String getIOTemplateRevision() { return ":1.1"; 
                }
                // Template
                revision per version - internal value 
                public String hPubIOVersion=
                getIOBaseVersion()+";"+getHPubBeanType()+
                getIOTemplateType()+getIOTemplateVersion()+
                getIOTemplateRevision()+getIOVersionInfo(); 
                public String getIOVersion() { return
                hPubIOVersion; } 
                // Generated Objects altered to export their data as
                //HAO_VARIABLE_ARRAY
                instead of HAO_VARIABLE_SIMPLE HAOVariable inquiry1 = new
                HAOVariable("","inquiry1","inquiry1",false,"",0,0,63,7,
                HAO_VARIABLE_ARRAY);
                HAOVariable inquiry2 = new
                HAOVariable("","inquiry2","inquiry2",false,"",0,0,63,7,
                HAO_VARIABLE_ARRAY);
                HAOVariable inquiry3 = new
                HAOVariable("","inquiry3","inquiry3",false,"",0,0,63,7,
                HAO_VARIABLE_ARRAY);
                HAOVariable inquiry4 = new
                HAOVariable("","inquiry4","inquiry4",false,"",0,0,63,7,
                HAO_VARIABLE_ARRAY);
                HAOVariable inquiry5 = new
                HAOVariable("","inquiry5","inquiry5",false,"",0,0,63,7,
                HAO_VARIABLE_ARRAY);
                **************************************************** ********
                Automatically
                Generated Code Not Shown ********
                **************************************************** /* 
                Added Getters to return the
                inquiries as a Vector */ public Vector getInquiry1AsVector() { return
                (inquiry1.oMultiValues); } public Vector getInquiry2AsVector() { return
                (inquiry2.oMultiValues); } public Vector getInquiry3AsVector() { return
                (inquiry3.oMultiValues); } public Vector getInquiry4AsVector() { return
                (inquiry4.oMultiValues); } public Vector getInquiry5AsVector() { return
                (inquiry5.oMultiValues); }

<%@ page
                contentType="text/html;charset=UTF-8"errorPage="
                ../BasicIOErrorPage.jsp"%>
                <%@ page import="com.ibm.hats.runtime.*,
                javax.xml.parsers.DocumentBuilder,
                javax.xml.parsers.DocumentBuilderFactory,
                javax.xml.transform.OutputKeys,
                javax.xml.transform.Transformer, 
                javax.xml.transform.TransformerFactory,
                javax.xml.transform.dom.DOMSource, 
                javax.xml.transform.stream.StreamResult,
                org.w3c.dom.Document,org.w3c.dom.Element, 
                org.w3c.dom.Text, java.io.StringWriter,
                java.util.ArrayList, java.util.Vector,
                java.util.Date"%> <%@ taglib
                uri="hats.tld" prefix="HATS"%> 
                <% IOGV.process(request); %>
                <jsp:useBean id="InquiryMacro" 
                type="IntegrationObject.InquiryMacro"
                class="IntegrationObject.InquiryMacro"
                scope="request">
                <jsp:setProperty name="InquiryMacro"
                property="*" />
                </jsp:useBean> <% 
                //Use the Integration Object that is
                instantiated above
                //to get data from the 3270 machine.
                InquiryMacro.doHPTransaction(request, response); try
                { // Build the feed to return
                from the page here. 
                // A well-formed Atom Feed should contain the // following: A
                root "feed" element with "title", 
                // "updated", "author" (containing "name" and
                "email"), and "id" 
                // Create new feed factory DocumentBuilderFactory feedFactory =
                DocumentBuilderFactory.newInstance();
                // Create a new feed builder from the
                feedFactory DocumentBuilder feedBuilder = 
                feedFactory.newDocumentBuilder(); //
                Create a new document from the feed builder Document doc =
                feedBuilder.newDocument(); 
                // Create the root "feed" Element for the Atom Feed
                Element root = doc.createElementNS
                ( "http://www.w3.org/2005/Atom", "feed");
                doc.appendChild(root);
                // Create the "title" element for the Atom Feed Element title
                = doc.createElement("title"); 
                // Append the title to the root element
                root.appendChild(title);
                // Create a text node for the title element Text titleText
                = doc.createTextNode("Sample Feed from HATS");
                // Append the text to the title node
                title.appendChild(titleText); 
                // Create the "updated" element for the root of the
                Atom Feed Element updated = doc.createElement("updated");
                root.appendChild(updated);
                Text updateText = doc.createTextNode(new Date().toString());
                updated.appendChild(updateText); 
                // Create the "author" element for the root of the
                Atom Feed Element author = doc.createElement("author"); 
                // Created the "name"
                element for under the author element Element name =
                doc.createElement("name"); //
                Create the "email" element for 
                under the author element Element email =
                doc.createElement("email"); name.setTextContent("IBM Hats");
                email.setTextContent("ibm@us.ibm.com"); 
                // Append the name and email to the author
                author.appendChild(name); author.appendChild(email); 
                // Append the author element to
                the root root.appendChild(author); 
                // Create the "id" element for the root of the
                Atom Feed Element id = doc.createElement("id");
                id.setTextContent("http://www.ibm.com/root"); root.appendChild(id); 
                // Add all of
                the inquiries to an array to loop through 
                // and construct the body of the Atom Feed
                ArrayList inqueries = new ArrayList();
                inqueries.add(InquiryMacro.getInquiry1AsVector());
                inqueries.add(InquiryMacro.getInquiry2AsVector());
                inqueries.add(InquiryMacro.getInquiry3AsVector());
                inqueries.add(InquiryMacro.getInquiry4AsVector());
                inqueries.add(InquiryMacro.getInquiry5AsVector()); 
                // Create multiple "entry"
                elements from the inquiries 
                // and add them to the root "feed" 
                // A well-formed
                entry element should contain title, 
                // link, id, updated, and content for (int i =
                0; i < 5; i++) { 
                // Get the vector of strings from the array JSP can't
                // have parameterized types so it
                must be generic Vector inquiry = (Vector)
                inqueries.get(i); /
                / Create the top element for the new Entry Element entry =
                doc.createElement("entry"); 
                // Append the entry to the root "feed" element
                root.appendChild(entry);
                //Create and append the title element to the Entry Element
                titleEntry = doc.createElement("title"); 
                titleEntry.setTextContent("Entry #" + i);
                entry.appendChild(titleEntry);
                //Create and append the link element to the Entry
                Element link = doc.createElement("link"); 
                link.setAttribute("href",
                "http://www.ibm.com"); entry.appendChild(link); 
                //Create and append the id element
                to the Entry id = doc.createElement("id"); 
                id.setTextContent("http://www.ibm.com/id"
                + i); entry.appendChild(id); 
                //Create and append the updated element to the Entry
                Element updatedEntry = doc.createElement("updated");
                entry.appendChild(updatedEntry); 
                Text updateEntryText = doc.createTextNode(new
                Date() .toString()); 
                updatedEntry.appendChild(updateEntryText); Element summaryEntry
                = doc.createElement("content"); 
                //******* If you plan on having html content here,
                you should set 
                //******* the type attribute to html so it will display correctly
                //******* by uncommenting the following lines 
                //summaryEntry.setAttribute("type",
                "html"); 
                //summaryEntry.setAttribute("mode", "escaped");
                // Create and append any
                data nodes from your inquiry to 
                // the content node of the entry Element record =
                doc.createElement("Number");
                record.setTextContent(inquiry.get(0).toString().trim());
                summaryEntry.appendChild(record);
                Element uname = doc.createElement("Name");
                uname.setTextContent(inquiry.get(1).toString().trim());
                summaryEntry.appendChild(uname);
                Element address = doc.createElement("Address");
                address.setTextContent(inquiry.get(2).toString().trim());
                summaryEntry.appendChild(address); 
                Element phone = doc.createElement("Phone");
                phone.setTextContent(inquiry.get(3).toString().trim());
                summaryEntry.appendChild(phone);
                Element date = doc.createElement("Date");
                date.setTextContent(inquiry.get(4).toString().trim());
                summaryEntry.appendChild(date); 
                Element amount = doc.createElement("Amount");
                amount.setTextContent(inquiry.get(5).toString().trim());
                summaryEntry.appendChild(amount);
                Element comment = doc.createElement("Comment");
                comment.setTextContent(inquiry.get(6).toString().trim());
                summaryEntry.appendChild(comment); 
                // Append the content element to the entry
                element entry.appendChild(summaryEntry); } 
                // The following block transforms the
                Feed into a consumable 
                // string for the out.print TransformerFactory
                feedTransformerFactory = TransformerFactory.newInstance();
                Transformer
                feedTransformer = feedTransformerFactory.newTransformer();
                feedTransformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
                feedTransformer.setOutputProperty(OutputKeys.INDENT, "yes"); 
                StringWriter sw = new
                StringWriter(); StreamResult result = new StreamResult(sw); 
                DOMSource source = new
                DOMSource(doc); feedTransformer.transform(source, result); 
                //Print out the
                constructed feed xml as the content of the page 
                out.print(sw.toString()); } catch
                (Exception e) { System.out.println(e); } %>

Recursos

Aprender

• Lea el artículo de developerWorks titulado “Uso de HATS para generar fuentes Atom para aplicaciones mainframe”, escrito por Ramakrishnan Kannan, Prasad Nagaraj y Saikrishna Vaidyanathan. Este artículo presenta excelentes fundamentos sobre cómo crear fuentes Atom desde los datos 3270.
  
  
• Conozca más sobre Rational Host Access Transformation Services (HATS). Gracias a HATS, usted puede ampliar sus aplicaciones host 3270 y 5250 hacia la Web, un portlet, un cliente rico o los navegadores en los dispositivos móviles de manera rápida, fácil y muy poco riesgosa. Además, usted puede descargar una versión de prueba.
  
  
• Lea el tutorial titulado Creating a Web Service using HATS (Creación de un servicio web usando HATS). Este laboratorio le enseña a usar HATS para crear un servicio web que presenta la lógica incluida en una aplicación de pantalla verde System i 5250. Este laboratorio presenta las nuevas características de la versión V7.1 (que incluyen las nuevas herramientas Visual Macro Editor).
  
  
• Vea HATS Help Documentation (Documentación de ayuda de HATS). Lea todas las generalidades de HATS.
  
  
• Conozca más sobre IBM Mashup Center. Descubra una solución mashup de negocios fácil de usar que soporta el ensamblaje de aplicaciones situacionales dinámicas por parte de la línea de negocios (con las capacidades de gestión, seguridad y gobernabilidad que requiere TI). Los desarrolladores pueden descargar una versión de prueba completamente gratuita.
  
  
• Lea el wiki de Mashup Center, que incluye artículos sobre cómo instalar, administrar, implementar y usar IBM Mashup Center (junto con tutoriales para los usuarios nuevos).
  
  
• Mire el video que complementa este artículo.
  
  

Obtener los productos y tecnologías

• Descargue una versión de prueba de IBM Mashup Center usando la versión de prueba online que se encuentra en la página Web de IBM Lotus Greenhouse.
  
  

Comentar

• Participar en el foro de debate.
  
  
• Conéctese con HATS HotSpot Community (Comunidad HATS HotSpot). Conéctese con la comunidad HATS para conocer todas las novedades, compartir sugerencias y consejos, obtener ayuda cuando no sepa qué hacer y mantener diálogos con el equipo de HATS en relación con lo que le gusta, lo que no le gusta y lo que necesita.
  
  

Sobre los autores

John Feller es gerente del equipo IBM Emerging Technologies Toolkit Development. Se encarga de gestionar un equipo creativo y dinámico de desarrolladores que inventa, diseña y desarrolla soluciones innovadoras que luego pasan a estar disponibles en alphaWorks. En la actualidad, se encuentra investigando las mejores prácticas necesarias para construir comunidades online usando tecnologías Web 2.0, como wikis, blogs, tagging e interfaces de usuario Ajax. Se recibió de licenciado en ciencias de la computación en la Universidad de Dayton y es Master en informática y ciencias de la computación de la Universidad del Estado de Ohio. Además, tiene una Maestría en Administración de Negocios de la Universidad de Carolina del Norte, Chapel Hill, y se recibió de Gerente de Proyectos Profesional en el Project Management Institute.

Chris Gladd está cursando Ciencias de la Computación en la Universidad del Estado de Pennsylvania. En la actualidad, es uno de los colaboradores del equipo IBM jStart Emerging Technologies y cuenta con más de tres años de experiencia en el desarrollo de software.

Califique este artículo

Comentario

Volver arriba

Tabla de contenidos

• Generalidades del escenario
• Explicación de la fuente Atom de HATS
• Conclusión
• Anexo: Listas de códigos
• Recursos
• Sobre los autores
• Comentarios