cout << “Facilitando Topcoder” << endl;

0 Comentarios Publicado por Román González 21 Julio 2008 en Herramientas, c++. english • español

Despues de culminada mi epoca de maratones de la ACM, mi equipo (Guayoyo) y yo empezamos a llenar el vacio de competencias participando en TopCoder.

La lógica de TopCoder es un poco distinta a la de los maratones de programación de la ACM, entre las diferencias encontramos que, existe un sistema diferente de evaluación de problemas (por puntajes y tiempo), e incluso de formato en el código fuente (Se definen reglas estrictas acerca de los nombres de las clases y métodos).

Para ingresar en TopCoder es necesario tener Java instalado en nuestra maquina, ya que funciona mediante Applets o Java Web Start (el cual recomiendo). A pesar de que el sistema (de ahora en adelante “la arena”) funcione muy bien, la parte de edición de código fuente no es la mas idonia para trabajar en competencias bajo presión.

Para solucionar este problema, los programadores de TopCoder ofrecieron la posibilidad de implementar Plugins que se adaptan a la arena y permiten mejorar los editores de texto (o incluso no usarlos del todo). A continuación explicaremos como instalar y configurar algunos Plugins para mejorar nuestra productividad a la hora de realizar competencias dentro de TopCoder.

  1. Obtener el archivo .jws que carga la arena en nuestro computador

    Para obtener la aplicación de la arena, debemos acceder a este link (Como indicamos anteriormente, se debe tener Java instalado para que este funcione).

    Descargar la arena

  2. Ingresar al sistema (o registrarse en caso de que no nos encontremos registrados)

    En el caso de que no se encuentre registrado en el sistema, siga las indicaciones de la aplicación para registrarse

  3. Descargar los Plugins que harán tu vida más fácil

    Entre los Plugins que puedo recomendar, se encuentran CodeProcessorv2.0, FileEdit y moj

  4. Configurar los plugins dentro de la arena

    Para instalar los Plugins dentro de la arena se deben seguir los siguientes pasos:

    • Acceder al menú de “Options” y luego la opción “Editor”

      Options then Editor

    • Al abrirse la ventana de editores, debe presionar click en el botón “Add”, esto abrira otra ventana donde deben ingresar el nombre del editor (CodeProcessor en nuestro caso), en el campo EntryPoint, debemos colocar “codeprocessor.EntryPoint”, y en el campo classpath, al presionar el botón “Browse” debe buscar todos los Plugins (archivos .jar) que descargo en el paso anterior

      Configuración del Editor

    • Una vez instalado el nuevo editor, presionamos click en el botón “Configure”, se abrirá una nueva ventana donde se debe especificar en el campo “Editor EntryPoint” el valor “fileedit.EntryPoint”, luego presionamos el botón “Add” y en la nueva fila creada asignamos el valor “moj.moj”. Lo que hacemos aquí, es usar CodeProcessor como un manejador de Plugins, que permite usar varios Plugins (en este caso FileEdit y moj) simultaneamente.

      CodeProcessorConfig

    • Para configurar los plugins de FileEdit y moj, se debe presionar a los botones “Configure”, ahi se tendrán diferentes opciones dependiendo de cada Plugin

      ConfiugreButtons

    • Para finalizar, ingrese a la configuración de FileEdit, y en la pestaña de “Code Template”, en la opción de C++, ingrese el siguiente contenido 

      $BEGINCUT$

/*
$PROBLEMDESC$
*/

$ENDCUT$

#line $NEXTLINENUMBER$ "$FILENAME$"
#include "string"
#include "vector"
#include "algorithm"
#include "map"
#include "iterator"
#include "iostream"
#include "sstream"
#include "cstdio"
#include "cmath"
#include "cstdlib"
#include "queue"
#include "stack"

using namespace std;

class $CLASSNAME$ {

  public:

  $RC$ $METHODNAME$($METHODPARMS$) {

  }
};

$BEGINCUT$
$TESTCODE$ 

$DEFAULTMAIN$
$ENDCUT$

      Configuracion FileEdit

  5. Ahora… a programar

    Una vez instalados y configurados los Plugins, al momento de abrir un problema dentro de la arena, verá que el editor de texto no se encuentra en el programa de la arena, mas bien se muestra un log de acciones. Lo que ocurre es que el contenido del problema es descargado, y con este se genera un archivo que contendrá el enunciado del problema, junto con una implementación que contiene el template establecido en la configuración del FileEdit (que cambiará dependiendo del problema) y un main que ejecuta las pruebas del problema.

    Coding Area

