The Matrix Recauchuted

Vale, ya sé que llega con 8 jodidos años de puto retraso... U^_^

La leyenda urbana del hámster

Erase una vez un par de maricones que decidieron usar el canuto del rollo de papel de cocina para metérselo por el culo y emplearlo como túnel sin peaje para que el hámster de ambos se diese un garbeo por el recto.

Esa historia, que es más vieja que el cagar (y que yo ya ilustré en una hoja al lado de unos "apuntes" de Sistemas Lineales... ahora que caigo, creo que todavía la tengo, qué bueno que es eso de guardar todas las cosas*), ha sido contada en numerosas ocasiones, atribuida a famosos, amigos de un vecino, etc. incluso nos la han contado con pelos y señales, bien aderezada para que nos echásemos unas risas**...

Pero lo más fuerte es que un gilipollas (perdón, un GILIPOLLAS) llame a la radio para contarlo como vivencia propia, y encima sin gracia ni salero ningunos. Yo no podía salir de mi asombro mientras iba conduciendo y el otro pringado relataba, con algún detalle de invención propia (el tubo de cartón ahora era de PVC, un gran avance), la trilladísima leyenda urbana que todos conocemos.

Todavía no sé qué es lo más increible, si que los presentadores no le dijesen "chaval, a otro con ese cuento, que ya nos la sabemos" ó que el tío se auto-humille él solito diciendo que le explotó un culo en la cara y que un roedor le rompió el tabique nasal (esto último no recuerdo si lo llegué a escuchar, cambié de cadena).

En fin, a lo que íbamos, que le echéis un ojo a las instrucciones de cómo meterse un ratón por el culo, que no tiene desperdicio (y de paso preguntaos cómo cojones aprobé la carrera con esos cacho de apuntes que tomaba).

*
**Raggot y su excursión por el ano de Kiki

factor de protección X

Ya sabéis, que quemarse es mú, mú malo... y en algunas partes peor que en otras ;-)

Vacaciones

Aquí os dejo una bonita tira que ilustra las esperanzas que se ponen al comienzo de las vacaciones... yo todavía no me voy, así que seguiré publicando (aunque sigo sin adsl, así que el ritmo seguirá bajo).

cojo-gestión de configuración

Este post me ha llevado un poco más de la cuenta, pero es que se las trae... espero que a los informáticos que leen el blog les sirva de algo, y a los profanos... bueno, a lo mejor aprenden que no es oro todo lo que reluce.

---

Hay un refrán que dice "en casa del herrero cuchillo de palo", lo cuál es bastante cierto si hablamos de informática. Parece que los ingenierillos disfrutan haciendo trabajo de monos espaciales. Se enciende una luz y tiras de una palanca. Repítelo un millón de veces y tendrás a un especialista en ingeniería del software.

Con la ingeniería del software me pasa lo mismo que con el comunismo. Las dos cosas me gustan, pero no puedo decir lo mismo de los ingenieros del software y los comunistas, que suelen ser gilipollas.

Vayamos al meollo de la cuestión. En las asignaturas de "injenierida del chofgüer" y derivadas parece que son asignaturas en las que enseñan a manejar el "Guord", a poner bien de colorines el documento, a hacerte unos encabezados muy chulos, a hacer un montón de fichas en tablitas para requisitos y componentes... y los alumnos, en cuanto tienen que pensar un poco, se quedan pasmados con el dedo en la nariz (ver diagrama:
)
y repiten como buenos simios amaestrados que son. Los más afortunados recibirán su plátano, trabajarán de consultores ganando una pasta y se sentirán dichosos de haber triunfado en la vida. Los menos, acabarán con estos jefes.

Siempre he pensado que la informática se creó con los siguientes objetivos:

1. Automatizar tareas.
2. Asistir en la resolución de problemas.
3. Almacenar datos.
   

(Y el punto dos se puede abstraer en el punto uno, teniendo en cuenta que la resolución de problemas por ordenador es automatizar procedimientos de resolución.)

Luego vino el ocio, la multimierda y tal, pero eso ya es harina de otro costal y se me escapa un poco del tema... hmmmm... no, ya me he escapado, voy a intentar volver a lo que tenía en la cabeza desde un principio.

Estaba intentando describir cómo para la última práctica de la carrera (Sistemas Informáticos) nos hemos desviado un poco de las típicas chapuzas artesanales y hemos automatizado los procesos de documentación todo lo que hemos podido (se podría haber hecho más, pero hay que encontrar un equilibrio entre el tiempo que empleas en mejorar los procesos y el tiempo que te ahorras con los procesos mejorados); con el fin de poder recurrir aquí cuando quiera repetir y de paso que cualquier otro se pueda subir al carro de los elegidos.

Empecemos enumerando los requisitos necesarios para montar el sistema:

• Servidor unix (o windows con cygwin) conectado a la red.
• cvs
• ssh
• make
• openjade (y todas las utilidades para docbook)
• ghostscript
• xmllint
  
• python
• Clientes
• edición xml (posibles alternativas)
• jedit + plugin xml (recomendada)
  
• vex (algo wysiwyg, pero todavía incompleto... como ventaja se puede incluir como workspace en eclipse).
• kxml (no está mal para ver la estructura, pero pesado para editar)
• emacs + sgml mode (un clásico que nunca falla)
  
• cliente cvs (posibles alternativas)
• cvs a pelo (algo coñazo, pero efectivo y disponible en casi todas partes)
• tortoise cvs (cómodo y divertido, para windows)
• eclipse (es lo más cómodo si ya lo usas para desarrollar y editar xml)
• hoja de cálculo
• oocalc (recomendada, porque exporta como queremos)
• gnumeric (copy & paste a un vi o emacs para exportar)
  
• excel (copy & paste a un notepad para exportar)

Ahora vamos a explicar cómo se monta el chiringuito para hacer URD's, SRD's y otras mierdas variadas:

1. Montar las cuentas de usuarios
   
2. Montar un repositorio CVS:
1. entrar en el directorio que queramos tener como repositorio y ejecutar el comando "cvs init" (un sitio típico es "/var/cvs", aunque puede estar en el home de una cuenta especial para el proyecto, a la que tienen permiso de acceso, lectura y escritura los miembros del grupo)
   
