Un investigador del Instituto de Fisiología Celular de la Universidad Nacional Autónoma de México ha desarrollado un nuevo software con el que poder determinar las funciones proteínicas a través del análisis tridimensional. El nuevo sistema ha sido diseñado por un matemático francés, un programador estudiante de bioinformática y un médico norteamericano.

Una de las ventajas que ofrece este nuevo sistema es la posibilidad de diseñar un nuevo fármaco capaz de controlar las funciones que desempeña. Una simulación permite conocer como actúa una determinada proteína gracias al conocimiento de su estructura, según indica el investigador Gabriel del Río, es como si simplemente viendo a una persona pudieras conocer cual es la función que desempeña. .

Hasta ahora, el mejor método que se empleaba para determinar la función proteínica, se realizaba a través de comparaciones y similitudes. La acción desempeñada de un determinado gen en una mosca se comparaba con la acción de un gen similar en el cuerpo humano asumiendo que ambos genes desempeñaban la misma función, pero este método sólo ha determinado el 50% de los genes.

El programa se denomina JAMMING (Java-based Multi-threaded Minimum Interactive Networks –Graphical User Interface–) y puede ser consultado o descargado por cualquier internauta para realizar distintos análisis proteínicos, así debería ser la ciencia, libre y al alcance de todo el mundo.

Vía | Terra
Más información | Universidad Nacional Autónoma de México
Más información | JAMMING
En Genciencia | El código genético

El mecanismo de funcionamiento es muy sencillo: un usuario que tenga esta camiseta puesta y un accesorio Bluetooth conectado a un móvil, al que vamos a llamar emisor, puede enviar un mensaje de abrazo con la información recopilada por sus sensores a otro móvil, el del receptor, que mandará el abrazo a la camiseta receptora. El abrazo generado depende de la temperatura corporal y ritmo cardíaco, entre otros factores, del emisor.

También se puede enviar un abrazo si el emisor no tiene la camiseta mediante un programa apto para móviles Java.

No tiene ningún problema para lavarse, ya que los sensores se pueden quitar, y está disponible en varios colores. Lleva pilas y no es tóxica.

Con esta idea no se pretende reemplazar el contacto humano, sino acortar las barreras en el caso de que uno de los amigos o familiares se encuentre lejos por trabajo o estudios. Así se puede aliviar la depresión, ya que el ser humano necesita ser tocado 70 veces al día como mínimo.

Vía | Cute Circuit

• Parseador: Es la clase que se encarga de leer el documento XML. Esta clase contiene varios métodos por defecto: inicioElemento(Avisa que se ha encontrado una etiqueta registro, y de paso almacenamos el atributo definido en ella), finElemento (Tratamos los datos, en nuestro caso almacenamos en el objeto Vector) y characters (recibe la ubicación de los caracteres del elemento y los extraemos almacenándolos en una cadena). En realidad inicioElemento y finalElemento son una versión simplificada de los métodos startElement y endElement. De aquí sacaremos una colección con los datos que hayamos leído durante el proceso de lectura. En la variable valor se irá guardando una cadena que contiene los datos extraídos, es decir, los datos que tendremos que almacenar en la colección. El código es el siguiente:

  import org.xml.sax.helpers.DefaultHandler;
  import org.xml.sax.Attributes;
  import java.util.Vector;
  import org.xml.sax.*;
  import org.xml.sax.helpers.*;
  
  
  	
  public class Parseador extends DefaultHandler  {
    private Vector coleccion; 
    private Acciones actual; 
    private String valor; 
  
    public Parseador (Vector coleccion) {
       this.coleccion = coleccion; 
    }
  
    /*
    localName: contiene el nombre de la etiqueta.
    att: de la clase "org.xml.sax.Attributes",
    es una tabla que contiene los atributos
    contenidos en la etiqueta.
    */
    public void startElement( String namespaceURI,
             String localName, String qName,
             Attributes attr ) throws SAXException {
  
       inicioElemento(localName, attr);
    }
  
    public void endElement (String namespaceURI,
             String localName, String rawName)
             throws SAXException {
        finElemento(localName);
    }
  
     public void inicioElemento(String nombreElemento,
              Attributes atributo) throws SAXException {
  
        if (nombreElemento.equals("entrada")) {
          actual = new Acciones (); 
          coleccion.addElement(actual); 
          actual.setID(
               Integer.parseInt(atributo.getValue("id"))); 
        }
      }
  
      public void finElemento(String nombreElemento)
               throws SAXException {
  
          if (nombreElemento.equals("nombre")){ 
            actual.setNombre (valor);
          } else if (nombreElemento.equals("telefono")) {
            actual.setTelefono (Integer.parseInt(valor)); 
          }
      }
  
      public void characters (char[] ch, int start, int end)
      {
  
         valor = new String (ch, start, end);
         valor = valor.trim();
      }
  }
  

• Acciones: La clase Acciones contiene sencillos métodos get y set utilizando en la aplicación. Viene dada por el siguiente código:

  public class Acciones {
  
     private String documento;
     private String nombre;
     private int telefono;
     private int id;
  
     public void setNombre (String nombre) {
        this.nombre = nombre;
     }
  
     public void setTelefono (int telefono) {
        this.telefono = telefono;
     }
  
     public void setID (int id) {
        this.id = id;
     }
  
     public void setDocumento(String documento) {
        this.documento = documento;
     }
  
      public String getNombre() {
         return nombre;
      }
  
      public int getTelefono()  {
         return telefono;
      }
  
       public int getID() {
         return id;
       }
  
       public String getDocumento() {
         return documento;
       }
  }
  