Pero espere… hay más

Si se encuentra en Mac OS X, puede usar este script que implementé (basado en rstakeout) que se encarga de compilar y ejecutar los archivos .cpp modificados, y luego mandar mensajes via Growl. En el momento que el programa cumpla con todas las pruebas exitosamente, saldrá un mensaje diciendo “Send It”. Para enviarlo, sólo debes presionar el botón “Compile” en la arena, y luego al botón “Submit” (Reflejados en la figura anterior).

notificación

La carita verde es una imagen que configuré manualmente, si quieren tener algo parecido por favor revisen el código fuente y establezcan el lugar donde se encuentra la imagen que quieren usar, las caritas se encuentrán aquí.

Espero que estos tips les ayuden a mejorar su rendimiento en TopCoder…

¡Java es Socialista!

1 Comentario Publicado por josevnz 23 Junio 2008 en General. english • español

O capitalista, o Marxista, o Comunista o arroz con mango.

Es lamentable que a una herramienta de desarrollo de software o a un lenguaje se le tilde de esto o de aquello, sólo por desconocimiento. Pero lo peor es que esto se convierta en un trabajo de investigación (sin mucha base).

Mi argumentos reflejan lo que siempre he pensado del fanatismo de los desarrolladores. ¿Y usted que opina?

ata2.00. exception Emask 0×0 SAct 0×0 action 0×2 frozen al iniciar Ubuntu 8.04 (Hardy Heron) en una DELL Inspiron 530

0 Comentarios Publicado por admin 22 Junio 2008 en General. english • español

La lentitud y los múltiples crashes de las aplicacciones en la DELL Inspiron 530 que compré para la casa a finales del año pasado hicieron que mi esposa y mi hija prácticamente me suplicaran que montara Ubuntu en la nueva máquina. Nunca pensé que tener una computadora con Windows Vista instalado fuera tan buen mercadeo para Linux ;-)

Por supuesto estaba el problema de los drivers, el monitor por sí solo es un mundo, etc. Sin embargo después de muchos fines de semana sin tiempo para respaldar, reparticionar, instalar y configurar,  por fin me dediqué a instalar Ubuntu 8.04, Hardy Heron.

Sin embargo después de la instalación se me quedaba "pegada" booteando con el siguiente mensaje:

PLAIN TEXT
CODE:
  1. ata2.00: status: {DRDY}
  2. ata2: soft resetting link
  3. ata2.00: configured for UDMA/33
  4. ata2: EH Complete
  5. ata2.00. exception Emask 0x0 SAct 0x0 action 0x2 frozen

Después de mucho escarbar en internet, pude resolver el problema agregando el parámetro pci=nomsi para el arranque del kernel, no estuvo fácil así que mejor postearlo aquí para que A) No se me olvide, B) Más nadie tenga que dar tumbos en los foros de Ubuntu, el WIki de DELL para soporte a Linux y cualquier otro recurso desquiciado en internet.

De momento el equipo funciona perfectamente, y mi mayor preocupación es que Gnomad2 se dispara con unos picos duros de consumo de CPU al sincronizar el Creative Labs Zen de mi hija con su "PlaysForSure" de Microsoft ;-)

Y ahora, por fin la máquina se comporta como un Core 2 Duo de 2.33 GHz, con 2 GB de RAM y una NVIDIA GeForce de 256MB y se acabará la letanía de ¿Y esta no "ique" era más rápida?

Nginx: 4to lugar en Netcraft cortesía de WordPress.com

0 Comentarios Publicado por admin 11 Junio 2008 en General. english • español

La gente de Netcraft reporta que para el mes de Mayo el servidor web Nginx ocupa el quinto lugar en su ranking. Esto cortesía de la gente de WordPress.com que reemplazaron Litespeed por Nginx, y que casualmente ayer generaron 36 millones de pageviews dinámicos con picos de 15k requests/sec en un pico histórico para su operación.

Capturando temperatura utilizando Sentilla Perk (II)