2. crear un módulo para la documentación (la manera más fácil es hacerlo con el asistente del eclipse, en el menú contextual sobre un proyecto "team > share project", o en la línea de comandos con "cvs import nombre-modulo grupo version")
3. Crear uno directorio para cada grupo de:
• Documentos
• Imágenes compartidas (logotipos, etc.)
• Plantillas comunes
4. Crear un directorio para el primer documento (bajo el de documentos):
1. Crear un Makefile (que luego explicaremos qué tiene).
2. Subdirectorio para las imágenes propias del documento.
   
3. Subdirectorio para los requisitos, con sus scripts y más cosas (luego lo explicamos).
   
4. Documentos xml para cada capítulo ó sección (con el grano todo lo fino que queramos) y un documento maestro (también explicamos cómo funciona ahora).

Aquí está la disposición de nuestro módulo de documentación para Sistemas Informáticos (con algunas cosas abreviadas y con comentarios seguidos de una #):

workspace/ssii_docs/
|-- CVS #esto es información del cvs, los siguientes están abrevidados
|   |-- Entries
|   |-- Repository
|   |-- Root
|   `-- Template
|-- diagramas #diagramas del rational y otros dibujitos
|   |-- Bender.emx
|   |-- CVS
|   |-- Disenyo.mdx
|   |-- Disenyo.wdx
|   |-- Disenyo5EC87526B7F54B30B9A09AFCE8E3EBA7.idx
|   |-- Mermelada.mdx
|   |-- Mermelada.wdx
|   |-- build.xml
|   |-- disenyo1037AB48F0554ECA9D513EDDDE78C57A.idx
|   |-- instalacion.svg
|   `-- sensor_tapon.svg
|-- documentos
|   |-- CVS
|   |-- anteproyecto #el anteproyecto, abarcará URD y SRD
|   |   |-- CVS
|   |   |-- Makefile #fantástico makefile
|   |   |-- anteproyecto.xml #documento maestro
|   |   |-- anteproyecto_final.pdf #el resultado final
|   |   |-- anteproyecto_final.ps #un resultado intermedio
|   |   |-- anteproyecto_final.xml #un resultado intermedio
|   |   |-- chap_descripcion_modelo_logico.xml #los siguientes chap*.xml son capítulos
|   |   |-- chap_disenno_arquitectonico.xml
|   |   |-- chap_estimacion.xml
|   |   |-- chap_introduccion.xml
|   |   |-- chap_maquinas_estados.xml
|   |   |-- chap_planificacion.xml
|   |   |-- chap_plano_instalacion.xml
|   |   |-- chap_presupuesto.xml
|   |   |-- chap_pruebas.xml
|   |   |-- chap_requisitos_software.xml
|   |   |-- chap_requisitos_usuario.xml
|   |   |-- chap_resumen.xml
|   |   |-- cocomo #informes del cocomo
|   |   |   |-- CVS
|   |   |   |-- cocomo-report.rpt
|   |   |   `-- cocomo.est
|   |   |-- images #gráficos para incrustar (*.ps y *.eps)
|   |   |   |-- CVS
|   |   |   |-- Mermelada__Arrancar__Actividad__Arrancar.ps
|   |   |   |-- Mermelada__Arrancar__Secuencia__InteractionInstance1__Arrancar.ps
|   |   |   |-- Mermelada__Casos_uso.ps
|   |   |   |-- Mermelada__Clases_analisis.ps
|   |   |   |-- Mermelada__Configurar__Actividad__Configurar.ps
|   |   |   |-- Mermelada__Configurar__Secuencia__InteractionInstance1__Configurar.ps
|   |   |   |-- Mermelada__Despliegue.ps
|   |   |   |-- Mermelada__Emergencia__Actividad__Emergencia.ps
|   |   |   |-- Mermelada__Emergencia__Secuencia__InteractionInstance1__Emergencia.ps
|   |   |   |-- Mermelada__Generar_informes__Actividad__Generar_informes.ps
|   |   |   |-- Mermelada__Generar_informes__Secuencia__InteractionInstance1__Generar_informes.ps
|   |   |   |-- Mermelada__Parar__Actividad__Parar.ps
|   |   |   |-- Mermelada__Parar__Secuencia__InteractionInstance1__Parar.ps
|   |   |   |-- Mermelada__esclavo 1__estados.ps
|   |   |   |-- Mermelada__esclavo2__estados.ps
|   |   |   |-- Mermelada__maestro__estados.ps
|   |   |   |-- bender.eps
|   |   |   |-- cocomo.eps
|   |   |   |-- costes-proyecto.eps
|   |   |   |-- costos-proyecto.pdf
|   |   |   |-- esclavo1.eps
|   |   |   |-- esclavo2.eps
|   |   |   |-- instalacion.ps
|   |   |   |-- maestro.eps
|   |   |   |-- planificacion.ps
|   |   |   |-- sensor_tapon.ps
|   |   |   `-- vaf.eps
|   |   |-- presupuesto #una simple hoja de cálculo para trabajar con ella
|   |   |   |-- CVS
|   |   |   `-- hardware.ods
|   |   |-- pruebas_aceptacion #cositas para las pruebas
|   |   |   |-- CVS
|   |   |   |-- hoja_pruebas_aceptacion.csv #el fichero que se procesa, derivado del excel
|   |   |   |-- hoja_pruebas_aceptacion.excel.xml #fichero de excel para trabajar
|   |   |   |-- procesar_pruebas.py #script que procesa el csv y lo transforma en xml docbook
|   |   |   `-- pruebas_aceptacion.docbook.xml #fragmento de docbook
|   |   `-- requisitos #los requisitos de usuario y del software
|   |       |-- CVS
|   |       |-- README.TXT #instrucciones para usarlos
|   |       |-- hoja_requisitos.csv #fichero para procesar, derivado del xls
|   |       |-- hoja_requisitos.xls #fichero de excel, para trabajar
|   |       |-- matriz-d-sr-ur.docbook.xml #matriz de trazabilidad, derivada del script
|   |       |-- matriz-i-sr-ur.docbook.xml #matriz de trazabilidad, derivada del script
|   |       |-- matriz.py #módulo genérico para las matrices de trazabilidad
|   |       |-- matriz.pyc #bytecode de python
|   |       |-- procesar_lista_requisitos.py #script que genera listas de requisitos
|   |       |-- procesar_matriz_directa.py #script que genera una matriz de trazabilidad directa
|   |       |-- procesar_matriz_inversa.py #script que genera una matriz de trazabilidad inversa
|   |       |-- requisitos-sr.docbook.xml #fragmento docbook, derivado
|   |       |-- requisitos-ur.docbook.xml #fragmento docbook, derivado
|   |       |-- requisitos.py #modulo generico para los requisitos
|   |       |-- requisitos.pyc #bytecode de python
|   |       `-- urd.xml #fragmento de docbook, que incrusta los *.docbook.xml
|   |-- disenyo #otro documento, más de lo mismo
|   |   |-- CVS
|   |   |-- Makefile
|   |   |-- chap_contexto.xml
|   |   |-- chap_descripcion.xml
|   |   |-- chap_descripcion_completo.xml
|   |   |-- chap_disenyo.xml
|   |   |-- chap_estandares.xml
|   |   |-- chap_introduccion.xml
|   |   |-- chap_viabilidad.xml
|   |   |-- chap_vision_sistema.xml
|   |   |-- componentes #descripción detallada de los componentes software
|   |   |   |-- CVS
|   |   |   |-- matriz-trazabilidad.docbook.xml #derivado
|   |   |   |-- modelo_componentes.xls
|   |   |   |-- modulo_automatas #una carpetita para modulito
|   |   |   |   |-- CVS
|   |   |   |   |-- especificacion-componentes.docbook.xml #fichero derivado del csv
|   |   |   |   |-- modelo_componentes.csv #csv exportado del xls
|   |   |   |   |-- modelo_componentes.xls #descripción de los componentes
|   |   |   |   `-- pseudocodigo #pseudocódigo de los componentes
|   |   |   |       |-- CVS
|   |   |   |       |-- TODO
|   |   |   |       |-- comp_AUT-003.txt
|   |   |   |       |-- comp_AUT-004.txt
|   |   |   |       |-- comp_AUT-005.txt
|   |   |   |       |-- ... #muchos más
|   |   |   |       `-- comp_AUT-059.txt
|   |   |   |-- modulo_comunicaciones #otro modulito, igual que el anterior
|   |   |   |   |-- CVS
|   |   |   |   |-- especificacion-componentes.docbook.xml
|   |   |   |   |-- modelo_componentes.csv
|   |   |   |   |-- modelo_componentes.xls
|   |   |   |   `-- pseudocodigo
|   |   |   |       |-- CVS
|   |   |   |       |-- comp_COM-003.txt
|   |   |   |       |-- comp_COM-004.txt
|   |   |   |       |-- ... #muuuuuuchos más
|   |   |   |       `-- comp_COM-100.txt
|   |   |   |-- ... #un par de módulos más
|   |   |   `-- scripts
|   |   |       |-- CVS
|   |   |       |-- modulos.py #modulo genérico para los módulos... vaya juego de palabras
|   |   |       |-- modulos.pyc #bytecode de python
|   |   |       |-- procesar_lista_modulos.py #genera la lista de los módulos de un componente
|   |   |       `-- procesar_matriz_trazabilidad.py #genera las matrices de trazabilidad
|   |   |-- disenyo.xml #documento maestro
|   |   |-- disenyo_final.pdf #resultado final
|   |   |-- disenyo_final.ps #resultado intermedio
|   |   |-- disenyo_final.xml #resultado intermedio
|   |   `-- images #graficos para incrustar
|   |       |-- CVS
|   |       |-- Disenyo__Automatas__Main.eps
|   |       |-- Disenyo__Comunicaciones__Buzon__Main.eps
|   |       |-- Disenyo__Comunicaciones__Main.eps
|   |       |-- Disenyo__Comunicaciones__Mensajes__Main.eps
|   |       |-- Disenyo__GestorInformes__Main.eps
|   |       |-- Disenyo__Main.eps
|   |       |-- Disenyo__SCADA__Main.eps
|   |       |-- Mermelada__Automatas__Main.ps
|   |       |-- Mermelada__Comunicaciones__Buzon__Main.ps
|   |       |-- Mermelada__Comunicaciones__Main.ps
|   |       |-- Mermelada__Comunicaciones__Mensajes__Main.ps
|   |       |-- Mermelada__GestorInformes__Main.ps
|   |       |-- Mermelada__Main.ps
|   |       |-- Mermelada__SCADA__Main.ps
|   |       |-- bender.eps
|   |       `-- diagrama_contexto.ps
|   |-- manual_usuario #el manual. estamos trabajando en él ahora mismo
|   |   |-- CVS
|   |   |-- Makefile
|   |   |-- images
|   |   |   |-- CVS
|   |   |   `-- bender.eps
|   |   `-- sum.xml
|   `-- stylesheets #plantillas comunes (sólo se usa custom.dsl, las otras son de referencia)
|       |-- CVS
|       |-- cogent-both.dsl
|       |-- custom.dsl
|       |-- freebsd_tuned.dsl
|       |-- gdp-both.dsl
|       `-- guide.dsl
`-- plantillas_docbook #ejemplos de archivos docbook
|-- CVS
|-- Makefile #ejemplo de makefile
|-- articulo.xml #ejemplo de articulo, para los manuales
|-- chap1src.xml #ejemplo de capitulo, para incluir en documentos
|-- images #varios logos, para guarrear
|   |-- CVS
|   |-- logo.wmf
|   |-- logotipo1.gif
|-- libro.xml #ejemplo de libro
|-- prueba.xml #no sé qué tenía este, creo que era un ejemplo de xinclude
`-- stylesheets
|-- CVS
|-- cogent-both.dsl
|-- custom.dsl
|-- gdp-both.dsl
`-- ldp.dsl

57 directories, 468 files

Ahora vamos a hablar un poco más detalladamente de cada tipo de archivo.

Los XML de DocBook

Para el que no conozca DocBook, habría que decir que es un lenguaje de marcas XML diseñado para escribir documentos estructurados. Los documentos estructurados son aquellos que tienen partes, capítulos, secciones, subsecciones, etc.

La edición de estos documentos puede ser un tanto tediosa si se hace a mano sin ningún editor especializado (que nos ayude con las marcas), pero tiene la ventaja de que al ser texto plano (bueno, al ser XML no es plano, es un árbol :-P), lo cuál tiene algunas recompensas:

• Se puede gestionar directamente con un SCV, como CVS ó SVN, con lo cuál se mantiene un histórico de las revisiones, se puede volver a una versión anterior en el caso de fallo, se puede ver quién ha escrito cada cosa...
• Se pueden hacer fácilmente programas que escriban este tipo de documentos (lo cuál lo explotaremos bastante).
• Se puede editar en (casi) cualquier parte.

Una nota a tener en cuenta aquí, es que como estamos usando OpenJade, le gustan los documentos que están codificados en el formato ISO-8859-1 (eso, o escapáis todos los caracteres acentuados), para lo cuál deberéis especificarlo en las opciones del editor que uséis.

Nosotros también queremos tener documentos modulares, lo cuál lo conseguiremos con dos tecnologías: XInclude y las System Entities de XML.

XInclude

XInclude tiene una ventaja y un inconveniente principales. La ventaja es que permite hacer un pre-procesado de los documentos a incluir, como puede ser seleccionar una rama del XML concreta para incluir ó escapar los caracteres no válidos en un documento XML al incluir texto plano (como los > y los <, por ejemplo).

El inconveniente es que el motor de render que usamos (Jade) no lo procesa correctamente (para los que usen XSL-FO no creo que tengan este problema, pero yo ya había apostado por Jade, ¡y uno no aprende DSSSL para luego cambiarse!).

Para solucionar el problema de procesamiento, optamos por hacer un pre-procesado de los documentos con una herramienta externa, en este caso xmllint.

System Entities

Es un mecanismo bastante más sencillo que el XInclude, ya que simplemente vuelva el contenido del fichero incluido en el maestro, lo cuál tiene el problema de que por lo general, los documentos que incluyamos no serán de por sí documentos DocBook válidos (por las cabeceras y tal) y no serán reconocidos como tal por los editores XML.

Esta característica nos viene muy bien para incluir los cachos de DocBook generados por nuestros programas, ya que en ellos no querremos perder tiempo declarando cabeceras, ni puede que sepamos de antemano en qué rama estarán metidos.

Gráficos

Como habréis podido observar, los gráficos están en formato PS ó EPS, que son formatos de gráficos vectoriales, lo cuál nos vendrá bien para que los diagramas no pierdan calidad en los documentos.

El problema que tienen estos gráficos es que están definidos en un lenguaje de programación de impresoras (que por cierto, es muy divertido aprenderlo, yo lo estoy haciendo) y no hay programas para editarlos directamente... pero por suerte, desde (casi) cualquier programa se puede exportar a PostScript, si bien no directamente, sí mediante la opción de imprimir a un archivo (habiendo instalado los drivers de una impresora PostScript, como los de casi cualquier impresora Láser).

Un pequeño escollo con el que nos encontramos aquí es que al generar los PDF's a partir de DocBook con Jade, nos dice que no le gustan los ficheros PS ni EPS. La solución es crear un PS con Jade y luego convertirlo a PDF con ps2pdf.

Las hojas de cálculo XLS y los CSV

Las hojas de cálculo son para editar registros de formato fijo, como son las típicas plantillas de requisitos y módulos de sofware. Con un poco de arte, se pueden automatizar varias cosillas, como la numeración automática, la selección de enumerados, etc.

Aquí os pongo un par de pantallazos para que veáis de qué hablo:


El problema de usar los XLS es que son ficheros binarios y no se llevan muy bien con el CVS, así que si usáis Excel (a partir del 2003, creo), podéis guardarlos en el XML ese guarruzo de Microsoft. Si usáis OpenOffice, podéis seguir el tutorial de Pesso para guardar los documentos ODF en texto plano que enlazaré en cuanto esté listo. Si usáis Gnumeric, sólo tenéis que ir a preferencias, y especificar que el nivel de compresión de los archivos es 0.

Los CSV tienen algunas consideraciones especiales, para que puedan ser procesados más fácilmente:

• Usar el tabulador como separador.
• No usar delimitadores para el texto.
• Estar codificados en UTF-8
  

Los scripts en Python

Para los que no lo conozcan, Python es un lenguaje dinámico interpretado, que te permite hacer muchas guarrerías de forma elegante y rápida, por lo que resulta ideal para lo que queremos hacer aquí.

Estos scripts también deberían estar codificados en UTF-8.

Estos scripts leeran los CSV y generarán cachos de DocBook a porrillo... como no hay mucho más que decir, aquí los pongo tal cual:

anteproyecto/requisitos/requisitos.py

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import sys

"""Encapsula un requisito"""
class Requirement:
def __init__(self):
self.id = ""
self.type = ""
self.nid = -1
self.priority = ""
self.need = ""
self.stability = ""
self.source = ""
self.description = ""
self.verification = ""
self.dependencies = []
def __init__(self, line):
self.parse(line)

def parse(self, line):
tokens = line.strip().split("\t")
self.type = tokens[0]
self.nid = int(tokens[1])
self.id = tokens[2]
self.priority = tokens[3]
self.need = tokens[4]
self.stability = tokens[5]
self.source = tokens[6]
self.description = tokens[7]
self.verification = tokens[8]
self.dependencies = tokens[9:]

def printDocBookSheet(self):
print "<table id =\""+self.id+"\">"
print "<title>"+self.id+"</title>"
print "<tgroup cols=\"4\"><tbody>"
print "<row>"
print "<entry><emphasis role=\"strong\">Prioridad</emphasis></entry>"
print "<entry>", self.priority,"</entry>"
print "<entry><emphasis role=\"strong\">Necesidad</emphasis></entry>"
print "<entry>", self.need,"</entry>"
print "</row>"
print "<row>"
print "<entry><emphasis role=\"strong\">Estabilidad</emphasis></entry>"
print "<entry>", self.stability, "</entry>"
print "<entry><emphasis role=\"strong\">Fuente</emphasis></entry>"
print "<entry>", self.source, "</entry>"
print "</row>"
print "</tbody></tgroup>"
print "<tgroup cols=\"1\"><tbody>"
print "<row>"
print "<entry><emphasis role=\"strong\">Descripción</emphasis></entry>"
print "</row>"
print "<row>"
print "<entry>", self.description, "</entry>"
print "</row>"
print "<row><entry><emphasis role=\"strong\">Dependencias</emphasis></entry></row>"
print "<row><entry>"
for i in self.dependencies:
   print "<link linkend=\"" +i+"\">", i, "</link>"
print "</entry></row>"
print "</tbody></tgroup>"
print "</table>"

def createRequirementsList():
reqs = []
headings = True
for line in sys.stdin.readlines():
if headings:
   if line.startswith("\t"):
           headings = False
else:
   if not line.startswith("\t"):
           r = Requirement(line)
           reqs.append(r)
return reqs

anteproyecto/procesar_lista_requisitos.py

from requisitos import *
import sys

def main():
type = sys.argv[1]

reqs = createRequirementsList()

for r in reqs:
if r.type == type:
r.printDocBookSheet()

main()

anteproyecto/requisitos/matriz.py

from requisitos import *

def directTraceabilityMatrix(reqs, fromType, toType):
matrix = []
types = {}
for i in reqs:
types[i.id] = i.type

for i in reqs:
#si tenemos un requisito del tipo de partida
if i.type == fromType:
#cogemos las dependencias del tipo de destino
d = [j for j in i.dependencies if types[j] == toType]
matrix.append((i.id, d))
return matrix

def inverseTraceabilityMatrix(reqs, fromType, toType):
matrix = []
table = {}
types = {}

#inicializamos la tabla
for i in reqs:
if i.type == toType:
table[i.id] = []

for i in reqs:
types[i.id] = i.type

for i in reqs:
#si tenemos un requisito del tipo de destino
if i.type == fromType:
#miramos las dependencias del tipo de partida
for j in i.dependencies:
if types[j] == toType:
table[j].append(i.id)

#pasamos de la tabla a la lista
for i in table:
matrix.append((i, table[i]))

matrix.sort()

return matrix

def printTraceabilityMatrix(matrix, title):
print "<table>"
print "<title>", title, "</title>"
print "<tgroup cols = \"2\">"
print "<colspec colwidth=\"1*\"/>"
print "<colspec colwidth=\"4*\"/>"
print "<tbody>"
for i,j in matrix:
print "<row>"
print "<entry>", link(i), "</entry>"
print "<entry>"
for k in j:
print link(k)
print "</entry>"
print "</row>"
print "</tbody>"
print "</tgroup>"
print "</table>"
return

def link(r):
return "<link linkend=\""+r+"\">"+r+"</link>"

anteproyecto/requisitos/procesar_matriz_directa.py

from matriz import *

def main():
fromType = sys.argv[1]
toType = sys.argv[2]
title = sys.argv[3]

reqs = createRequirementsList()
matrix = directTraceabilityMatrix(reqs, fromType, toType)
printTraceabilityMatrix(matrix, title)

main()

anteproyecto/requisitos/procesar_matriz_inversa.py

from matriz import *

def main():
fromType = sys.argv[1]
toType = sys.argv[2]
title = sys.argv[3]

reqs = createRequirementsList()
matrix = inverseTraceabilityMatrix(reqs, fromType, toType)
printTraceabilityMatrix(matrix, title)

main()

Makefile (juntándolo todo)

Si alguna vez has utilizado "make", seguramente ya tendrás una idea de cómo funcionan los Makefiles, pero por si acaso, primero haré una breve introducción.

La herramienta make sirve para gestionar dependencias en proyectos, por lo que normalmente se asocia con programas en C (para no tener que compilar módulos que no han sido modificados), pero se puede usar para automatizar casi cualquier proceso de flujo de datos.

Los ficheros Makefile están formados por una lista de reglas, que están separadas entre sí por una o más líneas en blanco. Las reglas tienen 3 partes:

• Objetivo (nombre del fichero a actualizar o de la regla)
• Dependencias (otras reglas o nombres de ficheros de los que dependa el objetivo)
• Acciones (comandos que se ejecutan para crear o actualizar el objetivo)

Así que tenemos que una regla es:

objetivo : dep1 dep2 dep3 #y más... a partir de la almohadilla va comentado
accion1
accion2
#y más...

Ahora aquí van los Makefiles que hemos usado:

anteproyecto/Makefile

NAME = anteproyecto

FLAGS = --dcl `if test -e /usr/share/sgml/xml.dcl ;then echo /usr/share/sgml/xml.dcl; else locate xml.dcl | tail -n1; fi`
STYLESHEET = ../stylesheets/custom.dsl

MOD_REQ = requisitos/requisitos.py
MOD_MAT = requisitos/matriz.py
PROC_LIST_REQ = requisitos/procesar_lista_requisitos.py
PROC_MAT_D_REQ = requisitos/procesar_matriz_directa.py
PROC_MAT_I_REQ = requisitos/procesar_matriz_inversa.py

HOJA_REQUISITOS = requisitos/hoja_requisitos.csv
MATRIZ_D_SR_UR = requisitos/matriz-d-sr-ur.docbook.xml
MATRIZ_I_SR_UR = requisitos/matriz-i-sr-ur.docbook.xml

all: pdf view

view:
        xpdf $(NAME)_final.pdf || evince $(NAME)_final.pdf || acroread $(NAME)_final.pdf

pdf: $(NAME)_final.pdf

html: $(NAME)_final.xml $(STYLESHEET)
        db2html $(FLAGS) $(NAME)_final.xml
        cp -r images $(NAME)_final

$(NAME)_final.pdf: $(NAME)_final.ps
        ps2pdf $<

$(NAME)_final.ps: $(STYLESHEET) $(NAME)_final.xml ../images/* images/*
        db2ps $(FLAGS) -d $(STYLESHEET) $(NAME)_final.xml

$(NAME)_final.xml: $(NAME).xml chap*.xml requisitos matrices pruebas cocomo/*
        xmllint --noent --encode "iso-8859-1" --xinclude $(NAME).xml > $@

#REQUISITOS

requisitos: requisitos/requisitos-ur.docbook.xml requisitos/requisitos-sr.docbook.xml

requisitos/hoja_requisitos.csv: requisitos/hoja_requisitos.xls
        echo $@ : HAY QUE ACTUALIZAR EL CSV A MANO!!!
        false

requisitos/requisitos-ur.docbook.xml: requisitos/hoja_requisitos.csv $(PROC_LIST_REQ)
        cat $< | python $(PROC_LIST_REQ) UR > $@

requisitos/requisitos-sr.docbook.xml: requisitos/hoja_requisitos.csv $(PROC_LIST_REQ)
        cat $< | python $(PROC_LIST_REQ) SR > $@

#MATRICES REQUISITOS
matrices: $(MATRIZ_D_SR_UR) $(MATRIZ_I_SR_UR)

$(MATRIZ_D_SR_UR): $(HOJA_REQUISITOS) $(PROC_MAT_D_REQ) $(MOD_REQ) $(MOD_MAT)
        cat $< | python $(PROC_MAT_D_REQ) SR UR "Matriz de dependencias directas SR-UR" > $@
        
$(MATRIZ_I_SR_UR): $(HOJA_REQUISITOS) $(PROC_MAT_I_REQ) $(MOD_REQ) $(MOD_MAT)
        cat $< | python $(PROC_MAT_I_REQ) SR UR "Matriz de dependencias inversas SR-UR" > $@

#PRUEBAS ACEPTACION

pruebas: pruebas_aceptacion/pruebas_aceptacion.docbook.xml

pruebas_aceptacion/hoja_pruebas_aceptacion.csv: pruebas_aceptacion/hoja_pruebas_aceptacion.excel.xml
        echo $@ : HAY QUE ACTUALIZAR EL CSV A MANO!!!
        false

pruebas_aceptacion/pruebas_aceptacion.docbook.xml: pruebas_aceptacion/hoja_pruebas_aceptacion.csv pruebas_aceptacion/procesar_pruebas.py
        cat $< | python pruebas_aceptacion/procesar_pruebas.py PA > $@


#PRESUPUESTO


#CLEAN
clean:
        rm -rf $(NAME)_final || true
        rm -rf $(NAME)_final.junk || true
        rm $(NAME)_final.xml || true
        rm *.tex *.aux *.dvi *.log *.out *.ps *.pdf || true
        rm requisitos/requisitos-??.docbook.xml || true
        rm requisitos/matriz-?-??-??.docbook.xml || true
        rm pruebas_aceptacion/pruebas_aceptacion.docbook.xml || true

disenyo/Makefile

NAME = disenyo

FLAGS = --dcl `if test -e /usr/share/sgml/xml.dcl ;then echo /usr/share/sgml/xml.dcl; else locate xml.dcl | tail -n1; fi`
STYLESHEET = ../stylesheets/custom.dsl

HOJA_AUT = componentes/modulo_automatas
HOJA_GEI = componentes/modulo_gestor_informes
HOJA_GUI = componentes/modulo_gui
HOJA_COM = componentes/modulo_comunicaciones
SCRIPT_COMPONTENTES = componentes/scripts/procesar_lista_modulos.py
SCRIPT_MATRIZ = componentes/scripts/procesar_matriz_trazabilidad.py

all: pdf view componentes

view:
        xpdf $(NAME)_final.pdf || evince $(NAME)_final.pdf || acroread $(NAME)_final.pdf

pdf: $(NAME)_final.pdf

html: $(NAME)_final.xml $(STYLESHEET)
        db2html $(FLAGS) $(NAME)_final.xml
        cp -r images $(NAME)_final

$(NAME)_final.pdf: $(NAME)_final.ps
        ps2pdf $<

$(NAME)_final.ps: $(STYLESHEET) $(NAME)_final.xml ../images/* images/*
        db2ps $(FLAGS) -d $(STYLESHEET) $(NAME)_final.xml

preprocesado_xinclude_nivel2: chap_descripcion.xml
        xmllint --noent --encode "iso-8859-1" --xinclude chap_descripcion.xml > chap_descripcion_completo.xml

$(NAME)_final.xml: $(NAME).xml chap*.xml matriz componentes preprocesado_xinclude_nivel2
        xmllint --noent --encode "iso-8859-1" --xinclude $(NAME).xml > $@
        
#COMPONENTES

matriz:
        python ${SCRIPT_MATRIZ} ${HOJA_AUT}/modelo_componentes.csv ${HOJA_COM}/modelo_componentes.csv ${HOJA_GEI}/modelo_componentes.csv ${HOJA_GUI}/modelo_componentes.csv > componentes/matriz-trazabilidad.docbook.xml

componentes: ${HOJA_AUT}/especificacion-componentes.docbook.xml ${HOJA_COM}/especificacion-componentes.docbook.xml ${HOJA_GEI}/especificacion-componentes.docbook.xml ${HOJA_GUI}/especificacion-componentes.docbook.xml

${HOJA_AUT}/modelo_componentes.csv: ${HOJA_AUT}/modelo_componentes.xls
echo $@ : HAY QUE ACTUALIZAR EL CSV ${HOJA_AUT} A MANO!!!
false

${HOJA_COM}/modelo_componentes.csv: ${HOJA_COM}/modelo_componentes.xls
echo $@ : HAY QUE ACTUALIZAR EL CSV ${HOJA_COM} A MANO!!!
false

${HOJA_GEI}/modelo_componentes.csv: ${HOJA_GEI}/modelo_componentes.xls
echo $@ : HAY QUE ACTUALIZAR EL CSV ${HOJA_GEI} A MANO!!!
false

${HOJA_GUI}/modelo_componentes.csv: ${HOJA_GUI}/modelo_componentes.xls
echo $@ : HAY QUE ACTUALIZAR EL CSV ${HOJA_GUI} A MANO!!!
false

${HOJA_AUT}/especificacion-componentes.docbook.xml: ${HOJA_AUT}/modelo_componentes.csv $(SCRIPT_COMPONTENTES)
cat $< | python $(SCRIPT_COMPONTENTES) ${HOJA_AUT}/pseudocodigo < ${HOJA_AUT}/modelo_componentes.csv > $@

${HOJA_COM}/especificacion-componentes.docbook.xml: ${HOJA_COM}/modelo_componentes.csv $(SCRIPT_COMPONTENTES)
cat $< | python $(SCRIPT_COMPONTENTES) ${HOJA_COM}/pseudocodigo < ${HOJA_COM}/modelo_componentes.csv > $@

${HOJA_GEI}/especificacion-componentes.docbook.xml: ${HOJA_GEI}/modelo_componentes.csv $(SCRIPT_COMPONTENTES)
cat $< | python $(SCRIPT_COMPONTENTES) ${HOJA_GEI}/pseudocodigo < ${HOJA_GEI}/modelo_componentes.csv > $@

${HOJA_GUI}/especificacion-componentes.docbook.xml: ${HOJA_GUI}/modelo_componentes.csv $(SCRIPT_COMPONTENTES)
cat $< | python $(SCRIPT_COMPONTENTES) ${HOJA_GUI}/pseudocodigo < ${HOJA_GUI}/modelo_componentes.csv > $@

#CLEAN
clean:
        rm `find componentes -name "*.docbook.xml"` || true
        rm -rf $(NAME)_final || true
        rm -rf $(NAME)_final.junk || true
        rm $(NAME)_final.xml || true
        rm *.tex *.aux *.dvi *.log *.out *.ps *.pdf || true

Bueno, pues hasta aquí hemos llegado, que ya estoy hasta los cojones de escribir... si encuentro algún josting de archivos chulo, cuelgo un tbz con todo (o si alguien lo quiere, que me mande un mail a fortranito arroba gmail punto com).

Y recordad: ¡make es vuestro amigo!

Fortran by Warchief

Me he traido la tableta gráfica a la facultad para hacer unos diagramas para una práctica (y de paso vacilar un poco) y un colega freak ha hecho una caricatura:

Ya le pillaré por banda en alguna tira... xD

Vaya Tirantazo

Debido a que casi nadie la pilla, antes de leer la tira, es conveniente saber esto

el Tito Fortran dibuja para El Listo

Me llena de orgullo poder contaros que ya se ha publicado una colaboración que he realizado con el equipo de Listo Entertainement, la podéis ver aquí:



Si no conocéis los cómics, aprovoechad para pegaros un buen empacho :D

Ah, he de añadir que debido a cometer el error de intentar cambiar de operador de ADSL, estoy jodido y sin conexión, así que si no respondo a los comentarios con celeridad o el ritmo de publicación es bajo, lo siento :-s

Juegos Satánicos

hay cosas peores que el garrafón

Lo prometido es deuda, ahí tenéis la tira grosera y soez que esperábais ;-)

el movimiento browniano

si no lo coges, deja un comentario y veremos qué se puede hacer al respecto :p

disco-man

a que no os esperábais ese final, eh? xD

la biblioteca en exámenes

Sé que pilla un poco fuera de época, pero es algo que siempre hemos pensado los ingenieros...

chickspotting

¡Aquí va la primera tira de los nuevos personajes hechos con la tableta gráfica!

más dibujos

Bueno, ya tengo la tableta gráfica funcionando, aunque sólo sea en Windows (es un marrón bastante gordo instalar los drivers para Linux, así que si alguien lo ha conseguido y lee esto, que se tire el rollo y deje un comentario xD) y me he puesto a hacer unos cuantos garabatos, para ir cogiéndole el tranquillo...

Aquí están las criaturas, dispuestas a someterse a la votación popular como si de un vulgar concurso de Miss España se tratase.

¿Cuáles te gustan más?
	El número uno (que te folle un tuno)
	El número dos (no me acuerdo de la rima)
	El número tres (te la meto del revés)
	El número cuatro (pá tu culo mi aparato)
	El número cinco (por el culo te la hinco)
	El numero seis (os la meto y no lo veis)
	El número siete (mi polla en tu ojete)
	El número ocho (te la meto por el chocho)
Free polls from Pollhost.com

podéis votar por las que más os gusten para que aparezcan en futuras tiras de dibujos (no digo cómicas, porque a lo mejor me da por hacer dramas o la tira gore, que entre el público friki tiene una acogida bastante buena xD)... si creéis que a alguno le va bien algún papel en especial, los comentarios están abiertos a todas vuestras sugerencias.

después habrá que buscarles un nombre a los elegidos :-)

(por cierto, el post ha desaparecido durante algunas horas porque hice una modificación y le di a guardar como borrador por equivicación, lo siento U^_^).

crossovers absurdos

Cuando los guionistas de cómics, series y películas se quedan sin ideas, tienen que recurrir a hacer cosas raras. Algunas veces, cuando un personaje parece que mola y está estancado como secundario, pues se le hace una serie para él solo, lo que se conoce como spin off... algunos dignos ejemplos son Angel (de Buffy), Frasier (de Cheers), Cosas de Casa (de Primos Lejanos... un momento, este ejemplo ya no es tan digno). Luego están crossovers, que consiste en mezclar personajes de distintos entornos... lo que en España se ha venido conociendo desde siempre como refritos.

Algunos crossovers molan, como pueden ser los recurrentes Batman y Superman, que creo que incluso se van de cañas juntos, o las Secret Wars, donde salen casi todos los de la Marvel, incluso los King Of Fighters, donde meten peña de puñaos de videojuegos, los Aliens VS Predator (no hablamos de la película, que es un subproducto)... de hecho, creo que las criaturitas de la Fox son los all-star de los crossovers; ha llegado a mis manos una colección entera de cómics relacionados con Aliens, Predator y Terminator, crossovers incluidos, y no tienen desperdicio:

• Batman VS Aliens - Meten a Batman en la jungla y para que se luzca (si no hay público no puede ir de estrella), meten a unos comandos que parecen El Equipo B(el de Benny Hill).
• Batman VS Predator - Tiene algo más de sentido y gracia que el anterior, aunque se parece demasiado a la película Predator 2.
• Superman VS Terminator - Superman sigue sin rival cuando juega en casa, lo cuál le quita bastante interés...
• Superman VS Aliens - Tienen que alejar al Super del Sistema Solar para darle vidilla a la cosa, sin demasiado éxito. Destacable el mullet que lleva Superman, sin duda uno de los más bestias, superando incluso al Dioni de Camela.
• Judge Dredd VS Aliens - No me ha molado demasiado, no le da intensidad dramática (sabes que Dredd no va a morir, pero el resto palman como moscas) y se pasan con el tema del ácido... un solo alien hace un boquete en el suelo firme (no metales) como la boca del metro cuando lo revientan.
• Tarzán VS Predator - No me lo he leido, me da grima pensar que un tío que se ha criado con unos monos y va con un taparrabos de árbol en árbol va a ganar a un Predator.
• Witchblade VS Aliens - No he visto nada antes de Witchblade, así que como no tenía ni puta idea de qué iba el rollo no seguí leyendo... por cierto, eso son curvas y no las de Lara Croft (sí, en los primeros juegos tenía un par de triángulos y los frikis se hacían pajas pensando que eran tetas).
• WildCats VS Aliens - Lo mismo que con Witchblade pero sin las curvas.
• Robocop VS Terminator - ah, este sí que mola... alteran ligeramente la trama argumental para que el choque no sea algo puramente casual, pero está bien llevado. No en vano el guión es de Frank Miller.

Después de algunos de estos desbarres, se nos han ocurrido crossovers mejores:

• Sonic VS Correcaminos VS Speedy González VS Flash VS Eyaculador Precoz - A ver quién corre más y más rápido.
• Homer VS Wile E. Coyote VS Mortadelo y Filemón - A ver quién tiene más arte recibiendo porrazos (doh!).
• Mortadelo y Filemón VS Starsky & Hutch - El producto nacional siempre es mejor.
• Gandalf VS Juan Tamariz - Yo me quedo con el Mago Pajas.
• Ford Fairlane VS Ace Ventura VS Sherlock Holmes - ¿Quién es mejor detective? supongo que cada uno es bueno en lo suyo.
• Espinete VS Yupi - Todos tenemos claro quién es el original y quién es la copia.
• Jack Sparrow VS Madmartigan VS Han Solo - ¿Quién es más chulo, tramposo y encantador?
• James Bond VS The Transporter - Si Frank lleva el Audi en lugar del BMW, Bond no tiene nada que hacer.
• James Bond VS Jason Bourne - Bond folla más, pero seguro que se jama una buena hostia.
• Jason Bourne VS La tía de Memoria Letal - En la cama.
• Indiana Jones VS Lara Croft - En la cama también.
• Selene (la de Underworld) VS Buffy - La clásica tijereta...
• Blade VS El Vampiro Tiroriro - Yo sé de qué me hablo.
• Alguno de los de Urotsukidoji VS Nacho Vidal - A ver quién come la almohada...
  
• Marvin el Marciano VS Los de Mars Attacks - A ver quién la tiene más grande (la cabeza)... la frenología ataca de nuevo!
  
• Superman VS Goku - No sé sabe, depende del nivel de superguerrero del que estemos hablando.
• Darth Vader VS Charles Xavier - o El Sable Láser VS La Silla de Ruedas.
• La Emperatriz Infantil VS Michael Jackson - ¿En la cama?
• Comepiedras VS La Cosa (la de los 4F)- ¿Se lo comerá o se la comerá?
• Godzilla VS Chtulhu - Habría que verlo.
• Superman VS McGyver - Todos sabemos que va a ganar McGyver, claro.
• Cerverza Duff VS Hilary Duff - Yo me bebería la primera... mientras la segunda me la chupa!
  
• Torrente VS Robocop - ¿Qué podemos esperar de los dos mejores policías de la historia?
  

Si a alguien se le ocurre algún crossover absurdo (o no absurdo, qué más dá), que se anime y deje un comentario :-)

¡¡¡Y aquí va la tira de Torrente VS Robocop!!!

Tira 2

Siguiendo el guión propuesto por Adro, aquí está la esperada segunda entrega de nuestra tira sádica:

---

Actualización

---

Una vez más, aquí las versiones en color y en escala de grises...

Frases chorras para firmar en las carpetas

Me estaba acordando de mi época en el instituto, en concreto de una costumbre muy cursi que tenían las niñas... firmarse cursiladas en las carpetas unas a otras. Recuerdo claramente a algunas de las niñas con la carpeta llena de mariconadas siempre abrazada de un lado para otro. Más tarde un colega (que dice que no lee este weblog, pero que me vota dos o tres veces al día, a ver si tomáis ejemplo el resto, cabronazos) me aclaró que lo de la carpeta era para no ir rozándose con las tetas por todas partes, que como estaban desarrollando no apuntaban bien con los pitones (todo lo contrario que un toro afeitado) y que molestaba porque los tenían muy sensibles... joder, no sé si esa explicación me produce ahora más fascinación que cuando la escuché por primera vez... de todos modos, no es el tema que nos ocupa (aunque desde luego que es un tema muy sabroso y que daría para un post entero por sí solo).

Pensaba hacer una recopilación de frases chorras, pero es que me estoy descojonando con una idea... que bueno, vamos allá, a ver qué os parece esta tira (me he flipado y he hecho un enlace al estilo barrapunto :p pinchad para verla entera):

Bueno, ahí queda para la posteridad esa pequeña obra de arte postmoderno y decadente. ¿Qué? ¿Os animáis ya a hacer sugerencias, guiones y a insultarme?

Ah, también os dejo a vosotros la recopilación de frases chorras, que seguro que conocéis más que yo...

---

Actualización

---

A petición de un cabroncete intimista que no se digna a comentar por aquí :p le he dado color a la tira... yo creo que pierde algo de magia, pero la versión en escala de grises no está mal:

Novedades en el blog

Ahora que llega el verano, entre party y party, práctica y práctica, resaca y resaca, a uno le entran ganas de ponerse creativo.

Teniendo ya varias cuentas en gmail y un blog, sólo me quedaba una cosa para sentirme realizado: una tira on-line. Pero claro, para hacer una tira y no quedar como un patán hay que cumplir varios requisitos:

1. Ser original.
2. Tener gracia
3. No ser patético.

Ya sé que son una mierda de puntos, pero me apetecía poner algunos. Volviendo al tema, que apetece hacer dibujitos y colgarlos en internet, coño.

Así que tenía pensadas varias ideas, que me gustaría que comentásemos entre todos (sí, chicos, la tira va dirigida a vosotros y sólo la vais a leer vosotros, así que más vale que colaboréis).

• En lugar de una "tira cómica" hacer una "tira trágica". Que den ganas de llorar.
• Hacer una tira de 1,2,4 o más viñetas (lo importante es huir de las típicas 3 viñetas).
• Ya que estamos, en lugar de una tira, hacer un cómic entero.

Yo me decanto por la última opción. Creo que puedo hacer una producción bastante decente (de muestra un botón: desde hace unas semanas ahí arriba tenéis a la nueva mascota, espero que os guste), pero en el guión ando algo flojo; me rondan muchas ideas por la cabeza, pero no logro definir nada impactante.

Aquí es donde entráis vosotros, mis estimados lectores. Podemos hacer una historia maja entre todos, y yo me encargo de llevarla al papel (digital, eso sí).

También me he pillado la tableta digitalizadora y todo, pero los putos drivers me están jodiendo, hermano... os pongo un par de ejemplos de lo que se puede llegar a hacer simplemente con el ratón, un poco de tiempo libre y muchos huevos:

Sí, ya sé que son Espinete y D. Pinpón, pero cuando se ponen con el gore son unos profesionales (y además es fácil dibujarlos)... Seguro que estáis deseando verlos en acción con una motosierra y un machete en las manos.