2.- Agregandole Velocity al asunto:
Para esto escribi una clase en java llamanda Plantilla, esta clase recibira un Map, este para los datos que manejaremos en nuestra plantilla para la vista

package agnux.util.web;

import java.io.StringWriter;
import java.util.LinkedHashMap;
import java.util.Iterator;
import java.util.Properties;
import javax.servlet.http.HttpServletRequest;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;

public class Plantilla {

    private static VelocityContext convert2context( LinkedHashMap params){
        VelocityContext context = new VelocityContext();
        Iterator it = params.keySet().iterator();
        while (it.hasNext()) {
            String key = ( String ) it.next();
            String value = ( String ) params.get( key );
            context.put(key , value);
        }
        return context;
    }

    public static String pegarDatosConPlantilla(String filevm , LinkedHashMap params,HttpServletRequest request){
        String valor_retorno = null;
        Template template = null;
        StringWriter writer = new StringWriter();
        VelocityEngine engine = new VelocityEngine();
        String servlet_root = request.getSession().getServletContext().getRealPath(”/”);

        Properties p = new Properties();
        p.setProperty(”resource.loader”, “file”);
        p.setProperty(”runtime.log.logsystem.class”, “org.apache.velocity.runtime.log.SimpleLog4JLogSystem”);
        p.setProperty(”runtime.log.logsystem.log4j.category”,”org.apache.velocity.runtime.log.SimpleLog4JLogSystem”);
        p.setProperty(”file.resource.loader.cache”,”false”);
        p.setProperty(”file.resource.loader.modificationCheckInterval”,”2″);
        p.setProperty(”file.resource.loader.class”,”org.apache.velocity.runtime.resource.loader.FileResourceLoader”);
        p.setProperty(”file.resource.loader.path”,servlet_root + “templates/”);

        try {
            engine.init(p);
            template = engine.getTemplate(filevm);
            template.merge( convert2context(params) , writer );
            valor_retorno = writer.toString();
        } catch( Exception e ) {
            System.out.println(”Exception caught: ” + e.toString());
        }        

        return valor_retorno;
    }
}

Aqui mi plantilla de velocity “login.vm”: (genere una directorio llamado templates… este esta a mismo nivel que WEB-INF en el arbol de el proyecto).

Y Aqui mi groovlet que manda a llamar la plantilla:

* Tratando de escribir a un puntero NULL

      char *foo = NULL;
      strcpy(foo, "bang!");

* Usando un puntero no inicializado

      char *foo;
      strcpy(foo, "bang!");

* Accesar mas alla de los limites de un arreglo

int bar[20];
bar[27] = 6;

* Tratando de almacenar algo sobre memoria de solo lectura

char *foo = "My string";
strcpy(foo, "bang!");

* Y por ultimo utilizando de manera tonta free y malloc

char bar[80];
free(bar);

o

char *foo = malloc(27);
free(foo);
free(foo);

$ cat capítulol capítulo2 capítulo3 | grep árbol

El primer proceso, que ejecuta cat, concatena y envía a la salida tres archivos. El segundo proceso, que ejecuta grep, selecciona todas las líneas que contienen la palabra “árbol”. Dependiendo de las velocidades relativas de los dos procesos (que a su vez dependen de la complejidad relativa de los programas y de cuánto tiempo de CPU ha ocupado cada uno), puede suceder que grep esté listo para ejecutarse, pero no haya entradas esperando ser procesadas por él. En tal caso, grep deberá bloquearse hasta que haya entradas disponibles.

Cuando un proceso se bloquea, lo hace porque le es imposible continuar lógicamente, casi siempre porque está esperando entradas que todavía no están disponibles. También puede ser que un programa que conceptualmente está listo y en condiciones de ejecutarse sea detenido porque el sistema operativo ha decidido asignar la CPU a otro proceso durante un tiempo. Estas dos condiciones son totalmente distintas. En el primer caso, la suspensión es inherente al problema (no es posible procesar la línea de comandos del usuario antes de que éste la teclee). En el segundo caso, se trata de un tecnicismo del sistema (no hay suficientes CPU para darle a cada proceso su propio procesador privado).

En MINIX, cuando un proceso lee de una tuberia (pipe) o archivo especial (p. ej., una terminal) y no hay entradas disponibles, se bloquea automáticamente.

Las transiciones 2 y 3 son causadas por el planificador de procesos, una parte del sistema operativo, sin que el proceso se entere siquiera de ellas. La transición 2 ocurre cuando el planificador decide que el proceso en ejecución ya se ejecutó durante suficiente tiempo y es hora de dejar que otros procesos tengan algo de tiempo de CPU. La transición 3 ocurre cuando todos los demás procesos han disfrutado de una porción justa y es hora de que el primer proceso reciba otra vez la CPU para ejecutarse. El tema de la planificación, es decir, de decidir cuál proceso debe ejecutarse cuándo y durante cuánto tiempo, es muy importante. Se han inventado muchos algoritmos para tratar de equilibrar las exigencias opuestas de eficiencia del sistema global y de equitatividad para los procesos individuales.

