viernes, 10 de septiembre de 2010

Estándar 802.3

En este post se brinda un resumen de referencia sobre el formato de un frame en 802.3, particularmente para una red Ethernet 10BASE-T que intenta aclarar algunas dudas que a mi se me presentaron al estudiarlo en detalle. Por lo tanto no se trata aquí abarcar todo el estándar IEEE 802.3 ni mucho menos.

Formato del frame

El frame para el estándar 802.3 se compone de la siguiente manera:
7Bpreámbulo (1010101010...)
1Bdelimitador de frame (10101011)
2 o 6Bdirección destino
2 o 6Bdirección origen
2Blongitud de datos
0 a 1500Bdatos
0 a 46Brelleno
4Bsuma de comprobación
Donde:
  • un márco válido debe tener al menos 64B desde la dirección de destino hasta la suma de comprobación (ambas inclusive).
  • el campo datos tiene un máximo de 1500B
Por lo que el marco válido tiene al menos 72B contando preámbulo y delimitador, y a lo sumo 1526B.

Algoritmo para enviar un frame

  
00_ lastBackoffMax = 1;                     // El primer intento de backoff irá entre 0 y 2.
01_ while (carrierSense);                   // Espero a que se libere el canal.
02_ wait (interframeGap);                   // Dejo pasar un IFG.
03_ bool collisionDetected = send(frame);   // send(...) está definido más abajo
04_ if (collisionDetected) {                // Aplico backoff
05_    if (lastBackoffMax == 2^backoffLimit) goto 10; // Si llegué al tope de reintentos, descarto el paquete.
06_    lastBackoffMax *= 2;                 // Tengo el doble de opciones que la vez anterior.
07_    r = random(0, lastBackoffMax);       // Elijo la cantidad de slots a esperar aleatoriamente.
08_    wait(r * slotTime);                  // Dejo pasar r slots.
09_    goto 1;                              // Vuelvo al paso 1.
10_ }


// Envía un frame, el jamSignal, si es necesario y detecta la colisión.
// En caso de colisión detectada, retorna verdadero.
function bool send(frame);
Siendo que, en el caso particular de 10BaseT:
interFrameGap9,6ustiempo que debe dejarse libre el canal antes de transmitir un frame
backoffLimit10límite de reintentos de backoff
jamSize32btamaño de la señal de jamming
slotTime51,2ustiempo que demora en transmitirse la trama mínima
Quizá esté medio desprolijo. Pero es sólo un apunte de referencia. Cualquier duda, corrección o necesidad de más detalles, pueden avisarme por aquí.

jueves, 15 de julio de 2010

Configurando Spring

Configuración básica

Caso de estudio

La configuración más sencilla brinda tan sólo la posibilidad de crear un andamiaje de objetos (llamados "beans").
No ofrece configuraciones para ORM ni para Servlets ni nada parecido.
Como ejemplo de andamiaje vamos a suponer que nuestro sistema tiene una clase Activity que representa a las actividades a ejecutar sobre objetos de otra clase, dejándolo en determinado estado y que éstas tienen algunos requisitos sobre el estado de los objetos (clase State).
Dado que estos requisitos son parte de la configuración del sistema, podríamos configurarlos al iniciarse la aplicación u obtenerlas cuando sea necesario desde alguna factory de la siguiente manera:
State encendido = new State("Encendido");
State standBy = new State("StandBy");
State apagado = new State("Apagado");
Activity apagar = new Activity("Apagar");
apagar.addRequisito(encendido);
apagar.addRequisito(standBy);
apagar.setDestino(apagado);
Básicamente, estamos tratando de implementar una inyección de dependencias.
Y tan sólo esto es lo que configuraremos como ejemplo de utilización básico del framework Spring.

Bibliotecas requeridas

En primer lugar es necesario añadir al classpath de la aplicación las siguientes bibliotecas:
  • commons-logging.jar
  • org.springframework.asm.jar
  • org.springframework.beans.jar
  • org.springframework.context.jar
  • org.springframework.core.jar
  • org.springframework.expression.jar

Que se incluyen en el paquete descargable de Spring, salvo commons-logging, que puede descargarse desde aquí.

Definición del andamiaje

Es necesario indicarle al framework toda la estructura de objetos necesaria por nuestra aplicación. Esto puede lograrse de diversas maneras; pero, por simplicidad, se eligió un archivo XML para ello.
A continuación podemos ver, con algunos comentarios para que se entienda, este XML; aunque, para más información, puede consultarse el manual en línea (en inglés) o el manual contenido en la descarga (en varios idiomas, incluso el español).