6 Comentarios Publicado por josevnz 24 Mayo 2008 en General, Java, sun. english • español

En un articulo anterior les mostraba lo fácil que era utilizar el sensor (mote) de Sentilla Perk para capturar temperatura; Les comentaba también que una de las cosas más molestas del kit era que el gateway (el servidor con el cual instalamos software en los sensores y capturamos datos desde la red) sólo corre bajo Windows XP (aunque los ingenieros ya están trabajando en mejoras como drivers para Linux ys OSX).

OK, ¡suficiente habladera de tonterias!. Una forma de remediar esto es agregar otro protocolo (como TCP/IP) encima al programa original que recolectaba las temperaturas de todos los sensores, es decir lo convertimos en un servidor.

Lo primero es decidir si queremos usar un protocolo existente o si queremos reinventar la rueda; Para este experimento decidí que usar un protocolo existente con algunas modificaciones era lo más sencillo (Daytime, RFC686):

  • El servidor escucha en el puerto 1973 (cualquiera sirve si está libre ;)).
  • El cliente envia un paquete (vacio o no) al puerto 1973 en la máquina en donde corre el servidor
  • El servidor recibe el paquete y lo descarta. Envia de vuelta uno nuevo con una lista temperatura de todos los sensores que ha escuchado hasta el momento
  • El servidor no envia más temperaturas

El protocolo es sencillo, es puro texto (con una cabecera el cual el cliente utiliza como validación):
HEADER SENSORID1 SENSORCOUNT1 TEMPERATURE1 UNITS1 SENSORID2 SENSORCOUNT2 TEMPERATURE2 UNITS2 ...

Siempre es bueno encapsular los paquetes de un protocolo en una clase, para hacer más fácil su manejo:

PLAIN TEXT
JAVA:
  1. package com.kodegeek.blog.pervasive.perk;
  2.  
  3. /**
  4. * Simple model for temperature readings
  5. * @author josevnz
  6. *
  7. */
  8. public final class SimpleMessage {
  9.    
  10.     /**
  11.      * Valid status codes for the message
  12.      * @author josevnz@kodegeek.com
  13.      */
  14.     public enum Units {
  15.         FAHRENHEIT("Fahrenheit"),
  16.         CELCIUS("Celcius"),
  17.         UNKNOWN("Unknown");
  18.        
  19.         private String desc;
  20.        
  21.         Units(String desc) {
  22.             this.desc = desc;
  23.         }
  24.        
  25.         public String getDescription() {
  26.             return desc;
  27.         }
  28.        
  29.         public static Units getCode(int code) {
  30.             for (Units codes : Units.values()) {
  31.                 if (codes.ordinal() == code)
  32.                     return codes;
  33.             }
  34.             throw new IllegalArgumentException(String.format("Unknown code: %d", code));
  35.         }
  36.        
  37.     }
  38.    
  39.     private long count;
  40.     private long moteId;
  41.     private double temperature;
  42.     private Units units;
  43.    
  44.     /**
  45.      * Default constructor. By default is UNKLNOWN
  46.      */
  47.     public SimpleMessage() {
  48.         this(0, 0, 0.0, Units.UNKNOWN);
  49.     }
  50.    
  51.     /**
  52.      * Parametric constructor
  53.      * @param count Message count
  54.      * @param moteId sensor id
  55.      * @param temperature Temperature
  56.      * @param isRequest Is a request or a response
  57.      */
  58.     public SimpleMessage(long count, long moteId, double temperature, Units code) {
  59.         setCount(count);
  60.         setMoteId(moteId);
  61.         setTemperature(temperature);
  62.         setUnits(code);
  63.     }
  64.    
  65.     /**
  66.      * Get the message cou
  67.      * @return the count
  68.      */
  69.     public final long getCount() {
  70.         return count;
  71.     }
  72.    
  73.     /**
  74.      * Set the message count
  75.      * @param count the count to set
  76.      */
  77.     public final void setCount(long count) {
  78.         this.count = count;
  79.     }
  80.    
  81.     /**
  82.      * Return the sensor id
  83.      * @return the moteId
  84.      */
  85.     public final long getMoteId() {
  86.         return moteId;
  87.     }
  88.    
  89.     /**
  90.      * Set the sensor id
  91.      * @param moteId the moteId to set
  92.      */
  93.     public final void setMoteId(long moteId) {
  94.         this.moteId = moteId;
  95.     }
  96.    
  97.     /**
  98.      * @return the temperature
  99.      */
  100.     public final double getTemperature() {
  101.         return temperature;
  102.     }
  103.    
  104.     /**
  105.      * Set the temperature
  106.      * @param temperature the temperature to set. No validation is made as it depends a lot on the units
  107.      */
  108.     public final void setTemperature(double temperature) {
  109.         this.temperature = temperature;
  110.     }
  111.    
  112.     /**
  113.      * Get the units
  114.      * @return The state code
  115.      */
  116.     public final Units getUnits() {
  117.         return units;
  118.     }
  119.    
  120.     /**
  121.      * Set the units
  122.      * @param code Valid code to pass
  123.      */
  124.     public final void setUnits(Units code) {
  125.         this.units = code;
  126.     }
  127. }