• Index: Es la clase que contiene el main e invoca a las demás clases. Su código es el que se muestra a continuación:

  import java.util.Vector;
  import org.xml.sax.XMLReader;
  import org.xml.sax.SAXException;
  import org.apache.xerces.parsers.SAXParser;
  import org.xml.sax.*;
  
  	
  public class Index {
  
    Vector coleccion = new Vector ();
    Acciones acciones = new Acciones ();
    XMLReader parser = new SAXParser();
  
   public void ParsearDocumento () throws Exception {
  
        String nombre_de_archivo;
        acciones.setDocumento("index.xml"); 
        nombre_de_archivo=acciones.getDocumento(); 
        parser.setContentHandler(new Parseador(coleccion));
        parser.parse(nombre_de_archivo); 
        Interfaz contenedor = new Interfaz(coleccion);
   }
  
   public static void main(String[] args) throws Exception {
  
        Index ejecutar = new Index();
        ejecutar.ParsearDocumento();
   }
  
  	
  }
  

• Interfaz y Conclusión: La clase Interfaz es la que se encarga de crear la interfaz gráfica dónde se mostrarán los datos en pantalla. La clase Conclusión es una clase auxiliar de Interfaz.

  import java.util.Vector;
  import java.awt.FlowLayout;
  import java.awt.Frame;
  import java.awt.List;
  import java.awt.MenuBar;
  import java.awt.Menu;
  import java.awt.MenuItem;
  import java.awt.Event;
  import java.awt.*;
  import java.awt.image.ImageObserver;
  
  
  	
  public class Interfaz {
  
     public Interfaz(Vector datos) {
  
        int i;
        Acciones[] inserta=new Acciones[datos.size()]; 
        List miLista = new List(15,false);
  
        for(i=0;i<datos .size();i++) {
           inserta[i]=(Acciones)datos.elementAt(i);
           miLista.add(inserta[i].getID()+"."
              <ins>inserta[i].getNombre()</ins>
              " - "+inserta[i].getTelefono());
        }
  
        Frame miFrame = new Frame("Agenda Electrónica XML");
        miFrame.setLayout(new FlowLayout());
        miFrame.add(miLista);
        miFrame.setSize(200,275);
        miFrame.setVisible(true); 
        miFrame.addWindowListener(new Conclusion());
  
     }
  }
  

  import java.awt.*;
  import java.awt.event.*;
  
  	
  public class Conclusion extends WindowAdapter {
      public void windowClosing( WindowEvent evt ) {
           System.exit(0);
      }
  
  }
  
  

  
  

Podemos parsear un documento XML de dos modos: usando SAX o DOM. Podemos distinguir a grandes rasgos el funcionamiento de cada modo de parseo de la siguiente forma:

• DOM: DOM crea un árbol jerárquico en memoria que contiene el todo documento XML, y con él en memoria podemos hacer realizar cualquier tipo de recorrido, movimiento o acción con los elementos que deseemos.


• SAX: SAX significa Simple API for XML. Se usa para realizar un recorrido secuencial de los elementos del documento XML, es decir, vamos tratando la información a la vez que la vamos leyendo.

SAX es menos potente que DOM, pero aún así es más rápido y útil para los casos donde por ejemplo interesa hacer una lectura secuencial o buscar algún fragmento en un documento.

Para mostrar el funcionamiento de un parser de XML, crearemos una pequeña aplicación donde leeremos el contenido de un documento XML usando SAX y lo mostraremos en pantalla. Para escribir el programa usaremos Java, aún así lo podriamos hacer en cualquier otro C++, PHP, Python, ...

Nuestra aplicación parseará el siguiente documento XML de ejemplo, que se trata de una agenda que almacena el nombre y el número de teléfono de cada registro insertado.

< ?xml version="1.0"?>
<agenda>
   <entrada id="1">
      <nombre> Javier </nombre>
      <telefono> 956425981 </telefono>
   </entrada>
   <entrada id="2">
      <nombre> Fran </nombre>
      <telefono> 645675431 </telefono>
   </entrada>
   <entrada id="3">
      <nombre> Alfonso </nombre>
      <telefono> 660137258 </telefono>
   </entrada>
   <entrada id="4">
      <nombre> Manuel </nombre>
      <telefono> 625435431 </telefono>
   </entrada>
   <entrada id="5">
      <nombre> Paco </nombre>
      <telefono> 630603804 </telefono>
   </entrada>
</agenda>

Para parsear el documento usaremos JAXP y Xerces. JAXP (Java API for XML Processing) es un conjunto de clases que permite a las aplicaciones en Java parsear y transformar documento XML independientemente del modo de procesamiento utilizado. La razón de la existencia de JAXP es facilitar el uso de XML en la plataforma Java, garantizando que una aplicación escrita en Java orientanda hacia un parser con soporte JAXP puede ser migrado a otro sin ningún problema. Xerces es un parseador desarrollado por la fundacion Aparche.org disponible para Java y C++. Para escribir nuestro programa usaremos Xerces.

Mañana continuaremos con la segunda parte Parseando XML con Java (II) donde mostraré la implementación de las clases necesarias y subiré el código de fuente.