<?xml version="1.0" encoding="UTF-8"?>
<beans
   xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:p="http://www.springframework.org/schema/p"
   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <!-- Aquí se está definiendo un bean cuyo identificador es "encendido"
        y es del tipo "my.package.State" -->
   <bean id="encendido" class="my.package.State">
      <!-- Le pasamos un parámetro al constructor (si es necesario) -->
      <constructor-arg value="Encendido" />   </bean>
   <bean id="standBy" class="my.package.State">
      <constructor-arg value="StandBy" />   </bean>
   <bean id="apagado" class="my.package.State">
      <constructor-arg value="Apagado" />   </bean>

   <!-- ... --->
   <!-- Otras definiciones de beans -->
   <!-- ... --->

   <bean id="apagar" class="my.package.Activity">
      <constructor-arg value="Apagar" />      <!-- Además se puede invocar a los setters del bean que se está creando -->
      <property name="destino" ref="apagado" />

      <!-- Y, si algunas propiedades son conjuntos de elementos, no hay problemas -->
      <property name="requisitos">
         <set>
            <!-- Siempre que se haga referencia a otro bean, es por su ID -->
            <ref bean="encendido" />
            <ref bean="standBy" />
         </set>
      </property>
   </bean>
</beans>
Debido a la forma en que se accederá luego a esta configuración, debe encontrarse en algún directorio que pueda ser encontrado por el ClassLoader. En nuestro caso, el archivo se llama "activities.xml" y está dentro del directorio "src", en el _default package_.

Utilización del !BeanFactory

Con no más configuraciones que las realizadas hasta el momento ya es posible comenzar a utilizar Spring. Si quisiera obtener el bean apagar, no hay más que solicitárselo a un BeanFactory mediante el id con el que se lo registró:

BeanFactory beanFactory = new ClassPathXmlApplicationContext("activities.xml");
Activity apagar = beanFactory.getBean("apagar", Activity.class);

jueves, 19 de noviembre de 2009

Cómo resaltar la sintaxis en tu blog

Este tutorial contará cómo resolví el primer desafío que se me presentó al intentar escribir otro sobre la configuración más básica del framework Spring para Java.
El problema radicaba en que, si quería mostrar fragmentos de código fuente con ejemplos de lo que hacía paso a paso, debía encargarme de los estilos para resaltarlo de acuerdo al lenguaje de que se trate (teniendo en cuenta las keywords y sintaxis).
La herramienta que encontré para resolverlo es SyntaxHighlighter.
Para utilizarlo no hay más que incluir sus Javascripts al final del documento, siendo que éstos deben incluir el shCore.js y un brush por cada lenguaje soportado, que se trata de un script que analiza el contenido del código fuente y lo pinta según las reglas del lenguaje que represente, como muestro en el siguiente ejemplo:
<link href="http://syntaxhighlighter.googlecode.com/svn/trunk/Styles/SyntaxHighlighter.css" rel="stylesheet" type="text/css"></link>
<script language="javascript" src="http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shCore.js">
</script>
<!-- aquí incluyo los brushes de Java y XML -->
<script language="javascript" src="http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushJava.js"></script>
<script language="javascript" src="http://syntaxhighlighter.googlecode.com/svn/trunk/Scripts/shBrushXml.js"></script>

<script language="javascript">
dp.SyntaxHighlighter.ClipboardSwf = '/flash/clipboard.swf';
dp.SyntaxHighlighter.BloggerMode();
dp.SyntaxHighlighter.HighlightAll('code');
</script>
Para agregarlo al final del documento, debe ingresar a la configuración de diseño del blog y, de allí, seleccionar la solapa "Edición de HTML".
Una vez configurado el blog, cada vez que se quiera resaltar la sintaxis de algún fragmento de texto. debe escribírselo de la siguiente manera:
<pre name="code" class="idLenguaje">
   ...
</pre>
Donde "idLenguaje" es cualquiera de los soportados, como: cpp, csharp, css, java, xml, html, php, python, sql, etc.
Aunque debe tenerse en cuenta que, en algunos casos, el código fuente a mostrar contiene algunos símbolos que luego causarán problemas (el syntaxHighlighter, por ejemplo, falla con los '>' en los tag <pre>). Ello no debería ser un obstáculo ya que podemos "escapear" cada caracter problemático. Sin embargo, esta tarea es demasiado engorrosa y propensa a errores; pero, afortunadamente, existen sitios como este que lo hacen automáticamente.

viernes, 13 de noviembre de 2009

El primer post

Este es el típico primer post del blog donde me presento y trato de comentarles qué temas se tratarán en este blog. Sin embargo no confíen demasiado en esto ya que es probable que a veces me desvíe y termine escribiendo sobre cualquier cosa.
En fin, mi idea es ir escribiendo tutoriales breves sobre temas que incumben al desarrollo de software. En general describirán la forma en que pude salvar alguna dificultad mientras programaba para la facultad, el trabajo o en mis ratos libres. Por lo tanto no es de esperar un diseño ordenado del blog.
Espero en cada tutorial ser didáctico y conciso y recibiré con agrado cualquier crítica constructiva de algún lector.