El siguiente paso es decidir como codificar y decodificar el mensaje que enviamos a traves de la red; En el mundo Java podemos usar RMI, Sockets + Serialization sin embargo me pareció mejor utilizar UDP, por lo pequeño de los mensajes además de que no requiero las características extras de TCP, y no serialización (hay que ser MUY cuidadoso cuando se implementa, no es sólo decir que la clase implenta la interfaz "Serializable"):

PLAIN TEXT
JAVA:
  1. /**
  2. *
  3. */
  4. package com.kodegeek.blog.pervasive.perk;
  5.  
  6. /**
  7. * Define the contract to encode / decode a temperature message.
  8. * Not using the Sentilla radio protocol.
  9. */
  10. import java.io.IOException;
  11. import java.io.UnsupportedEncodingException;
  12. import java.util.ArrayList;
  13.  
  14. /**
  15. * @author josevnz
  16. *
  17. */
  18. public interface TemperatureCoder {
  19.  
  20.     /**
  21.      * Decode message from wire
  22.      * @param buffer
  23.      * @return TempMessage decoded from the wire
  24.      */
  25.      ArrayList<SimpleMessage> fromWire(byte [] buffer) throws IOException;
  26.    
  27.     /**
  28.      * Encoded message
  29.      * @param e
  30.      * @return byte array with serialized message
  31.      * @throws UnsupportedEncodingException
  32.      */
  33.     byte [] toWire(ArrayList<SimpleMessage> messages) throws IOException;
  34.    
  35. }

Si, una interfaz la cual va a implementar el codificador especifico (código aquí). De esta manera, si cambiamos el protocolo (usamos Java + Serialization por ejemplo), nuestra aplicación sólo tiene que cambiar la declaración del codificador concreto y listo.

¿Que viene después? Ah, envenenar al cliente original que capturaba la temperatura; Ahora va a ser un servidor El cual:

  • Va a capturar constantemente nuevas temperaturas desde la inalámbrica de los sensores en una hebra separada
  • Va a enviar todas las temperaturas disponibles a quien se las pida

Si bien el código del servidor no es muy largo (haga click aqui para verlo completo) prefiero mostrarle sólo las piezas críticas:

PLAIN TEXT
JAVA:
  1. /**
  2. * Server that collects the temperature readings of
  3. * all the motes in the wireless network.
  4. * @author josevnz@kodegeek.com
  5. */
  6.  
  7. package com.kodegeek.blog.pervasive.perk;
  8.  
  9. ...
  10.  
  11. /**
  12. * Iterative Server that collects all the temperature readings coming from the Sentilla Perk on the networks
  13. * @author josevnz@kodegeek.com
  14. *
  15. */
  16. public final class TemperatureService implements Runnable {
  17.  
  18.     private TemperatureService() {};
  19.  
  20.     private static final Logger log = Logger.getLogger(TemperatureService.class.getName());
  21.    
  22.     static {
  23.         log.setLevel(Level.FINEST);
  24.     }
  25.     private static final int DEFAULT_PORT = 1973;
  26.     protected static final int BUFFER_SIZE = 65507; // 65535 bytes - IP Header(20) - UDP header (8)
  27.     private static final int MOTE_WAIT = MoteTemperatureReader.WAIT_TIME;
  28.     private static final Map <Long, TempMessage>sensorMap = new ConcurrentHashMap<Long, TempMessage>();
  29.  
  30.     /**
  31.      * Capture sensor temperatures firever on a separate thread
  32.      */
  33.     public void run() {
  34.  
  35.         // Connect to the Sentilla server
  36.         HostClient client = new HostClient();
  37.         try {
  38.             client.connect();
  39.             log.log(Level.INFO, String.format("Connected to sensor gateway at %s, capturing temperatures", client.getHost()));
  40.             while(true) {
  41.                 Receiver receiver = ReceiverDriver.create(TempMessage.class);
  42.                 receiver.setReceive().submit().block(MOTE_WAIT);
  43.                 if (receiver.isDone()) {
  44.                     TempMessage tmsg = receiver.getData();
  45.                     sensorMap.put(tmsg.moteId, tmsg); // Save every sensor update, replacing previous one
  46.                     log.log(Level.FINE, String.format("Got update from sensor id: %s", tmsg.moteId));
  47.                 }
  48.             }
  49.         } catch (IOException ioExp) {
  50.             log.log(Level.SEVERE, "Severe error, response will be dropped", ioExp);
  51.         } finally {
  52.             try {
  53.                 if (client != null)
  54.                     client.disconnect();
  55.             } catch (IOException ioExp) {
  56.                 log.log(Level.SEVERE, "Error while closing sensor connection", ioExp);
  57.             }
  58.         }
  59.     }
  60.  
  61.     /**
  62.      * Collect the statistics from all the motes
  63.      * @param args
  64.      */
  65.     public static void main(String[] args) throws Throwable {
  66. ...
  67.  
  68.         // Start capturing temperatures
  69.         Thread tempThread = new Thread(new TemperatureService());
  70.         tempThread.start();
  71.  
  72.         DatagramSocket socket;
  73.         TemperatureCoder coder = new TemperatureTextCoder();
  74.         socket = null;
  75.         try {
  76.             socket = new DatagramSocket(port);
  77.             byte [] buffer = new byte[BUFFER_SIZE];
  78.  
  79.             DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
  80.             ArrayList<SimpleMessage>messages = new ArrayList<SimpleMessage>();
  81.  
  82.             while(true) { // Wait forever for new clients            
  83.                 try {
  84.                     socket.receive(packet); // Get the packet and discard the contents
  85.                     log.info(String.format("Got a connection from: %s", packet.getAddress()));
  86.                     // Send every available tick to the client in one shot
  87.                     for (TempMessage tmsg : sensorMap.values()) {
  88.                         SimpleMessage message = new SimpleMessage();
  89.                         // Get the temperature for the sensor
  90.                         double temp = tmsg.temperature.doubleValue(CELSIUS);
  91.                         message.setCount(tmsg.count);
  92.                         message.setMoteId(tmsg.moteId);
  93.                         message.setTemperature(temp);
  94.                         message.setUnits(SimpleMessage.Units.CELCIUS);
  95. ...
  96.                         messages.add(message);
  97.  
  98.                     } // end for every sensor
  99.                    
  100.                     // Send the whole pack to the client
  101.                     buffer = coder.toWire(messages);
  102.                     packet.setData(buffer, 0, buffer.length);
  103.                     socket.send(packet);
  104.     ...

Si, el servidor no es muy robusto ni soporta un gran número de clientes a la vez (es iterativo), pero para jugar un rato está bien :)

Bueno, si aún no le ha dado un ataque leyendo todo este código lo invito a que vea el cliente (código completo aqui) . Muy sencillo (sólo imprime por pantalla las temperaturas) sin embargo tiene una caracteristica muy importante: No tiene ninguna dependencia con el código de Sentilla:

PLAIN TEXT
JAVA:
  1. package com.kodegeek.blog.pervasive.perk;
  2.  
  3. ...
  4.  
  5. /**
  6. * Simple client that will get all the temperature readings from a TemperatureServer on the network.
  7. * @author josevnz@kodegeek.com
  8. *
  9. */
  10. public final class TemperatureClient {
  11.    
  12. ...
  13.    
  14.     /**
  15.      * @param args host (args[0]), port number (arg[1])
  16.      * @throws Throwable On any fatal error
  17.      */
  18.     public static void main(String[] args) throws Throwable {
  19. ...
  20.    
  21.         log.log(Level.INFO, "Starting TemperatureClient");