La transición 4 ocurre cuando acontece el suceso externo que un proceso estaba esperando (como la llegada de entradas). Si ningún otro proceso se está ejecutando en ese instante, se dispara de inmediato la transición 3, y el proceso comienza a ejecutarse. En caso contrario, el proceso tal vez tenga que esperar en el estado listo durante cierto tiempo hasta que la CPU esté disponible.

OJO:

El “planificador” no sólo se refiere a planificación de procesos, sino también a manejo de interrupciones y toda la comunicación entre procesos.

En MINIX, el usuario puede pulsar la tecla DEL (suprimir) del teclado, la cual envía una señal al editor. El editor atrapa la señal y detiene el listado.

Donde mas se puede emplear las llamadas al sistema para Señalizacion en MINIX?
* Para informar de ciertas trampas detectadas por el hardware, como una instrucción no permitida o un desbordamiento de punto flotante.
* Las expiraciones de tiempo también se implementan como señales ( En muchas aplicaciones de tiempo real se hace necesario interrumpir un proceso después de un intervalo de tiempo específico a fin de hacer algo, como retransmitir un paquete que tal vez se perdió en una línea de comunicación no confiable ).

OJO:

Cuando se envía una señal a un proceso que no ha anunciado su disposición a aceptar esa señal, el proceso simplemente se termina sin más.

A fin de hacer más claro el mecanismo de las llamadas al sistema, examinemos brevemente READ (leer) Esta llamada tiene tres parámetros: el primero especifica el archivo, el segundo especifica el buffer, y el tercero especifica el número de bytes por leer. Una llamada de READ desde un programa en C podría verse así:

cuenta = read(file, buffer, nbytes);

La llamada al sistema (y el procedimiento de biblioteca) devuelve en cuenta el número de bytes que realmente se leyeron. Este valor normalmente es igual a nbytes, pero puede ser menor, si, por ejemplo, se llega al fin del archivo durante la lectura.

Si la llamada al sistema no puede ejecutarse, ya sea a causa de un parámetro no válido o de un error de disco, se asignará el valor — 1 a cuenta, y el número del error se colocará en una variable global, errno. Los programas siempre deben revisar los resultados de una llamada al sistema para ver si ocurrió un error. MINIX tiene un total de 53 llamadas al sistema

Las llamadas al sistema en MINIX se clasifican en:
* Administracion de Archivos
* Administracion de Procesos
* Administracion del Tiempo
* Señales
* Proteccion relacionada con usuarios y grupos

Que contiene el espacio de Direcciones de un Proceso?
* El programa ejecutable (o Segmento de Texto)
* Los datos del programa
* La Pila o Stack del programa

Los procesos en MINIX tienen su memoria dividida en tres segmentos: el segmento de texto (esto es,el código de programa), el segmento de datos (es decir, las variables) y el segmento de pila. El segmento de datos crece hacia arriba y el de pila lo hace hacia abajo, como se muestra en la Figura siguiente:

A cada proceso también se asocia un conjunto de registros, que incluyen el contador del programa, el apuntador de la pila y otros registros de hardware, así como toda la demás información necesaria para ejecutar el programa.

Tabla de procesos
Arreglo (o lista enlazada) de estructuras, una para cada proceso existente en ese momento. Toda la información acerca de cada proceso, aparte del contenido de su propio espacio de direcciones se almacena sobre esta tabla.

Procesos padre
Un proceso puede crear uno o más procesos distintos (denominados procesos hijos) y éstos a su vez pueden crear procesos hijos, pronto llegamos a la estructura de árbol de procesos. Los procesos relacionados que están cooperando para realizar alguna tarea a menudo necesitan comunicarse
entre sí y sincronizar sus actividades. Esta comunicación se llama comunicación entre procesos (IPC).

El administrador del sistema asigna un uid (identificador de usuario) a cada persona autorizada para usar MINIX. Cada proceso iniciado en MINIX tiene el uid de la persona que lo inició. Un proceso hijo tiene el mismo uid que su padre.

Poco después de liberarse MINIX, se formó un grupo de noticias de USENET para hablar de él. En pocas semanas, este grupo tenía 40000 suscriptores,
la mayor parte de los cuales quería agregar enormes cantidades de nuevas capacidades a MINIX a fin de hacerlo más grande y mejor (bueno, al menos más grande). Cada día, varios cientos de ellos ofrecían sugerencias, ideas y fragmentos de código. El autor de MINIX resistió con éxito esta arremetida durante varios años, a fin de mantener a MINIX lo suficientemente pequeño y aseado como para que los estudiantes lo entendieran. Gradualmente, la gente comenzó a convencerse de que su posición era inamovible. Finalmente, un estudiante finlandés, Linus Torvalds, decidió escribir un clon de MINIX que pretendía ser un sistema de producción con abundantes capacidades, más que una herramienta educativa.
Así fue como nació LINUX.