<!doctype debiandoc system>
<!-- comentarios:
* URL's a package manual?
* por qué a veces usa tt y otras no para los programas ?
-->

<debiandoc>

 <book>

  <titlepag>

   <title>Guía del Nuevo Desarrollador de Debian</title>

   <author>Josip Rodin <email/jrodin@jagor.srce.hr/
   </author>
   <author>Traducido por: Javier Fernández-Sanguino Peña <email/jfs@computer.org/
<!--
Por alguna extraña razón no le gusta que haya dos autores aquí ¿?
   <author>Traducido por: Javier Fernández-Sanguino Peña <email>jfs@computer.org</email> y David Martinez <email>david.martinez@rediris.es</email> </author>
-->
   <version>versión 1.0 (translation 1.0), 25 de enero de 2000</version>

   <copyright>
   <copyrightsummary>Copyright &copy; 1998, 1999, 2000 Josip Rodin.
   Translation Copyright &copy; 1999, 2000, 2001 Javier Fernández-Sanguino Peña.</copyrightsummary>

   <p>Este documento puede ser usado en los términos descritos en 
   la Licencia Pública GNU versión 2 o posterior.

   <p>Este documento se ha hecho usando estos dos documentos como
   ejemplo:

   <p>Making a Debian Package (AKA the Debmake Manual), copyright &copy;
   1997 Jaldhar Vyas <email/jaldhar@debian.org/.

   <p>The New-Maintainer's Debian Packaging Howto, copyright &copy; 1997
   Will Lowe <email/lowe@debian.org/.
   </copyright>

  </titlepag>

  <toc sect>

  <chapt id="start">Empezando "de la Forma Correcta".

  <p>Este documento tratará de describir cómo se construye un paquete
  Debian GNU/Linux para el usuario normal de Debian (y futuros
  desarrolladores) en un lenguaje informal, y con multitud de
  ejemplos. Hay un antiguo dicho romano que dice, <em>¡Longum iter est
  per preaecepta, breve et efficax per exempla!</em> (¡Es un largo
  camino con las reglas, pero corto y eficiente con ejemplos!)

  <p>Una de las cosas que hace a Debian una de las distribuciones más
  importantes del mercado es su sistema de paquetes. Aunque hay una
  gran cantidad de programas disponibles en formato de paquetes de
  Debian, algunas veces necesitarás instalar programas que no estén
  así. Puedes preguntarte cómo harás tus propios paquetes y que
  quizás ésta sea una tarea demasiada difícil. Bueno, si eres un
  novato en Linux, sí es duro, pero si eres todo un experto, no
  deberías estar leyendo esto ahora mismo. :-) Necesitas saber algo
  sobre programación en Unix, pero desde luego no tienes que ser un
  maestro.

  <p>Se pueden obtener versiones nuevas de este documento en línea
  en <url name="http://www.debian.org/doc/maint-guide"
  id="http://www.debian.org/doc/maint-guide"> y en el paquete
  'maint-guide-es'.

  <sect id="needprogs">Programas que necesitas para el desarrollo.

  <p>Antes de empezar nada, deberías asegurarte que tienes instalados
  algunos paquetes adicionales necesarios para el desarrollo. Observa
  que en la lista no están incluidos paquetes `esenciales' o
  `necesarios' que se suponen ya instalados.

  <p>Este documento fue escrito cuando la distribución `slink' 2.1 era
  la distribución estable oficial de Debian, y `potato' 2.2 estaba en
  fase de desarrollo. Por ello, los paquetes que se indicarán aquí son
  principalmente aquellos de `potato'.

  <p>Los siguientes paquetes vienen en una instalación estándar de
  Debian 2.1, así que probablemente ya los tengas (junto con los
  paquetes de los que dependen). Aún así, deberías comprobarlo con
  `dpkg -s &lt;paquete&gt;`.

  <list>
  <item><em>binutils</em> - estos programas se usan para ensamblar y
  enlazar ficheros objeto - aquellos que componen los programas (ve a
  `info binutils`)

  <item><em>cpp</em> - el preprocesador de C. (ve a <manref
  name="cpp" section="1">)

  <item><em>cpio</em> - este es un programa archivador como tar o zip.
  (ve a <manref name="cpio" section="1">)

  <item><em>dpkg-dev</em> - este paquete contiene las herramientas
  necesarias para desempaquetar, construir y enviar paquetes fuente de
  Debian. (ve a <manref name="dpkg-source" section="1">)

  <item><em>file</em> - este útil programa puede determinar de qué
  tipo es un fichero. (ve a <manref name="file" section="1">)

  <item><em>gcc</em> - el compilador de C de  GNU. La mayor parte de
  los programas de Linux están escritos en C. Si tu programa está
  escrito en algún otro lenguaje de programación como C++, Fortran o
  Pascal, deberías instalar g++, g77, o gpc, respectivamente.
  (lee <manref name="gcc" section="1">, <manref name="g++"
  section="1">, <manref name="g77" section="1">, <manref name="gpc"
  section="1">)

  <item><em>libc6-dev</em> - las librerías y cabeceras de fichero de C
  que gcc necesita para enlazar y crear ficheros objeto. Aunque
  algunos programas recomiendan y/o usan libc5, te sugiero que
  utilices la nueva versión (libc6). (revisa `info libc`)

  <item><em>make</em> - habitualmente la creación de un programa tiene
  varios pasos. En lugar de ejecutar los mismos comandos una y otra
  vez, puedes utilizar este programa para automatizar el proceso,
  creando `Makefile's. Algunos programas también usan imake y xmkmf,
  programas para generar Makefiles de un conjunto de funciones
  macro. Algunos programas más nuevos usan guiones de configuración y
  Makefiles con la ayuda de programas como autoconf y automake, así
  que puedes necesitarlos también. (ve a `info make`, <manref
  name="imake" section="1">, <manref name="xmkmf" section="1">,
  <manref name="autoconf" section="1">, <manref name="automake"
  section="1">)

  <item><em>patch</em> - esta utilidad es muy práctica, ya que permite
  tomar un fichero que contiene un listado de diferencias (producido
  por el programa diff) y aplicárselas al fichero original,
  produciendo una versión "parcheada". (ve a <manref name="patch"
  section="1">)

  <item><em>perl5</em> - Perl es uno de los lenguajes interpretados
  para hacer guiones más usados en los sistemas Un*x de hoy,
  comúnmente referido como la "Sierra Mecánica Suiza de Unix". (ve
  <manref name="perl" section="1">)
  </list>

  <p>De la sección `devel' de la distribución posiblemente necesites
  instalar esto tú mismo:

  <list> 
  <item><em>dh-make</em> y <em>debhelper</em> - dh-make es necesario
  para crear el esqueleto de nuestro paquete ejemplo, y se usarán
  algunas de las herramientas de debhelper para crear paquetes. No son
  imprescindibles para la creación de paquetes, pero se recomienda
  <strong>encarecidamente</strong> para nuevos desarrolladores. Hace
  el proceso mucho más fácil al principio, y más fácil de controlar
  también más adelante. (ve a <manref name="dh_make" section="1">,
  <manref name="debhelper" section="1">,
  /usr/share/doc/debhelper/README)
  
  <item><em>devscripts</em> - este paquete contiene algunos guiones
  útiles para los desarrolladores, pero no son necesarios para crear
  paquetes. (ve a /usr/share/doc/devscripts/README.gz)
    
  <item><em>fakeroot</em> - esta utilidad te permite emular ser root
  (superusuario, n. del t.) lo cual es necesario para ciertas partes
  del proceso de construcción. (ve a <manref name="fakeroot"
  section="1">)

  <item><em>lintian</em> - este es el gestor de paquetes de Debian,
  que te indica muchos de los errores comunes después de construir un
  paquete, y explica los errores. Hace falta tener instalado diffstat
  también, una pequeña utilidad que crea histogramas a partir de la
  salida de diff. (ve a <manref name="lintian" section="1">, <manref
  name="diffstat" section="1">,
  /usr/share/doc/lintian/lintian.html/index.html)
  </list>

  <p>Por último, estos paquetes de <em>gran importancia</em> están en
  la sección 'doc' de la distribución:

  <list>
  <item><em>debian-policy</em> - incluye la estructura y contenidos
  del archivo, ciertas notas sobre diseño del SO, el Estándar de la
  Jerarquía del Sistema de Ficheros (Filesystem Hierarchy Standard,
  n. del t.), y, lo más importante (para ti) es que describe los
  requisitos que debe satisfacer cada paquete para ser incluido en la
  distribución. (mira
  /usr/share/doc/debian-policy/policy.html/index.html)

  <item><em>developers-reference</em> - para todos los temas no
  específicamente relacionados con los detalles técnicos de cómo
  empaquetar, como la estructura del archivo, cómo renombrar,
  abandonar, coger paquetes, cómo hacer NMUs (Non-Maintainer Uploads,
  o envíos por personas distintas del desarrollador, n. del t.), como
  gestionar los errores que los usuarios envíen, y cómo y cuando
  enviar los paquetes, etc.
<!-- traduzco upload por "enviar" pero no me gusta mucho - jfs -->
  (lee
  /usr/share/doc/developers-reference/developers-reference.html/index.html)

  <item><em>packaging-manual</em> - describe los aspectos técnicos de
  cómo crear paquetes binarios y fuentes en Debian.
  (lee /usr/share/doc/packaging-manual/packaging.html/index.html)
  </list>

  <p>También necesitarás un paquete criptográfico, o bien PGP (los
  paquetes pgp-*) o GPG (el paquete gnupg), para <em>firmar</em>
  digitalmente tu paquete. Esto es especialmente importante si quieres
  distribuir tu paquete a otras personas (y harás precisamente esto
  si tu paquete se incluye en la distribución de Debian). Sin embargo,
  debido a una estúpida ley de exportación de los EEUU, no puedes
  simplemente obtenerlo de tu servidor FTP de Debian más cercano. Pero
  Debian ofrece estos paquetes a través de un servidor que no está
  físicamente en EEUU, llamado non-US.debian.org
  (ftp://non-us.debian.org/debian-non-US/). Tu servidor FTP tendrá un
  fichero llamado README.non-us, que te indicará dónde está la réplica
  más cercana de este servidor.

  <p>Las breves descripciones dadas anteriormente sólo sirven para
  introducirte a lo que hace cada paquete. Antes de continuar, por
  favor, lee la documentación de cada programa, al menos para su uso
  normal. Puede parecerte algo duro ahora, pero más adelante estarás
  <em>muy</em> contento de haberla leído.

  Nota: <em>debmake</em> es una paquete que incluye otros programas
  con funciones similares a dh-make, pero su uso específico
  <strong>no</strong> está cubierto en este documento. Lee el <url
  name="manual de Debmake" id="http://www.debian.org/~jaldhar/"> para
  más información.
  
  <sect id="otherinfo">Más información.

  <p>Puedes construir dos tipos de paquetes, fuentes y binarios. Un
  paquete fuente contiene el código que puede compilar en un programa.
  Un paquete binario contiene sólo el programa terminado. ¡No mezcles
  los términos como 'fuentes de un programa' y el 'paquete fuente de
  un programa'! Por favor, lee los otros manuales si necesitas más
  detalles sobre terminología.

  <p>Debian usa el término `desarrollador' para la persona que hace
  paquetes, `autor fuente' (`upstream author, n. del t.) para la
  persona que hizo el programa, y `desarrollador fuente' (`upstream
  maintainer', n. del t.) para la persona que actualmente mantiene el
  programa fuera de Debian. Generalmente el autor y el desarrollador
  fuente son la misma persona - y algunas veces incluso el
  desarrollador es el mismo. Si tú haces un programa, y quieres
  incluirlo en Debian, tienes total libertad para solicitar
  convertirte en desarrollador.

  <p>Después de construir tu paquete (o mientras lo haces), deberás
  convertirte en un desarrollador oficial de Debian si deseas que tu
  programa entre en la próxima distribución (si el programa es útil,
  ¿por qué no?). Este proceso se explica en la Referencia del
  Desarrollador, por favor, léela.

  <chapt id="first">Primeros pasos.

  <p>Mientras que la documentación en el <url name="Rincón del
  Desarrollador" id="http://www.debian.org/devel/"> no está muy clara
  sobre dónde y cómo debería empezar un nuevo desarrollador su
  trabajo, este documento te explicará cada pequeño (y algunas veces
  incluso irrelevante) detalle, para ayudarte crear ese primer
  paquete, y ganar alguna experiencia en la construcción de nuevas
  versiones de éste y quizás otros paquetes más adelante.


  <sect id="choose">Elige tu programa.

  <p>Probablemente hayas escogido ya el paquete que deseas construir,
  pero aquí hay algunos punteros para los novatos:

  <list>
  <item>comprueba si el paquete ya está en la distribución. Si usas la
  distribución `estable', quizás sea mejor que vayas a la <url
  name="página de búsqueda de paquetes"
  id="http://www.debian.org/distrib/packages.html">. Si usas la
  distribución `inestable' <strong>actualmente</strong>, comprueba
  esto con los comandos:
  <example>
  dpkg -s programa
  dpkg -l '*programa*'
  </example>

  <item>consulta la <url name="página WNPP (paquetes en Perspectiva o
  que Necesitan Ayuda)" id="http://www.debian.org/devel/wnpp/"> y los
  archivos de la lista de correo debian-devel para ver si alguna otra
  persona está construyendo ese mismo programa. Si es así, contacta
  con el desarrollador actual si crees que lo necesita mantener. Si
  no, intenta buscar otro programa interesante que nadie
  mantenga.</item>

  <item>el programa <strong>debe</strong> tener una licencia, si es
  posible, libre en el sentido marcado por las
  <url name="Directrices de Debian para el software libre"
  id="http://www.debian.org/social_contract.html#guidelines">.
  Si no sigue una de estas reglas, aún puede incluirse en las
  secciones `contrib' o `non-free' de Debian. Si no estás seguro sobre
  en qué lugar debería ir, pregunta en
  <email/debian-legal@lists.debian.org/.
  </item>

  <item>el programa <strong>no</strong> debería ejecutarse con setuid
  root, o aún mejor: no debería tener ningún programa 'setuid' ni
  'setgid'.</item>

  <item>el programa no debería ser un demonio, o algo que vaya en los
  directorios */sbin.</item>

  <item>el programa debería estar compuesto por binarios ejecutables,
  no lo intentes aún con librerías.</item>

  <item>debería tener una documentación buena, o al menos legible
  (para cualquiera).
  </item>

  <item>deberías contactar con el/los autor/es del programa para
  comprobar si están de acuerdo con que se empaquete. Esto es
  importante para consultar al/los autor/es sobre el programa en caso
  de que haya problemas específicos, así que no intentes empaquetar
  programas que no estén mantenidos.</item>

  <item>y por último pero no menos importante, deberías saber cómo
  funciona, y haberlo utilizado durante algún tiempo.</item>
  </list>

  <p>Por supuesto, esta lista es para tomar medidas de seguridad, y
  con la intención de salvarte de usuarios enfurecidos si haces algo
  mal con algún demonio setuid... Pero cuando tengas más experiencia
  en empaquetar cosas, podrás hacer este tipo de paquetes, pero
  incluso los desarrolladores más experimentados preguntan en la
  lista de distribución de debian-devel cuando tienen dudas. Y la
  gente allí te ayudará gustosamente.

  <p>Para más ayuda sobre esto, lee la Referencia del Desarrollador.

  <sect id="getit">Obtén el programa, y pruébalo.

  <p>La primera cosa a hacer es encontrar y descargar el paquete
  original. Supongo que ya tienes el código fuente que obtuviste de la
  página del autor. Las fuentes de los programas gratuitos de Linux
  generalmente vienen en formato tar/gzip, con extensión .tar.gz, y
  generalmente contienen un subdirectorio llamado programa-versión
  con todas las fuentes en él. Si tu programa viene en otro tipo de
  archivo (por ejemplo, el fichero termina en ".Z" o ".zip"),
  descomprímelo con las herramientas adecuadas, o pregunta en
  debian-mentors si no estás seguro de cómo se puede desempaquetar
  correctamente (pista: prueba `file archivo.extensión`).

  <p>Como ejemplo, usaré el programa conocido como `gentoo', un gestor
  de ficheros de X11 en GTK+. Observa que el programa ya ha sido
  empaquetado previamente pero ha cambiado sustancialmente de versión
  desde que este texto se escribió.

  <p>Crea un subdirectorio bajo tu directorio personal llamado
  'debian' o 'deb' o lo que creas apropiado (por ejemplo ~/gentoo/
  estaría bien en este caso) Y mueve a él el archivo que has
  descargado, y descomprímelo de la siguiente forma: `tar xzf
  gentoo-0.9.12.tar.gz`. Asegúrate de que no hay errores, incluso
  errores "irrelevantes", porque es muy probable que haya problemas
  desempaquetando en sistemas de otras personas, cuyas herramientas de
  desempaquetado puede que no ignoren estas anomalías.

  <p>Ahora tienes otro subdirectorio, llamado 'gentoo-0.9.12'.
  Muévete a ese directorio y lee <strong>en profundidad</strong> la
  documentación que encuentres. Está generalmente en ficheros que se
  llaman README*, INSTALL*, *.lsm o *.html. Allí encontrarás
  instrucciones de cómo compilar e instalar el programa (muy
  probablemente asumirán que lo quieres instalar en el directorio
  /usr/local/bin: no harás esto, pero eso lo veremos más adelante en
  <ref id="destdir">).

  <p>El proceso varía de programas a programas, pero gran parte de los
  programas modernos vienen con un guión 'configure' que configura
  las fuentes para tu sistema y se asegura de que tu sistema está en
  condiciones de compilarlo. Después de configurarlo (con
  `./configure`), los programas generalmente se compilan con `make`.
  Algunos de ellos soportan `make check` para ejecutarse incluyendo
  comprobaciones automáticas. Generalmente se instalarán en sus
  directorios de destino ejecutando `make install`.
  
  <p>Ahora intenta compilar, y ejecutar el programa, para asegurarte
  de que funciona bien y que no rompe nada más mientras está
  instalándose o ejecutándose.

  <P>También, generalmente, puedes escribir `make uninstall` para
  eliminar todos los programas instalados, y `make clean` (o mejor
  `make distclean`) para limpiar el directorio donde se genera el
  programa.

  <sect id="namever">Cosas antes de `dh_make'.

  <P>Deberías empezar a construir tu paquete en un directorio de
  fuentes completamente limpio, o simplemente con las fuentes recién
  desempaquetadas.

  <p>Para construir correctamente el paquete, debes poner el nombre
  original del programa en letras minúsculas (si no lo está ya), y
  deberías mover el directorio de fuentes a
  &lt;nombre_de_paquete&gt;-&lt;versión&gt;.

  <P> Si el nombre del programa son varias palabras, contráelas a una
  palabra o haz una abreviatura. Por ejemplo, el paquete del programa
  "el editor para X de Javi" se podría llamar javiedx o jle4x, o lo
  que decidas, siempre y cuando no se exceda de unos límites
  razonables, como 20 caracteres.

  <p>Comprueba también la versión exacta del programa (la que se
  incluye en la versión del paquete). Si el programa no está numerado
  con versiones del estilo de X.Y.Z, pero con fecha de lanzamiento,
  eres libre de utilizar la fecha como número de versión, precedida
  por "0.0" (sólo por si los desarrolladores originales deciden sacar
  una versión nueva como 1.0). Así, si la fecha de las fuentes es el
  19 de diciembre de 1998, puedes utilizar la abreviatura
  norteamericana 0.0.19981219 como número de versión. Aún así habrá
  algunos que ni siquiera estén numerados, en cuyo caso deberás
  contactar con el 'desarrollador fuente' para ver si tienen algún
  otro sistema de seguimiento de revisiones.

  <sect id="dh_make">Ejecutando `dh_make'.
  <p>Asegúrate que estás en el directorio donde están las fuentes del
  programa, y ejecuta lo siguiente:

  <p><example>
  dh_make -e tu.dirección@de.desarrollador -f ../gentoo-0.9.12.tar.gz
  </example>

  <p>Por supuesto, cambia la cadena
  "tu.dirección@de.desarrollador" por tu dirección de correo
  electrónico para que se incluya en la entrada del fichero de cambios
  así como en otros ficheros, y el nombre de fichero de tu archivo
  fuente original. Lee <manref name="dh_make" section="1"> para más
  detalles.

  <p>Saldrá alguna información. Te preguntará qué tipo de paquete
  deseas crear. Gentoo es un solo paquete de binarios - crea sólo un
  binario, y, por tanto, sólo un fichero .deb - así que
  seleccionaremos la primera opción, con la tecla `s'. Comprueba la
  información que aparece en la pantalla y confirma pulsando la tecla
  &lt;intro&gt;. Como nuevo desarrollador, está desaconsejado crear
  paquetes multibinarios, o librerías, como se explicó antes. No es
  extremadamente difícil, pero sí necesita algunos conocimientos más,
  así que aquí no describiremos el proceso.

  <p>Ten en cuenta que deberías ejecutar dh_make <strong>sólo una
  vez</strong>, y que no se comportará correctamente si lo haces otra
  vez en el mismo directorio, ya "debianizado". Esto también significa
  que usarás un método distinto para crear una nueva revisión o una
  nueva versión de tu paquete en el futuro. Lee más sobre esto más
  adelante en <ref id="update">.

  <chapt id="modify">Modificando las fuentes.

  <p>Normalmente, los programas se instalan a sí mismos en el
  subdirectorio /usr/local. Pero los paquetes Debian no pueden
  utilizar este directorio ya que está reservado para el uso privado
  del administrador (o de los usuarios). Esto significa que tienes que
  mirar el sistema de construcción de tu programa, generalmente
  empezando por el Makefile. Éste es el guión que <manref name="make"
  section="1"> usará para automatizar la creación de este programa.
  Para más detalles sobre Makefiles, mira en <ref id="rules">.

  <p>Date cuenta que si tu programa usa GNU <manref name="automake"
  section="1"> y/o <manref name="autoconf" section="1">, lo que quiere
  decir que las fuentes incluyen ficheros Makefile.am y Makefile.in,
  respectivamente, necesitarás modificar esos ficheros, porque cada
  invocación de automake reescribirá los Makefile.in's con información
  generada a partir de los Makefile.am's, y cada llamada a ./configure
  hará lo mismo con los Makefile's, con información de los
  Makefile.in's. Editar los ficheros Makefile.am requiere algunos
  conocimientos de automake, sobre lo que puedes leer en la entrada
  de info para automake, mientras que editar Makefile.in's es casi
  lo mismo que editar ficheros Makefile, simplemente basta con poner
  atención en las variables, es decir, cualquier cadena que empiece y
  acabe por `@'s, como por ejemplo @CFLAGS@ o @LN_S@, que se rellenan
  con cada vez que se ejecute ./configure.

  <p>Ten en cuenta que no hay espacio aquí para entrar en
  <em>todos</em> los detalles respecto a los arreglos, pero aquí hay
  algunos de los problemas frecuentes a los que se enfrenta uno.

  <sect id="destdir">Instalación en un subdirectorio.

  <p>La mayor parte de los programas tienen alguna manera de
  instalarse en la estructura de directorios existente en tu sistema,
  para que los binarios sean incluidos en tu $PATH, y para que
  encuentre la documentación y páginas de manual en los lugares
  habituales. Tienes que asegurarte que esto se realice de forma
  correcta, pero tienes que hacer que se instale en un directorio
  temporal que se creará bajo tu directorio debian/, generalmente con
  el nombre <tt>debian/tmp</tt>, desde el que las herramientas de
  desarrollo construirán un paquete .deb que se pueda instalar. Todo
  lo que se incluye en este directorio será instalado en el sistema
  del usuario cuando instale su paquete, la única diferencia es que
  dpkg instalará los ficheros en el directorio raíz.

  <p>Básicamente, debes hacer que el programa se instale en debian/tmp,
  pero se comporte correctamente cuando se instale en el directorio
  raíz, esto es, cuando se instale desde el paquete .deb. Con
  programas que utilicen la herramienta GNU autoconf, ésto será bien
  sencillo, porque dh_make pondrá las opciones necesarias para hacer
  esto automáticamente, así que podrías dejar de leer esta sección.
  Pero con otros programas, puede ser necesario que examines y edites
  los Makefiles.

  <p>Esta es la parte importante del Makefile de gentoo:

  <p><example>
  # ¿Dónde poner el binario en 'make install'?
  BIN     = /usr/local/bin
  # ¿Dónde poner los iconos en 'make install'? Nota: si cambias esto,
  # gentoo no encontrará los iconos cuando arranque. Deberás cambiar 
  # el path de iconos de gentoo (en la ventana de configuración:
  # "Paths") para que funcione.
  ICONS   = /usr/local/lib/gentoo/
  </example>


  <p>Antes de esto deberías insertar dos nuevas líneas que digan:

  <p><example>
  # Edited for Debian GNU/Linux.
  DESTDIR =
  </example>
  porque el proceso de construcción lo necesita (explicado más tarde,
  en <ref id="rules">).

  <p>Después el Makefile menciona la localización del binario final.
  Sólo necesita cambiar esto:
  <p><example>
  # ¿Dónde poner el binario en 'make install'?
  BIN     = $(DESTDIR)/usr/X11R6/bin
  </example>

  <p>¿Pero por qué en este directorio y no en otro? Porque Debian
  tiene unas reglas definidas de dónde deberían estar instalados los
  programas. Están especificadas en el Estándar de la Jerarquía del
  Sistema de Ficheros (Filesystem Hierarchy Standard, n. del t.)
  (/usr/share/doc/debian-policy/fhs). Así, deberíamos instalar el
  binario en /usr/X11R6/bin en lugar de /usr/local/bin, y la página de
  manual (no existe aquí, pero casi todos los programas tienen una,
  así que haremos una después) en /usr/share/man/man1 en lugar de
  /usr/local/man/man1.

  <p>Después de esto tendremos un situación un poco más complicada. Si
  dejas alguna línea como:

  <p><example>
  ICONS   = $(DESTDIR)/usr/share/gentoo/
  </example>
  que se ajusta a la política de Debian, deberás editar algunos
  ficheros de fuentes reales de C. Pero, ¿dónde buscar? Puedes probar
  a encontrarlos usando:
  <p><example>
  grep -n usr/local/lib *.[ch]
  </example>
  (en cada subdirectorio que contenga ficheros .c y .h). Grep dirá el
  nombre del fichero y la línea, cuando encuentra una ocurrencia.
  Ahora edita esos ficheros y cambia en esas líneas usr/local/lib con
  usr/share - y ya está. Simplemente reemplaza usr/local/lib por tu
  localización, y sé muy cuidadoso para no tocar el resto del código,
  si no sabes mucho sobre cómo programar en C. :-)

  <p>Después de esto deberías encontrar el objetivo 'install' (busca
  una línea que comience por 'install:') y renombra todas las
  referencias a directorios distintos de los definidos al comienzo del
  Makefile. Anteriormente el objetivo 'install' decía:

  <p><example>
  # ----------------------------------------- Installation

  # You're going to have to be root to do this!
  install:        gentoo
                  install ./gentoo $(BIN)
                  install icons $(ICONS)
                  install gentoorc-example $(HOME)/.gentoorc
  </example>

  <p>Después del cambio dice:
  <example>
  # ----------------------------------------- Installation

  # You're going to have to be root to do this!
  install:        gentoo-target
                  install -d $(BIN) $(ICONS) $(DESTDIR)/etc
                  install ./gentoo $(BIN)
                  install -m644 icons/* $(ICONS)
                  install -m644 gentoorc-example $(DESTDIR)/etc/gentoorc
                  install -d $(DESTDIR)/usr/share/doc/gentoo/html
                  cp -a docs/* $(DESTDIR)/usr/share/doc/gentoo/html
  </example>

  <p>Un lector atento se dará cuenta de que he cambiado `gentoo' a
  `gentoo-target' en la línea `install:'. A eso se le llama arreglar
  un fallo en el programa. :-)

  <p>Siempre que hagas cambios que no estén específicamente
  relacionados con el paquete Debian, asegúrese de que los envías al
  desarrollador original para que éste los incluya en la próxima
  revisión del programa. Observa que no tienes que enviar ninguno
  de los ficheros debian/* al desarrollador original, pero deberías
  hacerlo con cualquier otro parche. Y sé amable haciendo que tus
  cambios no sean específicos a Debian o Linux (¡ni siquiera a Unix!)
  antes de enviarlos.

  <sect id="difflibs">Librerías diferentes.

  <p>Hay un problema común: las librerías son generalmente diferentes
  de plataforma a plataforma. Por ejemplo, un Makefile puede contener
  una referencia a una librería que no exista en Debian o ni siquiera
  en Linux. En este caso, se necesita cambiarla a una librería que sí
  exista en Debian y sirva para el mismo propósito. La mejor forma es
  comentar esas líneas porque puede haber otras personas que intenten
  compilar en diferentes plataformas, y éstas les pueden dar algunas
  pistas de dónde puede estar el problema.

  <p>Así, si hay una línea en el Makefile (o Makefile.in) de tu
  programa que dice algo como lo siguiente (y tu programa no compila):

  <p><example>
  LIBS = -lcurses -lcosas -lmáscosas
  </example>

  <p>Entonces cámbiala a lo siguiente, y funcionará casi con
  seguridad:
  <p><example>
  LIBS = -lncurses -lcosas -lmáscosas
  #LIBS = -lcurses -lcosas -lmáscosas
  </example>

  <chapt id="dreq">Las cosas necesarias bajo debian/.

  <p>Ahora hay un nuevo subdirectorio bajo el directorio principal del
  programa (`gentoo-0.9.12'), que se llama `debian'. Hay bastantes
  ficheros en este directorio. Empezaremos editando éstos para adaptar
  el comportamiento del paquete. La parte más importante es modificar
  los ficheros `control', `rules' (reglas, n. del t.), `changelog', y
  `copyright' que son necesarios en todos los paquetes.

  <sect id="control">El fichero `control'.

  <p>Este fichero contiene varios valores que dpkg y dselect usarán
  para gestionar el paquete. Aquí está el fichero de control que
  dh_make crea para nosotros.

  <p><example>
  1 Source: gentoo
  2 Section: unknown
  3 Priority: optional
  4 Maintainer: Josip Rodin &lt;jrodin@jagor.srce.hr&gt;
  5 Standards-Version: 3.0.1
  6
  7 Package: gentoo
  8 Architecture: any
  9 Depends: ${shlibs:Depends}
  10 Description: &lt;insertar unos 60 caracteres de descripción&gt;
  11  &lt;inserta una descripción ligera, indentada con espacios&gt;
  </example>
  (He añadido los números de línea).

  <p>Las líneas 1-5 son la información de control para el paquete
  fuente. La línea 1 es el nombre del paquete fuente.

  <p>La línea 2 es la sección de la distribución dentro de la que
  estará este paquete. Como puedes haber notado, Debian está dividida
  en secciones: main (principal, n. del t.) (el software libre),
  non-free (no libre, n. del t.) (el software que realmente no es
  libre) y contrib (software libre que depende de software no libre).
  Bajo ellas, hay subdivisiones lógicas que describen en una palabra
  qué paquetes hay dentro. Así que tenemos `admin' para programas que
  sólo usa un administrador, `base' para las herramientas básicas,
  `devel' para las herramientas de programación, `doc' para la
  documentación, `libs' para las bibliotecas o librerías, `mail' para
  lectores y demonios de correo-e, `net' para aplicaciones y demonios
  de red, `x11' para programas específicos de X11, y muchos más.

  <p>Vamos a cambiarla para que ponga x11.

  <p>La línea 3 describe cómo de importante es para el usuario la
  instalación de este paquete. La sección y prioridad actualmente las
  usa sólo dselect cuando ordena paquetes y selecciona valores por
  defecto, y pueden ser modificadas (y generalmente lo serán) por
  nuestros administradores del FTP. Lee el manual de Política de
  Debian para una guía de qué valor deben tener estos campos.
  
  <p>Como es un paquete de prioridad normal, lo dejaremos con
  prioridad `optional' (opcional, n. del t.).

  <p>La línea 4 es el nombre y correo electrónico del desarrollador.

  <p>La línea 5 es la versión de los estándares de la Política de
  Debian que sigue este paquete (al menos, los dos primeros números de
  la versión del paquete debian-policy actual).

  <p>Si se necesita un compilador no estándar o alguna otra
  herramienta para construir el paquete, deberías añadir aquí una
  línea 'Build-Depends' y listar los paquetes necesarios. Para más
  información sobre ésto, lee el Manual de Empaquetamiento (sección
  8.7) y la documentación en el paquete 'build-essential'.

  <p>La línea 7 es el nombre del paquete binario.

  <p>La línea 8 describe la arquitectura de CPU para la que se compiló
  el paquete. Podemos dejar ésta como 'any' (cualquiera, n. del t),
  ya que <manref name="dpkg-gencontrol" section="1"> la rellenará con
  el valor apropiado cuando se compile este paquete (lea la Referencia
  del Desarrollador para una explicación de qué es portar paquetes).
  Si tu paquete es independiente de la arquitectura (por ejemplo, un
  documento, un programa de shell o un guión en Perl), cambia esto a
  "all", y lee más adelante  <ref id="rules"> sobre cómo usar la regla
  'binary-indep' en lugar de 'binary-arch' para construir el paquete.

  <p>La línea 9 muestra una de las más poderosas posibilidades del
  sistema de paquetes de Debian. Los paquetes se pueden relacionar
  unos con otros de diversas formas. Aparte de 'Depends:' (depende de,
  n. del t.) otros campos de relación son 'Recommends:' (recomienda,
  n. del t.), 'Suggests:' (sugiere, n. del t.), 'Pre-Depends:'
  (predepende de, n. del t.), 'Conflicts:' (entra en conflicto con,
  n. del t.), 'Provides:' (provee, n. del t.), 'Replaces:' (reemplaza
  a, n. del t.).

  <p>Las herramientas de gestión de paquetes como dpkg, dselect o apt
  (y sus respectivos front-ends) normalmente se comportan de la misma
  forma cuando tratan con esas relaciones entre paquetes; si no es
  así, se explicará en cada caso. (ve <manref name="dpkg"
  section="8">, <manref name="dselect" section="8">, <manref
  name="apt" section="8">, <manref name="console-apt" section="8">,
  <manref name="gnome-apt" section="8">)

  <p>Esto es lo que generalmente significan:

  <list>
  <item>Depends:
  <p>No se instalará el programa a menos que los paquetes de los que
  depende estén instalados. Usa esto si tu programa no funcionará de
  ninguna forma (o causará daños) a menos que esté instalado un
  paquete determinado.</item>

  <item>Recommends:
  <p>Dselect no te permitirá instalar el paquete a menos que los
  paquetes que recomienda estén instalados. Dpkg y apt, sin embargo,
  sí te dejarán. Usa esto para paquetes que no son estrictamente
  necesarios pero generalmente son usados con su programa.</item>

  <item>Suggests:
  <p>Cuando un usuario instale el programa, dselect le sugerirá
  instalar cualquier paquete que éste sugiera. Dpkg y apt no le hacen
  caso a esto. Utiliza esto para paquetes que funcionarán bien con tu
  programa pero no son necesarios en absoluto.</item>

  <item>Pre-Depends:
  <p>Esto es más fuerte que 'Depends'. Dpkg y dselect no instalarán el
  paquete a menos que el paquete del que pre-dependa esté instalado
  <em>y correctamente configurado</em>. Utiliza esto
  <strong>muy</strong> poco y sólo después de haberlo discutido en la
  lista de distribución de debian-devel. En resumidas cuentas: no lo
  utilices en absoluto. :-) </item>


  <item>Conflicts:
  <p>El paquete no será instalado hasta que todos los paquetes con los
  que entra en conflicto hayan sido eliminados. Utiliza esto si tu
  programa no funcionará en absoluto (o causará daños) si un paquete
  en particular está presente.
  </item>


  <item>Provides:
  <p>Para algunos tipos determinados de paquetes donde hay múltiples
  alternativas se han definido nombres virtuales. Puedes obtener la
  lista completa en el fichero
  /usr/share/doc/debian-policy/virtual-package-names-list.text.gz.
  Usa esto si tu programa ofrece las funciones de un paquete virtual
  existente.</item>

  <item>Replaces:
  <p>Use esto si tu programa reemplaza ficheros de otro paquete, o
  reemplaza totalmente otro paquete (generalmente se usa conjuntamente
  con 'Conflicts':). Se eliminarán los ficheros de los paquetes
  indicados antes de instalar el tuyo.</item>
  </list>

  <p>Todos estos campos tienen una sintaxis uniforme. Son una lista
  de nombres de paquetes separados por comas. Estos nombres de
  paquetes también puede ser listas de paquetes alternativos,
  separados por los símbolos de barra vertical <tt>|</tt> (símbolos
  tubería). Los campos pueden restringir su aplicación a versiones
  determinadas de cada paquete nombrado. Esto se hace listando después
  de cada nombre de paquete individual las versiones entre paréntesis,
  e indicando antes del número de versión una relación de la siguiente
  lista. Las relaciones permitidas son: <tt>&lt;&lt;</tt>,
  <tt>&lt;=</tt>, <tt>=</tt>, <tt>&gt;=</tt> y <tt>&gt;&gt;</tt>
  para estrictamente anterior, anterior o igual, exactamente igual,
  posterior o igual o estrictamente posterior, respectivamente.
  
  <p>La última funcionalidad que necesitas conocer es
  $(shlibs:Depends). Ésta se generará automáticamente gracias a
  <manref name="dh_shlibdeps" section="1"> y será rellenada por
  <manref name="dh_gencontrol" section="1"> con los nombres de
  cualquier librería compartida, como libc6 o xlib6g, que use tu
  programa, así que no necesitas especificar esto usted mismo.
  Habiendo dicho todo esto, puedes dejar la línea 9 exactamente como
  está ahora.

  <p>La línea 10 es donde va la lista de sugerencias. Aquí sólo
  es `file', porque gentoo utiliza algunas funciones de este
  paquete/programa.

  <p>La línea 11 es una descripción corta. La mayor parte de los
  monitores de la gente son de 80 columnas de ancho, así que no
  debería tener más de 60 caracteres. Cambiaré esto a "A fully GUI
  configurable GTK+ file manager" ("Un gestor de ficheros GTK+
  completamente configurable por GUI").

  <p>La línea 12 es donde va la descripción larga del paquete. Debería
  ser al menos un párrafo que dé más detalles del paquete. La Columna
  1 de cada línea debería estar vacía. No puede haber líneas en
  blanco, pero puede poner un . (punto) en una columna para simularlo.
  También no debe haber más de una línea en blanco después de la
  descripción completa.


  <p>Aquí está el fichero de control actualizado:

  <p><example>
  1  Source: gentoo
  2  Section: x11
  3  Priority: optional
  4  Maintainer: Josip Rodin &lt;jrodin@jagor.srce.hr&gt;
  5  Standards-Version: 3.0.1
  6
  7  Package: gentoo
  8  Architecture: any
  9  Depends: ${shlibs:Depends}
  10 Suggests: file 
  11 Description: A fully GUI configurable GTK+ file manager
  12  gentoo is a file manager for Linux written from scratch in pure C. It
  13  uses the GTK+ toolkit for all of its interface needs. gentoo provides
  14  100% GUI configurability; no need to edit config files by hand and re-
  15  start the program. gentoo supports identifying the type of various
  16  files (using extension, regular expressions, or the 'file' command),
  17  and can display files of different types with different colors and icons.
  18  .
  19  gentoo borrows some of its look and feel from the classic Amiga file
  20  manager "Directory OPUS" (written by Jonathan Potter).
  </example>
  (He añadido los números de línea).

  <sect id="copyright">El fichero `copyright'.

  <p>Este fichero contiene la información sobre la licencia y copyright
  de las fuentes originales del paquete. El formato no está definido en
  la Política, pero sí sus contenidos (sección 6.5). dh_make crea un
  fichero por defecto que es así:

  <p><example>
  1  This package was debianized by Josip Rodin &lt;jrodin@jagor.srce.hr&gt; on
  2  Wed, 11 Nov 1998 21:02:14 +0100.
  3
  4  It was downloaded from &lt;fill in ftp site&gt;
  5
  6  Upstream Author(s): &lt;put author(s) name and email here&gt;
  7
  8  Copyright:
  9
  10 &lt;Must follow here&gt;
  </example>
  (He añadido los números de línea).

  <p>Las cosas importantes que se deben añadir a este fichero son el
  lugar de donde obtuviste el paquete y la nota de copyright y
  licencia originales. Debes incluir la licencia completa, a menos que
  sea una licencia común en el mundo del software libre como GNU GPL o
  LGPL, BSD o la 'Artistic license', donde basta referirse al fichero
  apropiado en el directorio /usr/share/common-licenses/ que existe en
  todo sistema Debian. Gentoo está gobernado bajo la Licencia Pública
  General GNU, así que cambiaremos el fichero a esto:

  <p><example>
  1  This package was debianized by Josip Rodin &lt;jrodin@jagor.srce.hr&gt; on
  2  Wed, 11 Nov 1998 21:02:14 +0100.
  3
  4  It was downloaded from: ftp://ftp.obsession.se/gentoo/
  5
  6  Upstream author: Emil Brink &lt;emil@obsession.se&gt;
  7
  8  This software is copyright (c) 1998-99 by Emil Brink, Obsession
  9  Development.
  10
  11 You are free to distribute this software under the terms of
  12 the GNU General Public License.
  13 On Debian systems, the complete text of the GNU General Public
  14 License can be found in /usr/share/common-licenses/GPL file.
  </example>
  (He añadido los números de línea).

  <p>(Nota del T.: la política de Debian actual indica que los
  documentos aquí citados estén escritos en inglés, al ser el idioma
  oficial del proyecto, por lo que no se traducen en este documento).

  <sect id="changelog">El fichero `changelog'.

  <p>Este es un fichero requerido, que tiene un formato especial
  descrito en el Manual de Empaquetamiento (sección 3.2.3). Este es el
  formato que usan dpkg y otros programas para obtener el número de
  versión, revisión, distribución y urgencia de tu paquete.

  <p>Para ti es también importante, ya que es bueno tener documentados
  todos los cambios que hayas hecho. Le ayudará a las personas que se
  descarguen tu paquete para ver si hay temas pendientes en el paquete
  que deberían conocer de forma inmediata. Se salvará como
  `/usr/share/doc/gentoo/changelog.Debian.gz' en el paquete binario.

  <p>dh_make crea uno por defecto, que es algo así:

  <p><example>
  1  gentoo (0.9.12-1) unstable; urgency=low
  2
  3   * Initial Release.
  4
  5  -- Josip Rodin &lt;jrodin@jagor.srce.hr&gt; Wed, 11 Nov 1998 21:02:14 +0100
  6
  7  Local variables:
  8  mode: debian-changelog
  9  End:
  </example>
  (He añadido los números de línea).
  
  <p>La línea 1 es el nombre del paquete, versión, distribución y
  urgencia. El nombre debe coincidir con el nombre del paquete fuente,
  la distribución debería ser, por ahora, `unstable' o `experimental',
  y la urgencia no debería cambiarse a algo mayor que `low'. :-)
  
  <p>Las línea 3-5 son una entrada de registro, donde se documentan
  los cambios hechos en esta revisión del paquete (no los cambios en
  las fuentes originales - hay un fichero especial para este
  propósito, creado por los autores originales e instalado como
  /usr/share/doc/gentoo/changelog.gz). Las nuevas líneas deben
  insertarse justo antes de la línea que hay más arriba que comienza
  por un asterisco (`*'). Puede hacerlo con <manref name="dch"
  section="1">, <manref name="emacs" section="1"> (las líneas 7 a la
  9 contienen información de modo para el editor Emacs), o cualquier
  otro editor de texto. Terminará con algo así:
  
  <p><example>
  1  gentoo (0.9.12-1) unstable; urgency=low
  2
  3   * Initial Release.
  4   * This is my first Debian package.
  5   * Adjusted the Makefile to fix $DESTDIR problems.
  6
  7  -- Josip Rodin &lt;jrodin@jagor.srce.hr&gt; Wed, 11 Nov 1998 21:02:14 +0100
  8
  9  Local variables:
  10  mode: debian-changelog
  11 End:
  </example>
  (He añadido los números de línea).

  <p>Cuando distribuya una nueva revisión, sólo debe incrementar el
  número de versión. Puede hacer esto sólo con `dch -i` o
  explícitamente con `dch -v &lt;versión&gt;-&lt;revisión&gt;` y
  después insertar los comentarios usando su editor preferido. Pista:
  ¿cómo obtener rápidamente la fecha en el formato necesario? Use
  `822-date`, o `date -R`.

  <p>La nueva información sobre la versión se añade al principio del
  fichero de cambios. Esto es como el fichero de cambios quedará
  después:

  <p><example>
  1  gentoo (0.9.12-2) unstable; urgency=low
  2
  3   * Fixed a glitch in the menu file.
  4
  5  -- Josip Rodin &lt;jrodin@jagor.srce.hr&gt; Wed, 11 Nov 1998 22:15:39 +0100
  6
  7  gentoo (0.9.12-1) unstable; urgency=low
  8
  9   * Initial Release.
  10  * This is my first Debian package.
  11  * Adjusted the Makefile to fix $DESTDIR problems.
  12
  13 -- Josip Rodin &lt;jrodin@jagor.srce.hr&gt; Wed, 11 Nov 1998 21:02:14 +0100
  14
  15 Local variables:
  16 mode: debian-changelog
  17 End:
  </example>
  (He añadido los números de línea).

  <p>Puede leer más sobre nuevas versiones/revisiones de paquetes más
  adelante en <ref id="update">.

  <sect id="rules">El fichero `rules'.

  <p>Ahora necesitamos mirar las reglas exactas que <manref
  name="dpkg-buildpackage" section="1"> utilizará para crear el
  paquete. Este fichero es en realidad otro Makefile, ya que se
  ejecuta con `make -f', pero diferente al que viene en las fuentes
  originales.

  <p>Cada fichero `rules' (de reglas, n. del t.), como muchos otros
  Makefiles, se compone de varias reglas que especifican cómo tratar
  las fuentes. Cada regla se compone de objetivos, ficheros o nombres
  de acciones que se deben llevar a cabo (por ejemplo, `build:' o
  `install:'). Las reglas que quieras ejecutar deberían llamarse como
  argumentos de la línea de órdenes (por ejemplo, `./debian/rules
  build' o `make -f rules install'). Después del nombre del objetivo,
  puedes nombrar las dependencias, programas o ficheros de los que la
  regla dependa. Después de esto, hay un número cualquiera de
  instrucciones (¡indentado con &lt;tab&gt;!), hasta que se llega a
  una línea en blanco. Ahí empieza otra regla. Las líneas múltiples en
  blanco, y las líneas que empiezan por almohadillas ('#') se tratan
  como comentarios y se ignoran.

  <p>Probablemente ya te hayas perdido, pero todo quedará más claro
  después de ver un fichero `rules' que dh_make pone por defecto.
  Deberías también leer la entrada de `make' en info para más
  información.

  <p>La parte importante que debes conocer sobre el fichero de reglas
  creado por dh_make, es que sólo es una sugerencia. Funcionará para
  paquetes simples pero para más complicados, no te asustes y añade o
  quita cosas de éste para ajustarlo a tus necesidades. Una cosa que
  no debes cambiar son los nombres de las reglas, porque todas las
  herramientas utilizan estos nombres, como se indica en el Manual de
  Empaquetamiento.

  <p><example>
  1  #!/usr/bin/make -f
  2  # Made with the aid of dh_make, by Craig Small
  3  # Sample debian/rules that uses debhelper. GNU copyright 1997 by Joey Hess.
  4  # Some lines taken from debmake, by Christoph Lameter.
  5
  6  # Uncomment this to turn on verbose mode.
  7  #export DH_VERBOSE=1
  8
  9  # This is the debhelper compatability version to use.
  10 export DH_COMPAT=1
  11 build: build-stamp
  12 build-stamp:
  13	dh_testdir
  14
  15	
  16	# Add here commands to compile the package.
  17	$(MAKE)
  18
  19	touch build-stamp
  20
  21 clean:
  22	dh_testdir
  23	dh_testroot
  24	rm -f build-stamp 
  25
  26	# Add here commands to clean up after the build process.
  27	-$(MAKE) clean
  28
  29	dh_clean
  30
  31 install-stamp: build-stamp
  32	dh_testdir
  33	dh_testroot
  34	dh_clean -k
  35	dh_installdirs
  36
  37	# Add here commands to install the package into debian/tmp.
  38	$(MAKE) install DESTDIR=`pwd`/debian/tmp
  39
  40 # Build architecture-independent files here.
  41 binary-indep: build install
  42 # We have nothing to do by default.
  43
  44 # Build architecture-dependent files here.
  45 binary-arch: build install
  46 #	dh_testversion
  47	dh_testdir
  48	dh_testroot
  49 #  dh_installdebconf
  50	dh_installdocs
  51	dh_installexamples
  52	dh_installmenu
  53 #	dh_installemacsen
  54 #	dh_installpam
  55 #	dh_installinit
  56	dh_installcron
  57	dh_installmanpages
  58	dh_installinfo
  59 #	dh_undocumented
  60	dh_installchangelogs
  61	dh_link
  62	dh_strip
  63	dh_compress
  64	dh_fixperms
  65	# You may want to make some executables suid here.
  66	dh_suidregister
  67 #	dh_makeshlibs
  68	dh_installdeb
  69 #	dh_perl
  70	dh_shlibdeps
  71	dh_gencontrol
  72	dh_md5sums
  73	dh_builddeb
  74
  75 binary: binary-indep binary-arch
  76 .PHONY: build clean binary-indep binary-arch binary install
  </example>
  (He añadido los números de línea).

  <p>(N. del T.: se traduce el fichero de reglas, dh_make sólo lo
  ofrece en inglés)

  <p><example>
  1  #!/usr/bin/make -f
  2  # Creado con la ayuda de dh_make, por Craig Small 
  3  # Fichero de ejemplo debian/rules que usa debhelper. Copyright GNU 1997 por Joey Hess.
  4  # Algunas líneas son de debmake, por Christoph Lameter.
  5
  6  # Quítele el comentario para activar el modo explícito.
  7  #export DH_VERBOSE=1
  8
  9  # Esta es la versión de compatibilidad con debhelper que usaremos.
  10 export DH_COMPAT=1
  11 build: build-stamp
  12 build-stamp:
  13	dh_testdir
  14
  15	
  16	# Añada aquí los comandos para compilar el paquete.
  17	$(MAKE)
  18
  19	touch build-stamp
  20
  21 clean:
  22	dh_testdir
  23	dh_testroot
  24	rm -f build-stamp 
  25
  26	# Añada aquí los comandos para limpiar después del proceso de creación.
  27	-$(MAKE) clean
  28
  29	dh_clean
  30
  31 install-stamp: build-stamp
  32	dh_testdir
  33	dh_testroot
  34	dh_clean -k
  35	dh_installdirs
  36
  37	# Añada aquí los comandos para instalar el paquete en debian/tmp.
  38	$(MAKE) install DESTDIR=`pwd`/debian/tmp
  39
  40 # Construir los ficheros independientes de arquitectura aquí.
  41 binary-indep: build install
  42 # Por defecto no se hace nada.
  43
  44 # Construir los ficheros dependientes de arquitectura aquí.
  45 binary-arch: build install
  46 #	dh_testversion
  47	dh_testdir
  48	dh_testroot
  49 #  dh_installdebconf
  50	dh_installdocs
  51	dh_installexamples
  52	dh_installmenu
  53 #	dh_installemacsen
  54 #	dh_installpam
  55 #	dh_installinit
  56	dh_installcron
  57	dh_installmanpages
  58	dh_installinfo
  59 #	dh_undocumented
  60	dh_installchangelogs
  61	dh_link
  62	dh_strip
  63	dh_compress
  64	dh_fixperms
  65	# Puede hacer algunos ejecutables suid aquí.
  66	dh_suidregister
  67 #	dh_makeshlibs
  68	dh_installdeb
  69 #	dh_perl
  70	dh_shlibdeps
  71	dh_gencontrol
  72	dh_md5sums
  73	dh_builddeb
  74
  75 binary: binary-indep binary-arch
  76 .PHONY: build clean binary-indep binary-arch binary install
  </example>

  <p>Probablemente estés familiarizado con líneas como la 1 de guiones
  hechos en shell o Perl. Esto significa que el fichero debe
  ejecutarse con /usr/bin/make. 
  
  <p>Las líneas 12 a la 19 describen la regla `build' (construcción,
  n. del t.), que ejecuta el Makefile del propio programa para
  compilarlo.

  <p>La regla `clean' (limpiar, n. del t.), como se especifica en las
  líneas 21-29, limpia cualquier binario innecesario o cosas
  automáticamente generadas, dejadas después de la construcción del
  paquete. Esta regla debe funcionar en todo momento (incluso cuando
  el árbol de fuentes <em>esté</em> limpio!), así que, por favor, usa
  las opciones que fuercen a hacer cosas (por ejemplo para rm, sería
  `-f'), o ignora los valores devueltos (con un `-' al principio de la
  orden).

  <p>El proceso de instalación, la regla `install', comienza en la
  línea 31. Básicamente ejecuta la regla `install' del Makefile del
  programa, pero lo instala en el directorio `pwd`/debian/tmp -
  esto es por lo que especificamos $(DESTDIR) como el directorio
  raíz de instalación del Makefile de gentoo.

  <p>Como sugiere el comentario, la regla 'binary-indep', en la línea
  41, se usa para construir paquetes independientes de arquitectura.
  Como no tenemos ninguno aquí no se hará nada. Si tu paquete es del
  tipo `Architecture: all' necesitarás incluir todas las órdenes para
  crear el paquete bajo esta regla, y dejar la siguiente regla
  (`binary-arch') vacía en su lugar.

  <p>Lo siguiente es la regla 'binary-arch', en las líneas 45 a 73, en
  la que ejecutamos varias pequeñas utilidades del paquete debhelper
  que nos permiten hacer diversas operaciones en nuestro paquete para
  que cumpla la política de Debian.
  
  <p>Los nombres comienzan con dh_ y el resto es la descripción de lo
  que la utilidad en particular realmente hace. Es todo más o menos
  auto-explicativo, pero a continuación se indica lo que realmente
  hace cada pequeña utilidad:

  <list>
  <item><manref name="dh_testdir" section="1"> comprueba que estás en
        el directorio correcto (esto es, el directorio raíz de la
        distribución de las fuentes),
  <item><manref name="dh_testroot" section="1"> comprueba que tienes
        permisos de superusuario que son necesarios para las reglas
        binary* y clean,
  <item><manref name="dh_installmanpages" section="1"> copia todas las
        páginas de manual que puede encontrar en el paquete fuente en
        el paquete (cuidado, esto hace lo dice: *todas* las páginas),
<!-- ¿qué es DWIM? jfs -->
<!-- Do What I Mean. Quiere decir que buscará TODAS las páginas de
manual que encuentre en el árbol original. ender -->
  <item><manref name="dh_strip" section="1"> elimina las cabeceras de
        depuración de los ficheros ejecutables para hacerlos más
        pequeños,
  <item><manref name="dh_compress" section="1"> comprime con gzip las
        páginas de manual y los ficheros de documentación que sean más
        grandes de 4 kB,
  <item><manref name="dh_installdeb" section="1"> copia los ficheros
        relativos al paquete (es decir, los guiones del mantenedor)
	bajo el directorio debian/tmp/DEBIAN,
  <item><manref name="dh_shlibdeps" section="1"> calcula las
        dependencias de los ejecutables y librerías con las librerías
        compartidas,
  <item><manref name="dh_gencontrol" section="1"> genera e instala el
        fichero de control,
  <item><manref name="dh_md5sums" section="1"> genera las sumas de
        chequeo MD5 para todos los ficheros del paquete.
  </list>

  <p>Para información más completa de lo que hacen cada uno de estos
  guiones dh_* , y qué otras opciones tienen, por favor lee sus
  páginas de manual respectivas. Hay otros guiones con la misma
  nomenclatura (dh_*) que no se han mencionado aquí, pero pueden serte 
  útiles. Si los necesitas, lee la documentación de debhelper.

  <p>Las líneas 70 a la 74 son sólo algunas necesidades sobre las que
  puede leer en el manual de make. Por ahora, no es importante
  conocerlas.

  <p>La sección binary-arch es donde deberías comentar las
  líneas que llamen a funciones que no necesites. En este caso he
  comentado las líneas sobre testversion, emacsen, pam, init, cron,
  manpages, info, undocumented, suidregister, makeshlibs, y perl, 
  simplemente porque gentoo no las necesita. Sólo he añadido en la
  línea 60, `FIXES', porque este es el nombre del fichero de cambios
  de las fuentes.

  <p>Las últimas dos líneas (junto con otras que no se explican) son
  cosas más o menos necesarias, sobre las que puedes leer en el manual
  de make, y en el Manual de Empaquetamiento. Por ahora no necesitas
  saberlas.

  <chapt id="dother">Otros ficheros en el directorio debian/.

  <p>Verás que existen otros ficheros en el subdirectorio debian/,
  muchas de los cuales tendrán el sufijo `.ex', que indica que son
  ejemplos. Si quieres o deseas usar cualquiera de éstos, lee la
  información relativa (pista: Manual de Política), renómbralo para
  eliminar el sufijo `.ex' , y modifícalo junto con el fichero de
  reglas si fuera necesario. Algunos de estos ficheros, los más
  usados, se explican en las siguientes secciones.

  <sect id="readme">README.debian. (LÉEME.debian, n. del t.)

  <p>Cualquier detalle extra o discrepancias entre el programa
  original y su versión debianizada debería documentarse aquí. dh_make
  crea una por defecto, y éste es su aspecto:

  <example>
  gentoo for DEBIAN
  ----------------------

  &lt;possible notes regarding this package - if none, delete this file&gt;

  Josip Rodin &lt;jrodin@jagor.srce.hr&gt;, Wed, 11 Nov 1998 21:02:14 +0100
  </example>

  <p>Dado que no tenemos que poner nada aquí - está permitido
  borrarlo.


  <sect id="conffiles">conffiles.

  <p>Una de las cosas más molestas de los programas es cuando pasas
  mucho tiempo y esfuerzo adaptando un programa y una actualización
  destroza todos tus cambios. Debian resuelve este problema marcando
  los ficheros de configuración de forma que cuando actualizas un
  paquete no se te pregunta si deseas mantener la nueva
  configuración o no. Se consigue poniendo la ruta completa a cada
  fichero de configuración (se encuentran generalmente en /etc), una
  por línea, en un fichero llamado `conffiles'.


  <p>Gentoo tiene un fichero de configuración, /etc/gentoorc, y
  meteremos éste en el fichero 'conffiles'. No es necesario tener este
  último fichero si tu programa no tiene ningún fichero de
  configuración.

  <sect id="dirs">dirs.

  <p>Este fichero especifica los directorios que se necesitan pero que
  por alguna razón no se crean en un proceso de instalación normal
  (make install).

  Por defecto, tiene este aspecto:
  <p><example>
  1 usr/bin
  2 usr/sbin
  </example>

  <p>Observa que la barra precedente no está incluida. Normalmente lo
  cambiaríamos para gentools a algo así:
  <p><example>
  1 usr/X11R6/bin
  2 usr/X11R6/man/man1
  </example>

  pero estos directorios ya se crean en el Makefile, así que no
  necesitaremos este fichero y lo podremos borrar.
  <sect id="manpage">manpage.1.ex.

  <p>Los ficheros que terminan en *.ex son ejemplos de cómo añadir ese
  tipo de soporte en el paquete. Si usas uno de ellos, edítalo y
  elimina la extensión .ex. Si no lo quieres usar, simplemente
  bórralo.

  <p>Tu programa debería tener una página de manual. Si no la tiene,
  este es un esqueleto que puedes rellenar. Lee las páginas de manual
  para <manref name="man" section="7"> para una breve descripción de
  cómo crear una página de manual. Asegúrate de renombrar este fichero
  al nombre del programa y modificar la extensión para indicar la
  sección en la que debería ir. Aquí hay una corta lista:


  <p><example>
  Sección |     Descripción        |     Notas
     1     Comandos de Usuario       Programas o guiones ejecutables.
     2     Llamadas al Sistema       Funciones que ofrece el núcleo.
     3     Llamadas a Librerías      Funciones dadas por las librerías del sistema.
     4     Ficheros Especiales       Generalmente se encuentran en /dev.
     5     Formatos de Fichero       Por ejemplo, el formato del /etc/passwd.
     6     Juegos                    U otros programas frívolos.
     7     Paquetes de Macros        Como las macros de man.
     8     Administración del Sist.  Programas que sólo suele ejecutar el superusuario.
     9     Rutinas del Núcleo        Llamadas al sistema no estándar.
  </example>
  
  <p>Así que la página de manual de gentoo debería llamarse gentoo.1,
  o gentoo.1x porque es un programa de X11. Como no había página de
  manual en las fuentes originales la escribí a partir del ejemplo.

  <sect id="menu">menu.ex.

  <p>Los usuarios de X Windows tendrán un gestor de ventanas con menús
  que pueden adaptarse para lanzar programas. Si tienen instalado el
  paquete "menu" de Debian, se creará un conjunto de menús para cada
  programa del sistema para ellos. No se exige en la política de
  Debian, pero los usuarios seguramente lo apreciarán. Podemos añadir
  Gentoo a los menús editando este fichero. Aquí está el fichero que
  dh_make crea por defecto:
  
  <p><example>
  ?package(gentoo):needs=X11|text|vc|wm section=Apps/see-menu-manual\
    title="gentoo" command="/usr/bin/gentoo"
  </example>

  <p>El primer campo especifica qué tipo de interfaz necesita el
  programa (esto es, texto o X11). La siguiente es el menú y submenú
  dónde debería aparecer. La lista actual de secciones está en 
 /usr/share/doc/debian-policy/menu-policy.html/ch2.html#s2.1
  El tercero es el nombre del programa. El cuarto es el icono para el
  programa o "none" si no hay ninguno. El quinto es el texto que
  aparecerá en el menu. Finalmente, el sexto es la orden que ejecuta 
  el programa.

  <p>Ahora cambiaremos la entrada de menú a ésta:
  <p><example>
  ?package(gentoo):needs=X11 section=Apps/Misc \
    title="gentoo" command="/usr/X11R6/bin/gentoo"
  </example>

  <P>Revisa <manref name="menufile" section="5">, <manref
  name="update-menus" section="1"> y
  /usr/share/doc/debian-policy/menu-policy.html/ para más información.

  <sect id="watch">watch.ex.

  <p>Puedes usar este fichero, junto con los programas <manref
  name="uscan" section="1"> y <manref name="uupdate" section="1"> (en
  el paquete devscripts) para vigilar el servidor de donde obtuviste
  las fuentes originales.

  <p>Esto es lo que he puesto yo:

  <p><example>
  # watch control file for uscan
  # Site		Directory	Pattern			Version	Script
  ftp.obsession.se	/gentoo		gentoo-(.*)\.tar\.gz	debian	uupdate
  </example>

  <p>Pista: conéctate a Internet, e intenta ejecutar el programa
  "uscan" en el directorio donde has creado el fichero. Ve la página
  de manual para más detalles.

  <sect id="doc-base">ex.doc-base

  <p>Si tu paquete tiene documentación en HTML o de otro tipo (excepto
  páginas de manual y documentos info), deberías usar el fichero
  `doc-base' para registrarlo, para que el usuario pueda encontrarlo
  con, por ejemplo, <manref name="dhelp" section="1"> o <manref
  name="dwww" section="1">.

  <p>Este es el aspecto del fichero doc-base:
  <p><example>
  Document: gentoo
  Title: Gentoo Manual
  Author: Emil Brink
  Abstract: This manual describes what Gentoo is, and how it can be used.
  Section: Apps/Tools

  Format: HTML
  Index: /usr/share/doc/gentoo/html/index.html
  Files: /usr/share/doc/gentoo/html/*.html
  </example>

  <p>Para información sobre el formato del fichero, revisa <manref
  name="install-docs" section="8"> y el manual de doc-base en
  /usr/share/doc/doc-base/doc-base.html/index.html.


  <sect id="maintscripts">postinst.ex, preinst.ex, postrm.ex y prerm.ex.

  <p>Estos ficheros se llaman guiones del desarrollador (maintainer
  scripts, n. del t.), y son guiones que se colocan en el área de
  control del paquete y que dpkg ejecuta cuando tu paquete se instala,
  se actualiza o se quita.

  <p>Por ahora, deberías intentar evitar editar manualmente estos
  guiones si puedes porque suelen hacerse muy complejos. Para más
  información lee el Manual de Empaquetamiento (sección 6) y echa un
  vistazo a los ejemplos dados por dh_make.

  <p>Ahora estamos preparados para construir el paquete.

  <chapt id="final">Pasos Finales

  <sect id="build">Construir el paquete.

  <p>Entra en el directorio principal del programa y ejecuta el
  siguiente comando:

  <p><example>
  dpkg-buildpackage -rfakeroot
  </example>

  <p>Esto hará todo por ti, sólo tendrás que dar tu clave secreta PGP
  dos veces. Una vez hayas hecho esto, verás cuatro nuevos ficheros
  en el directorio anterior (~/debian/):

  <p><list>
  <item><em>gentoo_0.9.12-1_i386.deb</em>
  <p>Este es el paquete binario completo. Puedes usar dpkg o dselect
  para instalar o eliminar tanto este como cualquier otro paquete.

  <item><em>gentoo_0.9.12.orig.tar.gz</em>
  <p>Este es el código fuente original empaquetado de forma que si
  alguien quiere recrear su paquete desde cero puede hacerlo. O si
  no está usando el sistema de paquetes de Debian, pero necesita
  descargarse las fuentes y compilarlo manualmente.

  <item><em>gentoo_0.9.12-1.dsc</em>
  <p>Este es un sumario de los contenidos del código fuente. Este
  fichero se genera a partir del fichero gentoo-0.9.12/debian/control
  y se usa cuando se descomprimen las fuentes con <manref
  name="dpkg-source" section="1">. Este fichero está firmado con PGP
  de forma que cualquiera puede estar seguro de que es realmente suyo.

  <item><em>gentoo_0.9.12-1.diff.gz</em>
  <p>Este fichero comprimido contiene todos y cada uno de los cambios
  que hizo al código fuente original, en un formato conocido como "diff
  unificado". El que lo hace y lo usa es <manref name="dpkg-source"
  section="1">.

  <item><em>gentoo_0.9.12-1_i386.changes</em>
  <p>Este fichero describe todos los cambios hechos en la revisión
  actual del paquete, y se usa por los programas de gestión del
  archivo FTP para instalar los paquetes binarios y fuentes en él. Se
  genera parcialmente a partir del fichero
  gentoo-0.9.12/debian/changelog y el fichero .dsc.

  <p>Mientras sigues trabajando en el paquete, cambiará su
  comportamiento y se le añadirán nuevas funciones. Las personas que
  descarguen tu paquete pueden mirar este fichero y ver qué ha
  cambiado. Las largas listas de números son las sumas MD5 para los
  ficheros. Las personas que descarguen estos ficheros pueden
  comprobarlos con <manref name="md5sum" section="1"> y si los números
  no coinciden, sabrán que el fichero está corrupto o ha sido
  modificado. Este fichero está firmado con PGP de forma que
  cualquiera puede estar aún más seguro de que es realmente tuyo.
  </list>

  <p>Con un paquete grande, puede que no quieras recompilar desde cero
  cada vez que tocas un detalle en el fichero debian/rules. Para
  propósitos de prueba, puedes hacer un fichero .deb sin necesidad de
  recompilar las fuentes originales de esta forma:

  <p><example>
  fakeroot debian/rules binary
  </example>

  <p>Sólo asegúrate de que tu regla `install' <strong/no/ tiene un
  hijo `install-stamp' (éste es el valor por defecto actualmente),
  para asegurarse de que se ejecuta `dh_clean -k' cada vez. Y una vez
  que hayas terminado con los cambios, no te olvides de reconstruir el
  paquete siguiendo el procedimiento habitual, para poder enviarlo de
  la forma correcta.
  
  <sect id="checkit">Comprobar tu paquete para encontrar errores.

  <p>Ejecuta <manref name="lintian" section="1"> sobre tu fichero de
  cambios .changes; este programa comprobará muchos errores comunes al
  empaquetar. El comando es:
  
  <p><example>
  lintian -i gentoo_0.9.12-1_i386.changes
  </example>
  
  <p>Por supuesto, cambia el nombre de fichero con el nombre del
  fichero de cambios generado por tu paquete. Si parece que hay
  algunos errores (líneas que comienzan por E:), lee la explicación
  (líneas N:), corrige errores, y reconstruye como se describe en <ref
  id="build">. Si hay líneas que comienzan con W:, son sólo avisos
  (warnings, n. del t.), así que puedes estar seguro de que tu
  paquete está bien (pero seguramente necesita algún ajuste fino).

  <p>Observa que puedes construir el paquete con dpkg-buildpackage y
  ejecutar lintian todo de una sola vez con <manref name="debuild"
  section="1">.

  <p>Mira dentro del paquete usando un gestor de ficheros como <manref
  name="mc" section="1">, o descomprímelo en algún punto temporal
  usando <manref name="dpkg-deb" section="1">. Estáte atento a
  ficheros innecesarios extra y algunas otras cosas que no se
  limpiaron. Pista: `zgrep ^+++ ../gentoo_0.9.12-1.diff.gz` te dará
  una lista de tus cambios/contribuciones a las fuentes, y `dpkg-deb
  -c gentoo_0.9.12-1_i386.deb` listará los ficheros en el paquete.

  <p>Instala el paquete para probarlo tú mismo, p. ej. usando la
  orden <manref name="debi" section="1"> como superusuario. Intenta
  instalarlo y ejecutarlo en otras máquinas distintas de la tuya y
  estáte atento para detectar errores o avisos tanto en la instalación
  como en la ejecución del programa.

  <p>Más tarde, cuando construyas una nueva versión, deberías hacer lo
  siguiente para asegurar la actualización básica del paquete:

  <list>
  <item>actualízate a partir de la versión previa (y de la versión en
  la última versión de Debian),
  <item>vuelve a la versión anterior de nuevo,
  <item>instala el paquete como uno nuevo (esto es, sin ninguna
  versión instalada previamente),
  <item>desinstálalo, reinstálalo y luego púrgalo.
  </list>

  <sect id="upload">Enviando el paquete.

  <p>Ahora que has probado tu nuevo paquete en profundidad,
  necesitarás enviar estos ficheros a master.debian.org, usando
  <manref name="dupload" section="1">. Primero debes editar el fichero
  de configuración de dupload, ~/.dupload.conf. Puedes poner algo así:

  <p><example>
  package config;
  $default_host = "master";
  
  $cfg{"master"}{"method"} = "scpb";
  $cfg{"master"}{"login"} = "joy";
  $cfg{"master"}{"visibleuser"} = "jrodin";
  $cfg{"master"}{"visiblename"} = "jagor.srce.hr";
  $cfg{"master"}{"fullname"} = "Josip Rodin";
  
  $cfg{"non-us"}{"method"} = "scpb";
  $cfg{"non-us"}{"login"} = "joy";
  $cfg{"non-us"}{"visibleuser"} = "jrodin";
  $cfg{"non-us"}{"visiblename"} = "jagor.srce.hr";
  $cfg{"non-us"}{"fullname"} = "Josip Rodin";
  
  1;
  </example>

  <p>Por supuesto, cambia mis valores personales a los tuyos, y lee
  la página de manual <manref name="dupload.conf" section="5"> para
  comprender qué significa cada una de estas opciones.

  <p>Entonces conecta con tu proveedor de Internet, y ejecuta la
  orden:
  
  <p><example>
  dupload --to master gentoo_0.9.12-1_i386.changes
  </example>

  <p>Dupload comprueba que las sumas md5 coinciden con aquellas en el
  fichero .changes, y te avisará de rehacer el paquete como se
  describe en <ref id="build"> para poder enviarlo correctamente.

  <p>Dupload te preguntará tu contraseña en master.debian.org, enviará
  tus paquetes, y hará un pequeño anuncio sobre su envío en 
  <email/debian-devel-changes@lists.debian.org/ si es necesario.

  <p>Si vives en Europa, puedes usar otras colas de envío en lugar de
  master. Para más detalles lea <manref name="dupload" section="1">,
  <manref name="dupload" section="5"> y la Referencia del
  Desarrollador.

  <sect id="update">Actualizar tu paquete.

  <p>Supongamos que se ha creado un informe de un fallo en tu paquete,
  de número #54321, y que describe un problema que puedes solucionar.
  Para crear una nueva revisión del paquete, necesitas:

  <list>
  <item>Corregir, por supuesto, el problema en las fuentes del
  paquete.

  <item>Añadir una nueva revisión en el fichero de cambios (changelog,
  n. del t.) de Debian, con `dch -i`, e incluir una breve descripción
  del error y su solución, seguido por: "Closes: #54321". De esta
  forma, el informe del error será automágicamente cerrado por los
  programas de gestión del archivo en el momento en que tu paquete se
  acepte en el archivo de Debian.

  <item>Repite lo que hiciste en <ref id="build">, <ref id="checkit">,
  y <ref id="upload">. La diferencia es que esta vez, las fuentes
  originales del archivo no se incluirán, dado que no han cambiado y
  ya existen en el archivo de Debian.
  </list>

  <p>Ahora consideremos una situación diferente, algo más complicada:
  ha salido una versión nueva de las fuentes originales, y, por
  supuesto, deseas empaquetarla. Debes hacer lo siguiente:

  <list>
  <item>Descarga las nuevas fuentes y pon el archivo tar (pongamos que
  se llama `gentoo-0.9.13.tar.gz') un directorio por encima del
  antiguo árbol de fuentes (por ejemplo ~/debian/).

  <item>Entra en el antiguo directorio y ejecuta:

  <example>
  uupdate -u gentoo-0.9.13.tar.gz
  </example>

  Por supuesto, reemplaza este nombre de fichero con el nombre de las
  fuentes de tu programa. <manref name="uupdate" section="1">
  renombrará apropiadamente este fichero tar, intentará aplicar los
  cambios de tu fichero .diff.gz previo y actualizará el nuevo fichero
  debian/changelog.

  <item>Cambia al directorio `../gentoo-0.9.13', el nuevo directorio
  fuente del paquete, y repite la operación que hiciste en <ref
  id="build">, <ref id="checkit">, y <ref id="upload">.
  </list>

  <p>Observa que si has puesto el fichero `debian/watch' como se
  describe en <ref id="watch">, puedes ejecutar <manref name="uscan"
  section="1"> para buscar automágicamente fuentes revisadas,
  descargarlas, y ejecutar uupdate.

  <sect id="whereishelp">Dónde pedir ayuda.

  <p>Antes de que te decidas a preguntar en lugares públicos, por
  favor, simplemente RTFM ("Lee El Jodido Manual", n. del t.). Esto
  incluye la documentación en /usr/share/doc/dpkg,
  /usr/share/doc/debian, /usr/share/doc/package/* y las páginas de
  man/info para todos los programas mencionados en este artículo.
  Cuando recibas un aviso de fallo (bug report, n. del t.) (sí,
  avisos de fallos ¡de verdad!) sabrás que es el momento de indagar en
  el <url name="Sistema de Seguimiento de Fallos de Debian"
  id="http://www.debian.org/Bugs/"> y leer la documentación de allí,
  para poder tratar los informes de forma eficiente.

  <p>Si te unes a la lista de distribución de Mentores de Debian en
  <email/debian-mentors@lists.debian.org/ podrás tener a
  desarrolladores de Debian con experiencia que te ayudarán con las
  preguntas que pueda tener. Puedes subscribirte a ella enviando un
  correo electrónico a
  <email/debian-mentors-request@lists.debian.org/ con la palabra
  `subscribe' en el tema del mensaje.

  <p>Si aún tiene preguntas, házlas en la lista de distribución de
  Desarrolladores de Debian en <email/debian-devel@lists.debian.org/.
  Puedes subscribirte a ella enviando un correo electrónico a
  <email/debian-devel-request@lists.debian.org/ con la palabra
  `subscribe' en el tema del mensaje. Si ya eres un desarrollador de
  Debian deberías estar suscrito a ella de todas formas.

  <p>Aunque todo funcionara bien, es el momento de empezar a
  rezar. ¿Por qué? Por que en sólo unas horas (o días) usuarios de
  todo el mundo empezarán a usar tu paquete, y si cometiste algún
  error crítico serás bombardeado por correos de centenares de
  usuarios furiosos de Debian... Sólo bromeaba :-)

  <p>Relájate y prepárate para recibir reportes de fallos, porque hay
  mucho más trabajo que hacer antes de seguir completamente las
  políticas de Debian (una vez más lee la <em>documentación real</em>
  para más detalles). ¡Buena suerte!

 </book>

</debiandoc>
