ubuntu-packaging-guide - en to es translation catalogue (391 entries)

en: autopkgtest: Automatic testing for packages
es: autopkgtest: pruebas automáticas para paquetes

en: add a file called ``debian/tests/control`` which specifies the requirements for the testbed,
es: añadir un archivo de nombre ``debian/tests/control`` que especifique los requisitos para el banco de pruebas,

en: add the tests in ``debian/tests/``.
es: añadir las pruebas en ``debian/tests/``.

en: Testbed requirements
es: Requisitos del banco de pruebas

en: Below we are having a look at the ``glib2.0`` source package. In a very simple case the file would look like this::
es: Más adelante vamos a ver el paquete fuente ``glib2.0``. En un caso muy simple el archivo podría tener la siguiente forma::

en: For the test in ``debian/tests/build`` this would ensure that the packages ``libglib2.0-dev`` and ``build-essential`` are installed.
es: Para la prueba de ``debian/tests/build`` esto se aseguraría que los paquetes ``libglib2.0-dev`` y ``build-essential`` están instalados.

en: You can use ``@`` in the ``Depends`` line to indicate that you want all the packages installed which are built by the source package in question.
es: Puede usar ``@`` en la línea ``Depends`` para indicar que desea que estén instalados todos los paquetes que son compilados por el paquete fuente en cuestión.

en: The actual tests
es: La prueba real

en: The accompanying test for the example above might be:
es: La prueba asociada al ejemplo anterior podría ser:

en: Here a very simple piece of C code is written to a temporary directory. Then this is compiled with system libraries (using flags and library paths as provided by `pkg-config`). Then the compiled binary, which just exercises some parts of core glib functionality, is run.
es: Aquí una porción de código C muy simple se escribe en un directorio temporal. Luego es compilada con las bibliotecas del sistema (usando los marcadores y rutas de bibliotecas proporcionadas por `pkg-config`). Luego el binario compilado, que simplemente prueba algunas partes de la funcionalidad del núcleo de glib, se ejecuta.

en: Executing the test
es: Ejecutando la prueba

en: Further examples
es: Más ejemplos

en: This list is not comprehensive, but might help you get a better idea of how automated tests are implemented and used in Ubuntu.
es: Esta lista no es completa, pero podría ayudarle a hacer una mejor idea de cómo están implementadas y cómo se usan las pruebas automatizadas en Ubuntu.

en: Ubuntu infrastructure
es: Infraestructura de Ubuntu

en: Getting the test into Ubuntu
es: Llevando la prueba a Ubuntu

en: The process of submitting an autopkgtest for a package is largely similar to :doc:`fixing a bug in Ubuntu<./fixing-a-bug>`. Essentially you simply:
es: El proceso de enviar un autopkgtest para un paquete es muy parecido a :doc:`fixing a bug in Ubuntu<./fixing-a-bug>`. En esencia debe simplemente:

en: run ``bzr branch ubuntu:<packagename>``,
es: ejecutar ``bzr branch ubuntu:<packagename>``,

en: edit ``debian/control`` to enable the tests,
es: editar el archivo ``debian/control`` para activar las pruebas,

en: add the ``debian/tests`` directory,
es: añadir el directorio ``debian/tests``.

en: add your test case(s) to ``debian/tests``,
es: añadir sus casos de prueba a ``debian/tests``,

en: commit your changes, push them to Launchpad, propose a merge and get it reviewed just like any other improvement in a source package.
es: confirmar los cambios, empujarlos a Launchpad, proponer una integración y hacer que la revisen igual que cualquier otra mejora de un paquete fuente.

en: What you can do
es: Lo que puede hacer

en: Backporting software updates
es: Adaptar actualizaciones de software a versiones anteriores

en: Personal Package Archive (PPA)
es: Archivo de paquetes personal («Personal Package Archive», PPA)

en: Using a PPA has a number of benefits. It is fairly straight-forward, you don't need approval of anyone, but the downside of it is that your users will have to manually enable it. It is a non-standard software source.
es: Usar un PPA tiene una serie de ventajas. Es bastante directo, no necesita la aprobación de nadie, pero la desventaja es que sus usuarios tendrán que activarlo manualmente. Es un origen de software no estándar.

en: Official Ubuntu Backports
es: Adaptaciones oficiales a versiones anteriores de Ubuntu

en: The Backports Project is a means to provide new features to users. Because of the inherent stability risks in backporting packages, users do not get backported packages without some explicit action on their part. This generally makes backports an inappropriate avenue for fixing bugs. If a package in an Ubuntu release has a bug, it should be fixed either through the :doc:`Security Update or the Stable Release Update process<./security-and-stable-release-updates>`, as appropriate.
es: El proyecto Backports (adaptaciones a versiones antiguas) es un medio de proporcionar nuevas funcionalidades a los usuarios. Debido al riesgo inherente de afectar a la estabilidad al adaptar los paquetes a versiones antiguas, los usuarios no obtienen estos paquetes sin algún tipo de acción explícita por su parte. Esto generalmente convierte a las adaptaciones en camino poco adecuado para corregir errores. Si un paquete en una emisión de Ubuntu tiene un error, debería ser corregido mediante los procesos descritos en  :doc:`Security Update or the Stable Release Update process<./security-and-stable-release-updates>`, según sea corresponda.

en: Once you determined you want a package to be backported to a stable release, you will need to test-build and test it on the given stable release. ``pbuilder-dist`` (in the ``ubuntu-dev-tools`` package) is a very handy tool to do this easily.
es: Una vez haya determinado que quiere adaptar un paquete a una versión estable, necesitará hacer una compilación de prueba y probarla sobre dicha versión estable. ``pbuilder-dist`` (del paquete  ``ubuntu-dev-tools``) es una herramienta muy práctica para hacerlo fácilmente.

en: To report the backport request and get it processed by the Backporters team, you can use the ``requestbackport`` tool (also in the ``ubuntu-dev-tools`` package). It will determine the intermediate releases that package needs to be backported to, list all reverse-dependencies, and file the backporting request.  Also will it include a testing checklist in the bug.
es: Para reportar una petición de adaptación y hacer que el equipo de Backporters la procese, puede usar la herramienta ``requestbackport`` (también del paquete ``ubuntu-dev-tools``). Esta herramienta determinará las emisiones intermedias a las que el paquete necesita ser adaptado, listará todas las dependencias inversas y rellenará la petición de adaptación. También incluirá una lista de comprobación en el error.

en: Using Chroots
es: Usar chroots

en: If you are running one version of Ubuntu but working on packages for another versions you can create the environment of the other version with a ``chroot``.
es: Si ejecuta una versión de Ubuntu pero trabaja en paquetes de otra versión, puede crear un ambiente para esa otra versión con un ``chroot``

en: A ``chroot`` allows you to have a full filesystem from another distribution which you can work in quite normally.  It avoids the overhead of running a full virtual machine.
es: Un ``chroot`` le permite tener un sistema de archivos completo de otra distribución el cual puede funcionar normalmente. Esto evita la sobrecarga de ejecutar una maquina virtual

en: Creating a Chroot
es: Crear un chroot

en: Use the command ``debootstrap`` to create a new chroot::
es: Use la orden  ``debootstrap`` para crear un nuevo chroot::

en: You can then work inside the chroot::
es: Puede trabajar dentro del chroot::

en: Where you can install or remove any package you wish without affecting your main system.
es: Dónde  puede instalar o eliminar cualquier paquete que desee sin afectar a su sistema principal.

en: You might want to copy your GPG/ssh keys and Bazaar configuration into the chroot so you can access and sign packages directly::
es: Quizás quiera copiar sus claves GPG/ssh y su configuración de Bazaar dentro del chroot de manera que pueda acceder y firmar paquetes directamente::

en: To stop apt and other programs complaining about missing locales you can install your relevant language pack::
es: Para detener apt y otros programas que se quejan por la perdida de locales, puede instalar el paquete de idioma correspondiente::

en: If you want to run X programs you will need to bind the /tmp directory into the chroot, from outside the chroot run::
es: Si quiere correr programas X necesita enlazar el directorio /tmp dentro del chroot, desde fuera del chroot ejecute::

en: Some programs may need you to bind /dev or /proc.
es: Algunos programas pueden necesitar vincularse a /dev o /proc.

en: Alternatives
es: Alternativas

en: You can also set up pbuilder to pause when it comes across a build failure.  Copy C10shell from /usr/share/doc/pbuilder/examples into a directory and use the ``--hookdir=`` argument to point to it.
es: Puede configurar pbuilder para hacer una pausa cuando encuentre un error en la construcción. Copie C10shell desde /usr/share/doc/pbuilder/examples en un directorio y use el parámetro ``--hookdir=`` para apuntar a él.

en: Communication in Ubuntu Development
es: Comunicación en el desarrollo de Ubuntu

en: In a project where thousands of lines of code are changed, lots of decisions are made and hundreds of people interact every day, it is important to communicate effectively.
es: En un proyecto donde se modifican miles de líneas de código, se toman muchas decisiones y miles de personas interactúan a diario, es importante comunicarse eficazmente.

en: Mailing lists
es: Listas de correo

en: Mailing lists are a very important tool if you want to communicate ideas to a broader team and make sure that you reach everybody, even across timezones.
es: Las listas de correo son una herramienta importante si quiere comunicar ideas a un equipo más grande y asegurarse de llegar a todos, incluso en distintas zonas horarias.

en: In terms of development, these are the most important ones:
es: En términos de desarrollo, estos son los más importantes:

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel-announce (announce-only, the most important development announcements go here)
es: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel-announce (Solo anuncios, los anuncios más importantes sobre desarrollo van aquí)

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel (general Ubuntu development discussion)
es: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel (discusión general de desarrollo de Ubuntu)

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-motu (MOTU Team discussion, get help with packaging)
es: https://lists.ubuntu.com/mailman/listinfo/ubuntu-motu (Discusión del equipo MOTU, para obtener ayuda con el empaquetado)

en: IRC Channels
es: Canales IRC

en: For real-time discussions, please connect to irc.freenode.net and join one or any of these channels:
es: Para discusiones en tiempo real, conéctese a irc.freenode.net y únase a alguno de estos canales:

en: #ubuntu-devel (for general development discussion)
es: #ubuntu-devel (para discusiones generales sobre desarrollo)

en: #ubuntu-motu (for MOTU team discussion and generally getting help)
es: #ubuntu-motu (para discusiones del equipo MOTU y solicitar ayuda generalmente)

en: Basic Overview of the ``debian/`` Directory
es: Descripción general básica del Directorio  ``debian/``

en: This article will briefly explain the different files important to the packaging of Ubuntu packages which are contained in the ``debian/`` directory. The most important of them are ``changelog``, ``control``, ``copyright``, and ``rules``. These are required for all packages. A number of additional files in the ``debian/`` may be used in order to customize and configure the behavior of the package. Some of these files are discussed in this article, but this is not meant to be a complete list.
es: En este artículo explicaremos brevemente los diferentes archivos que son importantes para el empaquetado de paquetes Ubuntu los cuales están en el directorio  ``debian/``. Los más importantes son  ``changelog``,  ``control``, ``copyright``  y ``rules``. Estos son requeridos por todos los paquetes. Un conjunto de archivos adicionales en ``debian/`` puede que sean usados para personalizar y configurar el comportamiento del paquete. Sobre algunos de ello se habla en este articulo, pero esto no pretende ser una lista completa.

en: The changelog
es: El registro de cambios

en: This file is, as its name implies, a listing of the changes made in each version. It has a specific format that gives the package name, version, distribution, changes, and who made the changes at a given time. If you have a GPG key (see: :doc:`Getting set up<./getting-set-up/>`), make sure to use the same name and email address in ``changelog`` as you have in your key. The following is a template ``changelog``::
es: Este archivo es, como su nombre indica, un listado de los cambios realizados en cada versión. Tiene un formato especifico que da el nombre del paquete, versión,  distribución, cambios, y quién realizó estos cambios en un determinado momento. Si tiene una clave GPG (vea: :doc:`Getting set up<./getting-set-up/>`), asegúrese de usar el mismo nombre y dirección de correo electrónico en ``changelog``. tal y cómo lo tiene en la clave. Lo siguiente es una plantilla de ``changelog``::

en: The format (especially of the date) is important. The date should be in :rfc:`5322` format, which can be obtained by using the command ``date -R``. For convenience, the command ``dch`` may be used to edit changelog. It will update the date automatically.
es: El formato (especialmente el de la fecha) es importante. La fecha debe estar en formato :rfc:`5322`, que puede obtenerse mediante la orden ``date -R``. Por conveniencia, la orden ``dchx`` se puede usar para editar el archivo changelog. Se actualizará la fecha de forma automática.

en: Minor bullet points are indicated by a dash "-", while major points use an asterisk "*".
es: Los puntos de segundo nivel se indican con un guión «-», los de primer nivel usan un asterisco «*».

en: If you are packaging from scratch, ``dch --create`` (``dch`` is in the ``devscripts`` package) will create a standard ``debian/changelog`` for you.
es: Si está empaquetando desde cero, ``dch --create`` (``dch`` se encuentra en el paquete ``devscripts``) creará un archivo ``debian\changelog`` estándar.

en: Here is a sample ``changelog`` file for hello::
es: Este es un ejemplo del archivo ``changelog`` para hello::

en: Notice that the version has a ``-0ubuntu1`` appended to it, this is the distro revision, used so that the packaging can be updated (to fix bugs for example) with new uploads within the same source release version.
es: Observe que el paquete tiene un ``-0ubuntu1`` anexado a el, este representa la versión en la distribución y se usa para que el paquete pueda ser actualizado (para solucionar errores por ejemplo) con nuevas subidas usando la misma versión principal con la que se liberó.

en: Ubuntu and Debian have slightly different package versioning schemes to avoid conflicting packages with the same source version. If a Debian package has been changed in Ubuntu, it has ``ubuntuX`` (where ``X`` is the Ubuntu revision number) appended to the end of the Debian version. So if the Debian hello ``2.6-1`` package was changed by Ubuntu, the version string would be ``2.6-1ubuntu1``. If a package for the application does not exist in Debian, then the Debian revision is ``0`` (e.g. ``2.6-0ubuntu1``).
es: Ubuntu y Debian tienen esquemas de versión de paquetes ligeramente diferentes para evitar conflictos en los programas con la misma versión principal.  Si una paquete de Debian sufre un cambio en Ubuntu, se le agrega el ``ubuntuX`` (donde ``X`` es el número de revisión en Ubuntu) al final de la versión de Debian. Si el paquete hello ``2.6-1`` de Debian es modificado en Ubuntu, la versión quedaría ``2.6-1ubuntu1``. Si el paquete no existiera en Debian, entonces la revisión ahí sería ``0`` (y quedaría ``2.6-0ubuntu1``).

en: The control file
es: El archivo de control

en: The ``control`` file contains the information that the package manager (such as ``apt-get``, ``synaptic``, and ``adept``) uses, build-time dependencies, maintainer information, and much more.
es: El archivo ``control`` contiene la información que usan administradores de paquetes (como ``apt-get``, ``synaptic`` y ``adept``), dependencias  de compilación, información del mantenedor y mucho más.

en: For the Ubuntu ``hello`` package, the ``control`` file looks something like this:
es: Para el paquete ``hello`` de Ubuntu, el archivo ``control`` tiene el siguiente aspecto:

en: The first paragraph describes the source package including the list of packages required to build the package from source in the ``Build-Depends`` field. It also contains some meta-information such as the maintainer's name, the version of Debian Policy that the package complies with, the location of the packaging version control repository, and the upstream home page.
es: El primer párrafo describe el paquete fuente incluyendo la lista de paquetes requeridos para construirlo desde sus fuentes en el campo ``Build-Depends``. También contiene alguna meta-información como el nombre del mantenedor, la versión de la política de Debian que cumple el paquete, la ubicación del repositorio de control de versiones del paquete y la página principal para enviar el parche.

en: Each additional paragraph describes a binary package to be built.
es: Cada párrafo adicional describe un paquete binario a ser construido.

en: The copyright file
es: El archivo copyright

en: Generally, copyright information is found in the ``COPYING`` file in the program's source directory. This file should include such information as the names of the author and the packager, the URL from which the source came, a Copyright line with the year and copyright holder, and the text of the copyright itself. An example template would be::
es: Por lo general, la información sobre los derechos de autor se encuentra en el archivo ``COPYING`` dentro del directorio de código fuente del programa. Este archivo debe contener información tal los nombres de los autores, del creador del paquete, la URL de donde salió el código fuente y una línea de Copyright con el año, el titular de los derechos de autor y el propio texto del copyright. Una plantilla de ejemplo sería::

en: The rules file
es: El archivo de reglas

en: The last file we need to look at is ``rules``. This does all the work for creating our package. It is a Makefile with targets to compile and install the application, then create the ``.deb`` file from the installed files. It also has a target to clean up all the build files so you end up with just a source package again.
es: El último archivo que se necesita estudiar es el archivo ``rules``. Este archivo hace todo el trabajo para crear el paquete. Es un Makefile con secciones para compilar e instalar el programa, y después crear el archivo ``.deb`` a partir de los archivos instalados. También tiene una sección para limpiar todos los archivos generados por la compilación, con el fin de volver a quedarse únicamente con el paquete fuente.

en: Here is a simplified version of the rules file created by ``dh_make`` (which can be found in the ``dh-make`` package):
es: Esta es una versión simplificada del archivo de reglas creado por ``dh_make`` (el cual se puede encontrar en el paquete ``dh-make``):

en: Let us go through this file in some detail. What this does is pass every build target that ``debian/rules`` is called with as an argument to ``/usr/bin/dh``, which itself will call all the necessary ``dh_*`` commands.
es: Analicemos con más detalle este archivo. Lo que hace es pasar cada sección de compilación invocada por ``debian/rules`` como un parámetro a ``/usr/bin/dh``, que a su vez ejecutará todos los comandos ``dh_*`` necesarios.

en: ``dh`` runs a sequence of debhelper commands. The supported sequences correspond to the targets of a ``debian/rules`` file: "build", "clean", "install", "binary-arch", "binary-indep", and "binary". In order to see what commands are run in each target, run::
es: ``dh`` ejecuta una secuencia de órdenes de debhelper. Las secuencias soportadas son las que corresponden a las secciones del archivo ``debian/rules``: «build», «clean», «install», «binary-indep», y «binary». Para saber cuales son las órdenes que se ejecutan en cada sección, ejecute::

en: Commands in the binary-indep sequence are passed the "-i" option to ensure they only work on binary independent packages, and commands in the binary-arch sequences are passed the "-a" option to ensure they only work on architecture dependent packages.
es: A las órdenes de la secuencia binary-indep se incluye la opción «-i» para asegurar que solo funcionen en paquetes binarios independientes, mientras que a las órdenes de la secuencia binary-arch se les agrega una opción «-a» para asegurar que solo funcionen para paquetes independientes de la arquitectura.

en: Each debhelper command will record when it's successfully run in ``debian/package.debhelper.log``. (Which dh_clean deletes.) So dh can tell which commands have already been run, for which packages, and skip running those commands again.
es: Cada orden debhelper registrará cuando se ha ejecutado correctamente en «debian/package.debhelper.log» (archivo que dh_clean elimina). De esta manera dh puede saber qué órdenes ya han sido ejecutadas, para qué paquetes y evitar ejecutar esas órdenes de nuevo.

en: Each time ``dh`` is run, it examines the log, and finds the last logged command that is in the specified sequence. It then continues with the next command in the sequence. The ``--until``, ``--before``, ``--after``, and ``--remaining`` options can override this behavior.
es: Cada vez que ``dh`` se ejecuta, comprueba el registro y busca la última orden registrada que está en la secuencia especificada. Continúa entonces con la siguiente orden de la secuencia. Las opciones ``--until``, ``--before``, ``--after`` y ``--remaining`` pueden modificar este comportamiento.

en: If ``debian/rules`` contains a target with a name like ``override_dh_command``, then when it gets to that command in the sequence, ``dh`` will run that target from the rules file, rather than running the actual command. The override target can then run the command with additional options, or run entirely different commands instead. (Note that to use this feature, you should Build-Depend on debhelper 7.0.50 or above.)
es: Si el archivo ``debian/rules`` contiene una sección con el nombre ``override_dh_command``, cuando se llegue a esa orden en la secuencia, ``dh`` ejecutará esa sección en lugar de la orden original. La sección sobrescrita puede ejecutar entonces la orden con opciones adicionales, o ejecutar órdenes completamente diferentes en su lugar (téngase en cuenta  que para usar esta característica, se debería construir las dependencias con debhelper 7.0.50 o superior).

en: Have a look at ``/usr/share/doc/debhelper/examples/`` and ``man dh`` for more examples. Also see `the rules section (Section 4.9) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianrules>`_ of the Debian Policy Manual.
es: Véase ``/usr/share/doc/debhelper/examples/`` y ``man dh`` para más ejemplos. Véase  también `la sección sobre el archivo de reglas (sección 4.9)  <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianrules>`_ del manual de normas de Debian.

en: Additional Files
es: Archivos adicionales

en: The install file
es: El archivo de instalación

en: The ``install`` file is used by ``dh_install`` to install files into the binary package. It has two standard use cases:
es: El archivo ``install`` lo usa ``dh_install`` para instalar archivos en el paquete binario. Tiene dos casos de uso estándar:

en: To install files into your package that are not handled by the upstream build system.
es: Para instalar archivos en el paquete que no son manejados por el sistema de compilación del proyecto original.

en: Splitting a single large source package into multiple binary packages.
es: Partir paquete fuente en un único fichero grande en varios paquetes binarios.

en: In the first case, the ``install`` file should have one line per file installed, specifying both the file and the installation directory. For example, the following ``install`` file would install the script ``foo`` in the source package's root directory to ``usr/bin`` and a desktop file in the ``debian`` directory to ``usr/share/applications``::
es: En el primer caso, el archivo ``install`` debería contener solo una linea por cada archivo instalado, indicando tanto el archivo como el directorio de destino. Por ejemplo, el siguiente archivo ``install`` instalaría el script ``foo`` que se encuentra en la raíz del paquete en ``usr/bin`` y el archivo «desktop» del directorio ``debian`` en ``usr/share/applications``::

en: When a source package is producing multiple binary packages ``dh`` will install the files into ``debian/tmp`` rather than directly into ``debian/<package>``. Files installed into ``debian/tmp`` can then be moved into separate binary packages using multiple ``$package_name.install`` files. This is often done to split large amounts of architecture independent data out of architecture dependent packages and into ``Architecture: all`` packages. In this case, only the name of the files (or directories) to be installed are needed without the installation directory. For example, ``foo.install`` containing only the architecture dependent files might look like::
es: Cuando un paquete fuente crea varios paquetes binarios, ``dh`` instala los archivos en ``debian/tmp`` en lugar de ``debian/<paquete>``. Los archivos instalados en ``debian/tmp`` pueden entonces moverse a diferentes paquetes binarios usando varios archivos ``$nombre_paquete.install``. Esto se hace frecuentemente para separar grandes cantidades de datos que son independientes de la arquitectura de paquetes que dependen de la misma, llevándolos a paquetes ``Architecture: all``.  En este caso, solo se necesita el nombre de los archivos (o directorios) a instalar, sin el directorio de instalación. Por ejemplo, un archivo ``foo.install`` que solo contenga archivos dependientes de la arquitectura se vería así::

en: While ``foo-common.install`` containing only the architecture independent file might look like::
es: Por el contrario, un archivo ``foo-common.install`` que solo contenga archivos que son independientes de la arquitectura se vería así:

en: This would create two binary packages, ``foo`` and ``foo-common``. Both would require their own paragraph in ``debian/control``.
es: Esto crearía dos paquetes binarios, ``foo`` y ``foo-common``. Ambos necesitarían su propia sección en el archivo ``debian/control``.

en: See ``man dh_install`` and the `install file section (Section 5.11) <http://www.debian.org/doc/manuals/maint-guide/dother.en.html#install>`_  of the Debian New Maintainers' Guide for additional details.
es: Véase ``man dh_install`` y la `sección sobre el archivo «install» (Section 5.11) <http://www.debian.org/doc/manuals/maint-guide/dother.en.html#install>`_ de la guía del nuevo mantenedor de Debian para obtener más información.

en: The watch file
es: El archivo de avisos («watch»)

en: The ``debian/watch`` file allows us to check automatically for new upstream versions using the tool ``uscan`` found in the ``devscripts`` package. The first line of the watch file must be the format version (3, at the time of this writing), while the following lines contain any URLs to parse. For example::
es: El archivo ``debian/watch`` permite comprobar automáticamente si existe una nueva versión del proyecto original con la herramienta ``uscan``, localizada en el paquete ``devscripts``.  La primera línea del archivo «watch» debe describir la versión del formato (3, en el momento de escribir esto), mientras que el resto de líneas contienen las URLs a analizar. Por ejemplo::

en: Running ``uscan`` in the root source directory will now compare the upstream version number in ``debian/changelog`` with the latest available upstream version. If a new upstream version is found, it will be automatically downloaded. For example::
es: Ejecutando ``uscan`` en el directorio raíz del paquete comparará el número de versión original que se encuentra en ``debian/changelog`` con el último disponible en el proyecto original. Si se encuentra una versión más moderna del proyecto original, se descargará automáticamente. Por ejemplo::

en: For further information, see ``man uscan`` and the `watch file section (Section 4.11) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianwatch>`_ of the Debian Policy Manual.
es: Para más información, véase ``man uscan`` y la `sección sobre el archivo «watch» (sección 4.11) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianwatch>`_ del manual de normas de Debian.

en: For a list of packages where the ``watch`` file reports they are not in sync with upstream see `Ubuntu External Health Status <http://qa.ubuntuwire.org/uehs/no_updated.html>`_.
es: Para obtener una lista de los paquetes de los que el archivo ``watch`` informa no estar sincronizados con las versiones originales véase la página `Ubuntu External Health Status <http://qa.ubuntuwire.org/uehs/no_updated.html>`_ (estado de salud externa de Ubuntu, en inglés).

en: The source/format file
es: El archivo de formato («source/format»)

en: This file indicates the format of the source package. It should contain a single line indicating the desired format:
es: Este archivo indica el formato fuente del  paquete. Solo debería contener una línea indicando el formato deseado:

en: ``3.0 (native)`` for Debian native packages (no upstream version)
es: ``3.0 (native)`` para paquetes nativos de Debian (sin versión en upstream)

en: ``3.0 (quilt)`` for packages with a separate upstream tarball
es: ``3.0 (quilt)`` para paquetes con un archivo tar de upstream independiente.

en: ``1.0`` for packages wishing to explicitly declare the default format
es: ``1.0`` para paquetes que desean declarar explícitamente el formato por defecto

en: Currently, the package source format will default to 1.0 if this file does not exist. You can make this explicit in the source/format file. If you choose not to use this file to define the source format, Lintian will warn about the missing file. This warning is informational only and may be safely ignored.
es: Actualmente, el formato fuente del paquete será por defecto 1.0 si no existe este archivo. Se puede establecer esto explícitamente en el archivo  «source/format». Si elige no usar este archivo para definir el formato, Lintian mostrará una advertencia sobre su ausencia. La advertencia es de carácter informativo y puede ser ignorada.

en: You are encouraged to use the newer 3.0 source format. It provides a number of new features:
es: Se le anima a utilizar el nuevo formato fuente 3.0 .  Proporciona una serie de nuevas características:

en: Support for additional compression formats: bzip2, lzma and xz
es: Soporte para formatos de compresión adicionales: bzip2, lzma y xz

en: Support for multiple upstream tarballs
es: Soporte para varios archivos tar de upstream

en: Not necessary to repack the upstream tarball to strip the debian directory
es: No es necesario volver a empaquetar los archivos tar de upstream para eliminar el directorio debian

en: Debian-specific changes are no longer stored in a single .diff.gz but in multiple patches compatible with quilt under ``debian/patches/``
es: Los cambios específicos de Debian ya no se guardan en un único archivo .diff.gz, sino en varios parches compatibles con quilt en ``debian/patches/``

en: Additional Resources
es: Recursos adicionales

en: Fixing a bug in Ubuntu
es: Corregir un fallo en Ubuntu

en: Introduction
es: Introducción

en: If you followed the instructions to :doc:`get set up with Ubuntu Development<./getting-set-up>`, you should be all set and ready to go.
es: Si se han seguido las instrucciones de :doc:`ponerse en marcha con el desarrollo de Ubuntu<./getting-set-up>`, debería estar preparado para comenzar.

en: As you can see in the image above, there is no surprises in the process of fixing bugs in Ubuntu: you found a problem, you get the code, work on the fix, test it, push your changes to Launchpad and ask for it to be reviewed and merged. In this guide we will go through all the necessary steps one by one.
es: Como se puede observar en la imagen superior, no hay sorpresas en el proceso de corrección de fallos en Ubuntu: se encuentra un problema, se descarga el código fuente, se trabaja en la solución, se prueba, se envían los cambios a Launchpad y se pide que sea revisado e integrado. Durante esta guía se pasará por todos estos pasos, uno a uno.

en: Finding the problem
es: Encontrar el problema

en: There are a lot of different ways to find things to work on. It might be a bug report you are encountering yourself (which gives you a good opportunity to test the fix), or a problem you noted elsewhere, maybe in a bug report.
es: Hay muchas formas de encontrar cosas en las que trabajar. Puede ser reportando un error que usted mismo haya encontrado (lo que le da una buena oportunidad de probar la solución), o un problema que haya encontrado en otro lugar, tal vez en un informe de error.

en: Figuring out what to fix
es: Averiguar qué se debe corregir

en: If you don't know the source package containing the code that has the problem, but you do know the path to the affected program on your system, you can discover the source package that you'll need to work on.
es: Si no se conoce el paquete fuente que contiene el código con el problema, pero sí la ruta al programa afectado en su sistema, puede encontrar el paquete en el que necesitará trabajar.

en: This would print out::
es: Esto mostrará::

en: ``apt-cache`` is part of the standard installation of Ubuntu.
es: ``apt-cache`` es parte de la instalación estándar de Ubuntu.

en: Confirming the problem
es: Confirmar el problema

en: Let's say the package ``bumprace`` does not have a homepage in its package description. As a first step you would check if the problem is not solved already. This is easy to check, either take a look at Software Center or run::
es: Digamos que el paquete ``bumprace`` no tiene una página web en su descripción. Como primer paso podría comprobar que el problema no esté ya resuelto. Es fácil de hacer, bien mirando al Centro de software o ejecutando::

en: The output should be similar to this::
es: La salida debería ser algo parecido a esto::

en: A counter-example would be ``gedit``, which has a homepage set::
es: Un contraejemplo sería ``gedit``, el cual tiene definida una página web::

en: Sometimes you will find that a particular problem you are looking into is already fixed. To avoid wasting efforts and duplicating work it makes sense to first do some detective work.
es: A veces se encontrará con que un problema concreto que estaba mirando ya ha sido corregido. Para evitar desperdiciar esfuerzos y duplicar trabajos tiene sentido realizar antes cierto trabajo de investigación.

en: Research bug situation
es: Investigar la situación de un error

en: First we should check if a bug for the problem exists in Ubuntu already. Maybe somebody is working on a fix already, or we can contribute to the solution somehow. For Ubuntu we have a quick look at https://bugs.launchpad.net/ubuntu/+source/bumprace and there is no open bug with our problem there.
es: Primero debería comprobar si ya existe un informe de error para el problema en Ubuntu. Quizá ya haya alguien trabajando en una corrección o podamos contribuir de alguna forma a la solución. Para Ubuntu echamos un vistazo rápido a https://bugs.launchpad.net/ubuntu/+source/bumprace y vemos que no hay un error abierto aquí para nuestro problema.

en: For Ubuntu the URL ``https://bugs.launchpad.net/ubuntu/+source/<package>`` should always take to the bug page of the source package in question.
es: Para Ubuntu la URL  ``https://bugs.launchpad.net/ubuntu/+source/<package>`` siempre debería llevar la página de error del paquete fuente en cuestión.

en: For Debian, which is the major source for Ubuntu's packages, we have a look at http://bugs.debian.org/src:bumprace and can't find a bug report for our problem either.
es: Para Debian, que es la fuente principal de paquetes para Ubuntu, echamos un vistazo a http://bugs.debian.org/src:bumprace y tampoco pudimos encontrar un informe de error sobre nuestro problema.

en: For Debian the URL ``http://bugs.debian.org/src:<package>`` should always take to the bug page of the source package in question.
es: Para Debian la URL ``http://bugs.debian.org/src:<package>`` siempre debería llevar la página de error del paquete fuente en cuestión.

en: The problem we are working on is special as it only concerns the packaging-related bits of ``bumprace``. If it was a problem in the source code it would be helpful to also check the Upstream bug tracker. This is unfortunately often different for every package you have a look at, but if you search the web for it, you should in most cases find it pretty easily.
es: El problema en el que estamos trabajando es especial ya que sólo afecta a parte relacionada con el empaquetado de ``bumprace``. Si hubiera un problema en el código fuente sería útil comprobar también el registro de errores aguas arriba. Desafortunadamente este es a menudo diferente para cada paquete que mire, pero si lo busca en la web, en la mayoría de los casos debería encontrarlo fácilmente.

en: Offering help
es: Ofrecer ayuda

en: If you found an open bug and it is not assigned to somebody and you are in a position to fix it, you should comment on it with your solution. Be sure to include as much information as you can: Under which circumstances does the bug occur? How did you fix the problem? Did you test your solution?
es: Si encuentra un error abierto que no está asignado a nadie y está en situación de corregirlo, debería añadir un comentario con su solución. Asegúrese de incluir tanta información como sea posible: ¿bajo qué circunstancias ocurre el error? ¿cómo ha corregido el problema? ¿ha probado la solución?

en: If no bug report has been filed, you can file a bug for it. What you might want to bear in mind is: Is the issue so small that just asking for somebody to commit it is good enough? Did you manage to only partially fix the issue and you want to at least share your part of it?
es: Si no se ha rellenado ningún informe de error, puede crear uno. Lo que debe tener en cuenta es lo siguiente: ¿es la incidencia tan pequeña que simplemente pedir que alguien la confirme es suficiente? ¿ha podido únicamente corregir parcialmente la incidencia y desea al menos compartir su parte?

en: It is great if you can offer help and will surely be appreciated.
es: Es bueno poder ofrecer ayuda y con toda seguridad será apreciada.

en: Getting the code
es: Obtener el código

en: Work on a fix
es: Trabajar en una solución

en: There are entire books written about finding bugs, fixing them, testing them, etc. If you are completely new to programming, try to fix easy bugs such as obvious typos first. Try to keep changes as minimal as possible and document your change and assumptions clearly.
es: Se han escrito libros completos sobre cómo encontrar errores, cómo arreglarlos, cómo probarlos, etc. Si completamente novato en programación, intente primero encontrar errores simples como erratas obvias en los textos. Intente mantener tan reducidos como sea posible y documente claramente tanto los cambios como los supuestos que haga.

en: Before working on a fix yourself, make sure to investigate if nobody else has fixed it already or is currently working on a fix. Good sources to check are:
es: Antes de comenzar a trabajar en una solución, asegúrese de investigar si alguien más ya lo ha solucionado o está trabajando en una solución. Algunos buenos lugares para buscar son:

en: Upstream (and Debian) bug tracker (open and closed bugs),
es: El sistema de seguimiento de errores (abiertos y cerrados) del proyecto original (y de Debian)

en: Upstream revision history (or newer release) might have fixed the problem,
es: El historial de cambios del proyecto original (o una versión más reciente) podría haber corregido el problema.

en: bugs or package uploads of Debian or other distributions.
es: La subida de errores o paquetes de Debian u otras distribuciones

en: This will copy the packaging to a temporary directory.  You can now edit files with a text editor or apply patches from upstream, for example::
es: Esto copiara el paquete a un directorio temporal. Ahora ya puede editar los archivos con un editor de textos o aplicar parches desde el proyecto original, por ejemplo::

en: After editing the file type ``exit`` or press ``control-d`` to quit the temporary shell.  The new patch will have been added into ``debian/patches``.
es: Completada la edición escriba ``exit`` o pulse ``Ctrl+D`` para abandonar el intérprete de órdenes temporal. El nuevo parche se habrá añadido a ``debian/patches``.

en: Documenting the fix
es: Documentar la solución

en: It is very important to document your change sufficiently so developers who look at the code in the future won't have to guess what your reasoning was and what your assumptions were. Every Debian and Ubuntu package source includes ``debian/changelog``, where changes of each uploaded package are tracked.
es: Es muy importante documentar con suficiente detalle los cambios que se hacen, de tal forma que los desarrolladores que revisen el código en el futuro no tengan que imaginar su razonamiento y sus supuestos cuando lo hizo. Cada paquete fuente de Debian y Ubuntu contiene un archivo ``debian/changelog`` donde se mantienen los cambios de cada paquete subido.

en: The easiest way to update this is to run::
es: La manera más fácil de actualizar esto es ejecutar::

en: This will add a boilerplate changelog entry for you and launch an editor where you can fill in the blanks. An example of this could be::
es: Esto añadirá una entrada modelo al registro de cambios y lanzará un editor en el que poder rellenar los campos vacíos. Un ejemplo podría ser::

en: ``dch`` should fill out the first and last line of such a changelog entry for you already. Line 1 consists of the source package name, the version number, which Ubuntu release it is uploaded to, the urgency (which almost always is 'low'). The last line always contains the name, email address and timestamp (in :rfc:`5322` format) of the change.
es: ``dch`` debería rellenar por usted la primera y última línea de la entrada en el registro de cambios. La línea 1 contiene el nombre del paquete fuente, la número de versión, la emisión de Ubuntu a la que va dirigida, la urgencia (que casi en todos los casos es «low», baja). La última línea siempre contiene el nombre, la dirección de correo y la fecha y hora (en formato :rfc:`5322`) del cambio.

en: With that out of the way, let's focus on the actual changelog entry itself: it is very important to document:
es: Realizado todo esto, céntrese en la propia entrada del registro de cambios: es muy importante documentar:

en: In our (very sparse) example the last point is covered by ``(LP: #123456)`` which refers to Launchpad bug 123456. Bug reports or mailing list threads or specifications are usually good information to provide as a rationale for a change. As a bonus, if you use the ``LP: #<number>`` notation for Launchpad bugs, the bug will be automatically closed when the package is uploaded to Ubuntu.
es: En este (muy sencillo) ejemplo el último punto se cubre por ``(LP: #123456)`` que se refiere al reporte 123456 en Launchpad. Los reportes de errores, discusiones en listas de correos y documentos de especificaciones son buenas fuentes de información que justifican las razones por las cuales se hacen los cambios. Como ventaja adicional, si se usa la notación ``LP: #<número>`` para de los errores de Launchpad, dichos errores se cerrarán automáticamente cuando los cambios se suban a Ubuntu.

en: Testing the fix
es: Probar la solución

en: To build a test package with your changes, run these commands::
es: Para crear un paquete de prueba con los cambios, ejecute estas órdenes::

en: In a lot of cases you will have to actually install the package to make sure it works as expected. Our case is a lot easier. If the build succeeded, you will find the binary packages in ``~/pbuilder/<release>_result``. Install them via ``sudo dpkg -i <package>.deb`` or by double-clicking on them in your file manager.
es: En muchos casos tendrá que instalar de verdad el paquete para asegurarse de que funciona como se espera. En nuestro caso es mucho más fácil. Si la compilación tuvo éxito, encontrará los paquetes binarios en ``~/pbuilder/<release>_result``. Instálelos mediante ``sudo dpkg -i <package>.deb`` o haciendo doble clic sobre ellos en el administrador de archivos.

en: This will take you through a series of steps to make sure the bug ends up in the correct place. Be sure to review the diff again to make sure it does not include random changes you made earlier.
es: Esto le llevará por una serie de pasos para asegurarse de que el error termina en el lugar adecuado. Asegúrese de revisar de nuevo el archivo de differencias (diff) para tener certeza de que no incluye cambios aleatorios que haya realizado anteriormente.

en: Communication is important, so when you add some more description to it to the inclusion request, be friendly, explain it well.
es: La comunicación es importante, así que cuando añada algo más de descripción a la petición de inclusión, sea amigable y explíquelo bien.

en: If everything went well you should get a mail from Debian's bug tracking system with more information. This might sometimes take a few minutes.
es: Si todo ha ido bien debería recibir un correo desde el sistema de registro de errores de Debian con más información. Esto podría llevar unos minutos.

en: Additional considerations
es: Consideraciones adicionales:

en: If you find a package and find that there are a couple of trivial things you can fix at the same time, do it. This will speed up review and inclusion.
es: Si encuentra un paquete y existen un par de cosas triviales que puede corregir al mismo tiempo, hágalo. Esto acelerará su revisión e inclusión.

en: If there are multiple big things you want to fix, it might be advisable to send individual patches or merge proposals instead. If there are individual bugs filed for the issues already, this makes it even easier.
es: Si hay varias cosas importantes que quiera arreglar, sería recomendable enviar parches individuales o peticiones de integración. Si se han rellenado errores independientes para las incidencias, lo hace incluso más fácil.

en: Fixing FTBFS packages
es: Corrección de paquetes que no compilan a partir del código fuente (FTBFS)

en: Before a package can be used in Ubuntu, it has to build from source. If it fails this, it will probably wait in -proposed and will not be available in the Ubuntu archives. You can find a complete list of packages that are failing to build from source at http://qa.ubuntuwire.org/ftbfs/. There are 5 main categories shown on the page:
es: Antes de que un paquete se pueda usar en Ubuntu, tiene que compilarse a partir del código fuente. Si esto falla, probablemente espere en -proposed (propuesto) y no estará disponible en los repositorios de Ubuntu. Puede encontrar una lista completa de los paquetes para los que falla la compilación desde el código fuente en http://qa.ubuntuwire.org/ftbfs/. Se muestran cinco categorías principales en esta página:

en: Package failed to build (F): Something actually went wrong with the build process.
es: Paquetes que fallan la compilación (F): algo falló en el proceso de compilación.

en: Cancelled build (X): The build has been cancelled for some reason. These should probably be avoided to start with.
es: Compilaciones canceladas (X): la compilación se ha cancelado por algún motivo. Estas probablemente deberían evitarse para empezar.

en: Package is waiting on another package (M): This package is waiting on another package to either build, get updated, or (if the package is in main) one of it's dependancies is in the wrong part of the archive.
es: El paquete está esperando a otro paquete (M): este paquete está esperando a que otro paquete se compile, se actualice o (si el paquete está en «main») una de sus dependencias está en la parte equivocada del repositorio.

en: Failure in the chroot (C): Part of the chroot failed, this is most likely fixed by a rebuild. Ask a developer to rebuild the package and that should fix it.
es: Fallo en el «chroot» (C): la parte del «chroot» ha fallado, lo que muy probablemente se arregle mediante una recompilación. Pida a un desarrollador que recompile el paquete y esto debería solucionarlo.

en: Failed to upload (U): The package could not upload. This is usually just a case of asking for a rebuild, but check the build log first.
es: Falló al subirlo (U) el paquete no se pudo subir. Generalmente es simplemente un caso en el que pedir una recompilación, pero compruebe antes el registro de la compilación.

en: First steps
es: Primeros pasos

en: The first thing you'll want to do is see if you can reproduce the FTBFS yourself. Get the code either by running ``bzr branch lp:ubuntu/PACKAGE`` and then getting the tarball or running ``dget PACKAGE_DSC`` on the .dsc file from the launchpad page. Once you have that, build it in a schroot.
es: Lo primero que querrá hacer es ver si puede reproducir el problema de compilación por usted mismo. Obtenga el código ejecutando ``bzr branch lp:ubuntu/PAQUETE`` y después obteniendo el tarball o ejecute `dget PAQUETE_DSC`` sobre el archivo .dsc de la página de launchpad. Una vez lo tenga, compílelo en un «schroot».

en: You should be able to reproduce the FTBFS. If not, check if the build is downloading a missing dependency, which means you just need to make that a build-dependency in debian/control. Building the package locally can also help find if the issue is caused by a missing, unlisted, dependency (builds locally but fails on a schroot).
es: Debería ser capaz de reproducir el error de compilación. Si no es así, compruebe si la compilación está descargando una dependencia faltante, lo que quiere decir que simplemente necesita convertirla en una dependencia de compilación en debian/control. Compilar el paquete en local también puede ayudar a saber si el problema está causado por una dependencia que falta, no listada (se compila localmente, pero falla en un «schroot»).

en: Checking Debian
es: Comprobando Debian

en: Once you have reproduced the issue, it's time to try and find a solution. If the package is in Debian as well, you can check if the package builds there by going to http://packages.qa.debian.org/PACKAGE. If Debian has a newer version, you should merge it. If not, check the buildlogs and bugs linked on that page for any extra information on the ftbfs or patches. Debian also maintains a list of command FTBFSs and how to fix them which can be found at https://wiki.debian.org/qa.debian.org/FTBFS, you will want to check it for solutions too.
es: Una vez que haya reproducido la incidencia, será el momento de buscar una solución. Si el paquete está también en Debian, puede comprobar si compila allí yendo a http://packages.qa.debian.org/PAQUETE. Si Debian cuenta con una versión más moderna, debería fusionarla. Si no es así, compruebe los registros de compilación y los errores enlazados desde esa página para conseguir  información adicional sobre los problemas de compilación o parches. Debian también mantiene una lista de órdenes que fallaron al compilar y cómo corregirlas, la cual se puede encontrar en https://wiki.debian.org/qa.debian.org/FTBFS, donde podrá buscar soluciones.

en: Other causes of a package to FTBFS
es: Otras causas para para que un paquete falle para compilarse desde el código fuente (FTBFS).

en: If a package is in main and missing a dependency that is not in main, you will have to file a MIR bug. https://wiki.ubuntu.com/MainInclusionProcess explains the procedure.
es: Si un paquete está en «main» y le falta una dependencia que no está en «main», tendrá que rellenar un error de MIR. En https://wiki.ubuntu.com/MainInclusionProcess se explica el procedimiento para hacerlo.

en: Fixing the issue
es: Corregir la incidencia

en: Once you have found a fix to the problem, follow the same process as any other bug. Make a patch, add it to a bzr branch or bug, subscribe ubuntu-sponsors, then try to get it included upstream and/or in Debian.
es: Una vez que haya encontrado una solución al problema, siga el mismo proceso para cualquier otro error. Cree un parche, añádalo a una rama bzr o a un error, suscríbase a ubuntu-sponsors y luego intente que lo incluyan agua arriba o en Debian.

en: Getting Set Up
es: Fase de preparación

en: There are a number of things you need to do to get started developing for Ubuntu. This article is designed to get your computer set up so that you can start working with packages, and upload your packages to Ubuntu's hosting platform, Launchpad. Here's what we'll cover:
es: Hay una serie de cosas que necesita hacer para poder empezar a desarrollar para Ubuntu. Este artículo está diseñado para que pueda configurar su equipo de forma que pueda comenzar a trabajar con paquetes y subirlos a Launchpad, la plataforma de hospedaje de Ubuntu. Los temas cubiertos son:

en: Installing packaging-related software. This includes:
es: Instalar software relacionado con el empaquetado. Incluye:

en: Ubuntu-specific packaging utilities
es: Utilidades de empaquetado específicas de Ubuntu

en: Encryption software so your work can be verified as being done by you
es: Software de cifrado, para poder verificar que el trabajo se hizo por el usuario indicado

en: Additional encryption software so you can securely transfer files
es: Software de cifrado adicional para poder enviar archivos de forma segura

en: Creating and configuring your account on Launchpad
es: Crear y configurar una cuenta en Launchpad

en: Setting up your development environment to help you do local builds of packages, interact with other developers, and propose your changes on Launchpad.
es: Configurar un entorno de desarrollo para ayudarle compilar paquetes localmente, interactuar con otros desarrolladores y proponer sus cambios en Launchpad.

en: It is advisable to do packaging work using the current development version of Ubuntu. Doing so will allow you to test changes in the same environment where those changes will actually be applied and used.
es: Se recomienda hacer el trabajo de empaquetado usando la versión actual en desarrollo de Ubuntu. Esto le permitirá probar los cambios en el mismo entorno en el que serán realmente aplicados y usados.

en: Install basic packaging software
es: Instalar software básico de empaquetado

en: This command will install the following software:
es: Esta orden instalará el software siguiente:

en: ``pbuilder`` -- a tool to do reproducible builds of a package in a clean and isolated environment.
es: ``pbuilder`` -- una herramienta para realizar compilaciones reproducibles de una paquete en un entorno limpio y aislado.

en: ``ubuntu-dev-tools`` (and ``devscripts``, a direct dependency) -- a collection of tools that make many packaging tasks easier.
es: ``ubuntu-dev-tools`` (y ``devscripts``, una dependencia directa) -- una colección de herramientas que hace muchas tareas del empaquetado más sencillas.

en: ``apt-file`` provides an easy way to find the binary package that contains a given file.
es: ``apt-file`` proporciona una forma sencilla de encontrar el paquete binario que contiene un archivo determinado.

en: Create your GPG key
es: Crear su clave GPG

en: To generate a new GPG key, run::
es: Para generar una nueva clave GPG, ejecute::

en: GPG will first ask you which kind of key you want to generate. Choosing the default (RSA and DSA) is fine. Next it will ask you about the keysize. The default (currently 2048) is fine, but 4096 is more secure. Afterwards, it will ask you if you want it to expire the key at some stage. It is safe to say "0", which means the key will never expire. The last questions will be about your name and email address. Just pick the ones you are going to use for Ubuntu development here, you can add additional email addresses later on. Adding a comment is not necessary. Then you will have to set a passphrase, choose a safe one (a passphrase is just a password which is allowed to include spaces).
es: GPG primero le preguntará qué tipo de clave desea generar. Elegir el tipo por defecto (RSA y DSA) es correcto. Después le preguntará por el tamaño de la clave. El predeterminado (actualmente 2048) es adecuado, pero 4096 es más seguro. Posteriormente le preguntará si desea que la clave caduque en algún momento. Es seguro decir «0», lo que significa que nunca expirará. Las últimas preguntas serán sobre su nombre y dirección de correo electrónico. Aquí simplemente elija los que quiere usar para el desarrollo de Ubuntu, y puede añadir direcciones de correo electrónico adicionales posteriormente. No es necesario añadir un comentario. Luego tendrá que establecer una frase de paso, elija una segura (una frase de paso es simplemente una contraseña en la que se permite la inclusión de espacios).

en: Now GPG will create a key for you, which can take a little bit of time; it needs random bytes, so if you give the system some work to do it will be just fine.  Move the cursor around, type some paragraphs of random text, load some web page.
es: Ahora GPG creará la clave, lo que le puede llevar un tiempo; necesita algunos bytes aleatorios, así que si le da al sistema algún trabajado para hacer, mejor. Mueva el cursor, escriba algunos párrafos de texto aleatorio o cargue alguna página web.

en: Once this is done, you will get a message similar to this one::
es: Una vez hecho esto, recibirá un mensaje similar a::

en: In this case ``43CDE61D`` is the *key ID*.
es: En este caso ``43CDE61D`` es el *ID de clave*.

en: Next, you need to upload the public part of your key to a keyserver so the world can identify messages and files as yours. To do so, enter::
es: Después necesitará cargar la parte pública de su clave a un servidor de claves, de forma que el resto del mundo pueda identificar los mensajes y archivos como suyos. Para hacerlo, escriba::

en: This will send your key to the Ubuntu keyserver, but a network of keyservers will automatically sync the key between themselves. Once this syncing is complete, your signed public key will be ready to verify your contributions around the world.
es: Esto mandará su clave al servidor de claves de Ubuntu, pero una red de servidores de claves la sincronizarán automáticamente entre ellos. Una vez que se complete esta sincronización, su clave pública firmada estará lista para verificar sus contribuciones por todo el mundo.

en: Create your SSH key
es: Crear su clave SSH

en: SSH_ stands for *Secure Shell*, and it is a protocol that allows you to exchange data in a secure way over a network. It is common to use SSH to access and open a shell on another computer, and to use it to securely transfer files. For our purposes, we will mainly be using SSH to securely upload source packages to Launchpad.
es: SSH_ viene de *Secure Shell* (intérprete de órdenes seguro) y es un protocolo que le permite intercambiar datos de una forma segura en una red. Es habitual usar SSH para acceder a un intérprete de órdenes en otro equipo y usarlo para transferir archivos de forma segura. Para nuestros propósitos, usaremos SSH básicamente para subir paquetes fuentes a Launchpad.

en: To generate an SSH key, enter::
es: Para generar una clave SSH, escriba::

en: The default file name usually makes sense, so you can just leave it as it is. For security purposes, it is highly recommended that you use a passphrase.
es: El nombre de archivo por defecto normalmente tiene sentido, así que puede dejarlo tal cual. Por motivos de seguridad, se recomienda encarecidamente que use una frase de paso.

en: Set up pbuilder
es: Configurar pbuilder

en: ``pbuilder`` allows you to build packages locally on your machine. It serves a couple of purposes:
es: ``pbuilder`` le permite compilar paquetes localmente en su equipo. Sirve para un par de propósitos:

en: The build will be done in a minimal and clean environment. This helps you make sure your builds succeed in a reproducible way, but without modifying your local system
es: La compilación se hará en un entorno mínimo y limpio. Esto le ayuda a asegurarse de que sus compilaciones se completan de una forma reproducible, pero sin modificar su sistema local.

en: There is no need to install all necessary *build dependencies* locally
es: No es necesario instalar todas las *dependencias de compilación* necesarias de forma local.

en: You can set up multiple instances for various Ubuntu and Debian releases
es: Puede configurar varias instancias para distintas versiones de Ubuntu y Debian.

en: Setting ``pbuilder`` up is very easy, run::
es: Configurar ``pbuilder`` es muy fácil, ejecute::

en: Get set up to work with Launchpad
es: Preparar una configuración para trabajar con Launchpad

en: With a basic local configuration in place, your next step will be to configure your system to work with Launchpad. This section will focus on the following topics:
es: Con una configuración local básica establecida, el siguiente paso será configurar el sistema para trabajar con Launchpad. Esta sección se centrará en los siguientes temas:

en: What Launchpad is and creating a Launchpad account
es: Qué es Launchpad y la creación de una cuenta de Launchpad

en: Uploading your GPG and SSH keys to Launchpad
es: Subir claves GPG y SSH a Launchpad

en: About Launchpad
es: Acerca de Launchpad

en: Launchpad is the central piece of infrastructure we use in Ubuntu. It not only stores our packages and our code, but also things like translations, bug reports, and information about the people who work on Ubuntu and their team memberships.  You will also use Launchpad to publish your proposed fixes, and get other Ubuntu developers to review and sponsor them.
es: Launchpad es la pieza central de la infraestructura usada en Ubuntu. No sólo almacena todos sus paquetes y código, sino también cosas tales como traducciones, informes de errores e información sobre la gente que trabaja en Ubuntu y su pertenencia a equipos. También usará Launchpad para publicar sus propuestas de solución y hacer que otros desarrolladores de Ubuntu las revisen y esponsoricen.

en: You will need to register with Launchpad and provide a minimal amount of information. This will allow you to download and upload code, submit bug reports, and more.
es: Necesitará registrarse en Launchpad y proporcionar una cantidad mínima de información. Esto le permitirá descargar y subir código, enviar informes de error y más cosas.

en: Besides hosting Ubuntu, Launchpad can host any Free Software project. For more information see the `Launchpad Help wiki <https://help.launchpad.net/>`_.
es: Además de hospedar a Ubuntu, Launchpad puede hospedar a cualquier otro proyecto de software libre. Para más información véase la `Launchpad Help wiki <https://help.launchpad.net/>`_.

en: Get a Launchpad account
es: Obtener una cuenta de Launchpad

en: Launchpad's registration process will ask you to choose a display name. It is encouraged for you to use your real name here so that your Ubuntu developer colleagues will be able to get to know you better.
es: El proceso de registro de Launchpad le pedirá que elija un nombre de usuario. Se recomienda que use su nombre real de forma que los colegas desarrolladores de Ubuntu lleguen a conocerle mejor.

en: When you register a new account, Launchpad will send you an email with a link you need to open in your browser in order to verify your email address. If you don't receive it, check in your spam folder.
es: Cuando registre una nueva cuenta, Launchpad le enviará un correo con un enlace que deberá abrir en su navegador para verificar su dirección de correo electrónico. Si no lo recibe, compruebe su carpeta de correo no deseado (spam).

en: Upload your GPG key to Launchpad
es: Subir su clave GPG a Launchpad

en: To find about your GPG fingerprint, run::
es: Para buscar su huella de GPG, ejecute::

en: and it will print out something like::
es: y le mostrará algo como::

en: Head to https://launchpad.net/~/+editpgpkeys and copy the "Key fingerprint" into the text box. In the case above this would be ``5C28 0144 FB08 91C0 2CF3  37AC 6F0B F90F 43CD E61D``. Now click on "Import Key".
es: Diríjase a https://launchpad.net/~/+editpgpkeys y copie la huella de la clave («Key fingerprint») en la casilla de texto. En el caso anterior sería ``5C28 0144 FB08 91C0 2CF3  37AC 6F0B F90F 43CD E61D``. Ahora pulse en «Import Key» (importar clave).

en: Launchpad will use the fingerprint to check the Ubuntu key server for your key and, if successful, send you an encrypted email asking you to confirm the key import. Check your email account and read the email that Launchpad sent you. `If your email client supports OpenPGP encryption, it will prompt you for the password you chose for the key when GPG generated it. Enter the password, then click the link to confirm that the key is yours.`
es: Launchpad usará la huella para comprobar su clave en el servidor de claves de Ubuntu. Si tiene éxito, le enviará un correo electrónico cifrado, pidiéndole que confirme la clave importada. Compruebe su cuenta de correo electrónico y lea el mensaje que le ha enviado Launchpad. `Si su cliente de correo electrónico soporta el cifrado de OpenPGP, le pedirá la contraseña que eligió para la clave cuando la generó GPG. Escriba la contraseña, y luego pulse en el enlace que confirma que esa clave es suya.`

en: Back on the Launchpad website, use the Confirm button and Launchpad will complete the import of your OpenPGP key.
es: De vuelta a la web de Launchpad, use el botón «Confirm» (confirmar) y Launchpad completará la importación de su clave OpenPGP.

en: Find more information at https://help.launchpad.net/YourAccount/ImportingYourPGPKey
es: Encuentre más información en https://help.launchpad.net/YourAccount/ImportingYourPGPKey

en: Upload your SSH key to Launchpad
es: Subir su clave SSH a Launchpad

en: Open https://launchpad.net/~/+editsshkeys in a web browser, also open ``~/.ssh/id_rsa.pub`` in a text editor. This is the public part of your SSH key, so it is safe to share it with Launchpad. Copy the contents of the file and paste them into the text box on the web page that says "Add an SSH key". Now click "Import Public Key".
es: Abra https://launchpad.net/~/+editsshkeys en su navegador web y abra también ``~/.ssh/id_rsa.pub`` en un editor de textos. Esta es la parte pública de su clave SSH, así que es seguro compartirla en Launchpad. Copie el contenido del archivo y péguelo en la casilla de texto de la página web que dice «Add an SSH key» (añadir una clave SSH). Ahora pulse «Import Public Key» (importar clave pública).

en: Configure your shell
es: Configurar el intérprete de órdenes

en: Now save the file and either restart your terminal or run::
es: Ahora guarde el archivo y reinicie su terminal o ejecute::

en: (If you do not use the default shell, which is `bash`, please edit the configuration file for that shell accordingly.)
es: (si no usa el intérprete de órdenes por defecto, que es `bash`, edite el archivo de configuración de dicho intérprete como corresponda).

en: Ubuntu Packaging Guide
es: Guía de empaquetado de Ubuntu

en: Ubuntu is not only a free and open source operating system, its platform is also open and developed in a transparent fashion. The source code for every single component can be obtained easily and every single change to the Ubuntu platform can be reviewed.
es: Ubuntu no solo un sistema operativo libre, gratuito y de código abierto, su plataforma también es abierta y está desarrollada de forma transparente. El código fuente para cada uno de los componentes se puede obtener fácilmente y todos los cambios realizados a la plataforma de Ubuntu pueden ser revisados.

en: This means you can actively get involved in improving it and the community of Ubuntu platform developers is always interested in helping peers getting started.
es: Esto significa que puede involucrarse activamente en mejorarlo y que la comunidad de desarrolladores de la plataforma de Ubuntu está siempre interesada en ayudar a las personas que comienzan.

en: Ubuntu is also a community of great people who believe in free software and that it should be accessible for everyone. Its members are welcoming and want you to be involved as well. We want you to get involved, to ask questions, to make Ubuntu better together with us.
es: Ubuntu es además una comunidad de personas estupendas que creen en el software libre y que éste debería estar accesible para todos. Sus miembros son amigables y quieren que se una. Queremos que se involucre, que realice preguntas, que ayude a hacer Ubuntu mejor junto a nosotros.

en: If you run into problems: don't panic! Check out the :doc:`communication article<./communication>` and you will find out how to most easily get in touch with other developers.
es: Si se topa con un problema: ¡no se preocupe! Consulte el :doc:`artículo sobre comunicación<./communication>` y sabrá cómo puede contactar a otros desarrolladores fácilmente.

en: The guide is split up into two sections:
es: La guía está separada en dos secciones:

en: A list of articles based on tasks, things you want to get done.
es: Una lista de artículos basados en tareas, cosas que puede desear que se hagan.

en: A set of knowledge-base articles that dig deeper into specific bits of our tools and workflows.
es: Un conjunto de artículos de la base de conocimientos que profundizan en partes especificas de las herramientas y flujos de trabajo.

en: Articles
es: Artículos

en: Knowledge Base
es: Base de conocimiento

en: Further Reading
es: Lecturas adicionales

en: If you want to learn more about building Debian packages, here are some Debian resources you may find useful:
es: Si quiere conocer más sobre la construcción de paquetes Debian, aquí tiene algunos recursos Debian que pueden resultarle útiles:

en: Introduction to Ubuntu Development
es: Introducción al desarrollo de Ubuntu

en: Ubuntu is made up of thousands of different components, written in many different programming languages. Every component -  be it a software library, a tool or a graphical application - is available as a source package. Source packages in most cases consist of two parts: the actual source code and metadata. Metadata includes the dependencies of the package, copyright and licensing information, and instructions on how to build the package. Once this source package is compiled, the build process provides binary packages, which are the .deb files users can install.
es: Ubuntu está formado por miles de componentes distintos, escritos en muchos lenguajes de programación diferentes. Cada componente, ya sea una biblioteca software, una herramienta o una aplicación gráfica, está disponible en forma de paquete fuente. Los paquetes fuente, en la mayoría de los casos, constan de dos partes: el código fuente en sí, y los metadatos. Los metadatos incluyen las dependencias del paquete, los derechos de autor e información sobre la licencia e instrucciones sobre cómo compilar el paquete. Una vez que el paquete está compilado, el proceso de construcción proporciona los paquetes binarios, que son los archivos .deb que el usuario puede instalar.

en: Ubuntu's development is very much dependent on the current stage of the release cycle. We release a new version of Ubuntu every six months, which is only possible because we have established strict freeze dates. With every freeze date that is reached developers are expected to make fewer, less intrusive changes. Feature Freeze is the first big freeze date after the first half of the cycle has passed. At this stage features must be largely implemented. The rest of the cycle is supposed to be focused on fixing bugs. After that the user interface, then the documentation, the kernel, etc. are frozen, then the beta release is put out which receives a lot of testing. From the beta release onwards, only critical bugs get fixed and a release candidate release is made and if it does not contain any serious problems, it becomes the final release.
es: El desarrollo de Ubuntu depende en gran medida de la fase actual del ciclo de publicación. Se publica una nueva versión de Ubuntu cada seis meses, lo que solo es posible porque se han establecido fechas estrictas de congelación. Con cada fecha de congelación que se va alcanzando, los desarrolladores esperan hacer menos cambios y menos intrusivos. La congelación de funciones («feature freeze») es la primera gran fecha de congelación después de haber pasado la primera mitad del ciclo. En esta fase, las funciones deben estar ya prácticamente implementadas. El resto del ciclo se supone que se centrará en corregir errores. Después de que la interfaz de usuario, la documentación, el núcleo, etc. se congelan, se publica una versión beta que pasa gran cantidad de pruebas. De la versión beta en adelante, solo se corrigen errores críticos y se publica la versión candidata, la cual, si no contiene ningún problema serio, es la que se convierte en la versión definitiva.

en: Thousands of source packages, billions of lines of code, hundreds of contributors require a lot of communication and planning to maintain high standards of quality. At the beginning and in the middle of each release cycle we have the Ubuntu Developer Summit where developers and contributors come together to plan the features of the next releases. Every feature is discussed by its stakeholders and a specification is written that contains detailed information about its assumptions, implementation, the necessary changes in other places, how to test it and so on. This is all done in an open and transparent fashion, so you can participate remotely and listen to a videocast, chat with attendants and subscribe to changes of specifications, so you are always up to date.
es: Miles de los paquetes fuente, miles de millones de líneas de código, cientos de contribuyentes requieren de mucha comunicación y planificación para mantener altos estándares de calidad. Al principio y hacia la mitad de cada ciclo de emisión tiene lugar la «Ubuntu Developer Summit» (cumbre de desarrolladores de Ubuntu) en la que los desarrolladores y contribuyentes se juntan para planificar las características de las próximas versiones. Cada característica es discutida por sus accionistas y se escribe una especificación que contiene información detallada sobre sus supuestos, implementación, cambios necesarios en otras partes, cómo probarla y así sucesivamente. Todo esto se hace de forma abierta y transparente, así que puede participar remotamente y escuchar una transmisión de vídeo, chalar con los asistentes y suscribirse a cambios en las especificaciones, de forma que siempre esté al día.

en: Not every single change can be discussed in a meeting though, particularly because Ubuntu relies on changes that are done in other projects. That is why contributors to Ubuntu constantly stay in touch. Most teams or projects use dedicated mailing lists to avoid too much unrelated noise. For more immediate coordination, developers and contributors use Internet Relay Chat (IRC). All discussions are open and public.
es: Sin embargo, no todos los cambios pueden ser discutidos en una reunión, particularmente porque Ubuntu depende de cambios que se hacen en otros proyectos. Es por esto que los contribuyentes se mantienen en contacto permanente. La mayoría de los equipos o proyectos usan listas de correo dedicadas para evitar demasiado ruido no relacionado. Para una coordinación más inmediata, los desarrolladores y contribuyentes usan charlas en IRC («Internet Relay Chat»). Todas las discusiones son abiertas y públicas.

en: Another important tool regarding communication is bug reports. Whenever a defect is found in a package or piece of infrastructure, a bug report is filed in Launchpad. All information is collected in that report and its importance, status and assignee updated when necessary. This makes it an effective tool to stay on top of bugs in a package or project and organise the workload.
es: Otra herramienta importante relacionada con la comunicación son los informes de errores. Siempre que se encuentra un error en un paquete o en un parte de la infraestructura, se rellena un informe de error en Launchpad. Se recoge toda la información en dicho informe y se actualiza cuando sea necesario su importancia, estado y desarrollador asignado. Esto lo convierte en una herramienta efectiva para mantenerse al día de los errores de un paquete o proyecto y para organizar la carga de trabajo.

en: Most of the software available through Ubuntu is not written by Ubuntu developers themselves. Most of it is written by developers of other Open Source projects and then integrated into Ubuntu. These projects are called "Upstreams", because their source code flows into Ubuntu, where we "just" integrate it. The relationship to Upstreams is critically important to Ubuntu. It is not just code that Ubuntu gets from Upstreams, but it is also that Upstreams get users, bug reports and patches from Ubuntu (and other distributions).
es: La mayoría del software disponible a través de Ubuntu no está escrito por los propios desarrolladores de Ubuntu. La mayoría está escrito por otros desarrolladores de otros proyectos de código abierto que luego son integrados en Ubuntu. Estos proyectos se denominan «upstreams» (aguas arriba), porque su código fuente fluye a Ubuntu, donde «simplemente» se integra. La relación con los proyectos «upstream» tiene una importancia crítica para Ubuntu. No es solo código lo que Ubuntu recoge aguas arriba, sino que los proyectos «upstream» obtienen también usuarios, informes de error y parches de Ubuntu (y de otras distribuciones).

en: The most important Upstream for Ubuntu is Debian. Debian is the distribution that Ubuntu is based on and many of the design decisions regarding the packaging infrastructure are made there. Traditionally, Debian has always had dedicated maintainers for every single package or dedicated maintenance teams. In Ubuntu there are teams that have an interest in a subset of packages too, and naturally every developer has a special area of expertise, but participation (and upload rights) generally is open to everyone who demonstrates ability and willingness.
es: El proyecto «upstream» más importante para Ubuntu es Debian. Debian es la distribución en la que se basa Ubuntu y muchas de las decisiones de diseño relativas a la infraestructura de empaquetado se hacen allí. Traicionalmente, Debian ha tenido siempre mantenedores dedicados para cada paquete individual o equipos dedicados de mantenimiento. En Ubuntu hay equipos que tienen interés en un subconjunto de paquetes también y, naturalmente, cada desarrollador tiene un área de especialización, pero la participación (y permisos de subida) está generalmente abierta a cualquiera que demuestre capacidad y voluntad.

en: Getting a change into Ubuntu as a new contributor is not as daunting as it seems and can be a very rewarding experience. It is not only about learning something new and exciting, but also about sharing the solution and solving a problem for millions of users out there.
es: Conseguir un cambio en Ubuntu como un nuevo contribuyente no es tan desalentador como parece y puede resultar una experiencia muy gratificante. No se trata únicamente de aprender algo nuevo y excitante, sino también de compartir la solución y resolver un problema para millones de otros usuarios.

en: Open Source Development happens in a distributed world with different goals and different areas of focus. For example there might be the case that a particular Upstream is interested in working on a new big feature while Ubuntu, because of the tight release schedule, is interested in shipping a solid version with just an additional bug fix. That is why we make use of "Distributed Development", where code is being worked on in various branches that are merged with each other after code reviews and sufficient discussion.
es: Los desarrollos de código abierto se producen en un mundo distribuido con distintos objetivos diferentes y con áreas de interés diferentes. Por ejemplo, podría darse el caso de que alguien aguas arriba («upstream») esté interesado en trabajar en una nueva funcionalidad importante mientras que Ubuntu, debido a su estricta planificación de emisiones, está interesado en distribuir una versión sólida solo con algunas correcciones de errores. Es por ello que se usa el «desarrollo distribuido», en el que se trabaja en distintas ramas de código que son combinadas con las demás después de revisiones de código y suficientes discusiones.

en: In the example mentioned above it would make sense to ship Ubuntu with the existing version of the project, add the bugfix, get it into Upstream for their next release and ship that (if suitable) in the next Ubuntu release. It would be the best possible compromise and a situation where everybody wins.
es: En el ejemplo mencionado anteriormente tendría sentido emitir Ubuntu con una versión existente del proyecto, añadir la corrección del error, integrarla aguas arriba («upstream») para su próxima emisión y distribuirla (si fuera conveniente) en la próxima emisión de Ubuntu. Sería el mejor compromiso posible y una situación en la que todo el mundo gana.

en: To fix a bug in Ubuntu, you would first get the source code for the package, then work on the fix, document it so it is easy to understand for other developers and users, then build the package to test it. After you have tested it, you can easily propose the change to be included in the current Ubuntu development release. A developer with upload rights will review it for you and then get it integrated into Ubuntu.
es: Para arreglar un error en Ubuntu, primero debería obtener el código fuente del paquete, después trabajar en la solución, documentarla de forma que sea fácil de entender por otros desarrolladores y usuarios y luego compilar el paquete para probarlo. Una vez lo haya probado, puede proponer fácilmente que el cambio se incluya en la publicación actualmente en desarrollo de Ubuntu. Un desarrollador con permisos para subir el código lo revisará y hará que se integre en Ubuntu.

en: When trying to find a solution it is usually a good idea to check with Upstream and see if the problem (or a possible solution) is known already and, if not, do your best to make the solution a concerted effort.
es: Cuando intente encontrar una solución, habitualmente es una buena idea comprobar los proyectos aguas arriba («upstreams») para ver si el problema (o una posible solución) es conocido y, si no, hacer lo posible para que la solución sea un esfuerzo concertado.

en: Additional steps might involve getting the change backported to an older, still supported version of Ubuntu and forwarding it to Upstream.
es: Podrían ser necesarios pasos adicionales para hacer que el cambio se incluya en una versión antigua, aunque todavía soportada de Ubuntu, y enviarlo aguas arriba («upstream»).

en: The most important requirements for success in Ubuntu development are: having a knack for "making things work again," not being afraid to read documentation and ask questions, being a team player and enjoying some detective work.
es: Los requisitos más importantes para tener éxito en el desarrollo de Ubuntu son: tener una habilidad especial para «hacer que las cosas funcionen de nuevo», no tener miedo a leer documentación y a hacer preguntas, ser un jugador de equipo y disfrutar con algo de trabajo detectivesco.

en: KDE Packaging
es: Empaquetado de KDE

en: Patching Policy
es: Política de parches

en: Kubuntu does not add patches to KDE programs unless they come from the upstream authors or submitted upstream with the expectation they will be merged soon or we have consulted the issue with the upstream authors.
es: Kubuntu no añade parches a los programas KDE a menos que vengan de los autores aguas arriba o se hayan enviado aguas arriba con la expectativa de que sean combinados pronto o hayamos consultado la incidencia con los autores aguas arriba.

en: Kubuntu does not change the branding of packages except where upstream expects this (such as the top left logo of the Kickoff menu) or to simplify (such as removing splash screens).
es: Kubuntu no cambia la marca de los paquetes excepto cuando aguas arriba esperan que se haga (por ejemplo, el logotipo de la parte inferior izquierda del menú de inicio) o para simplificar (por ejemplo, eliminar las pantallas iniciales).

en: Debian packages include some additions to the basic Debhelper usage. These are kept in the ``pkg-kde-tools`` package.
es: Los paquetes de Debian incluyen algunos añadidos al uso básico de Debhelper. Estos añadidos se mantienen en el paquete ``pkg-kde-tools``.

en: Packages which use Debhelper 7 should add the ``--with=kde`` option. This will ensure the correct build flags are used and add options such as handling kdeinit stubs and translations::
es: Los paquetes que usan Debhelper 7 deberían añadir la opción ``--with=kde``. Esto asegurará que se usan los marcadores de compilación adecuados y que se añaden opciones como la gestión de los «stubs» de kdeinit y las traducciones::

en: Some newer KDE packages use the ``dhmk`` system, an alternative to ``dh`` made by the Debian Qt/KDE team.  You can read about it in /usr/share/pkg-kde-tools/qt-kde-team/2/README.  Packages using this will ``include /usr/share/pkg-kde-tools/qt-kde-team/2/debian-qt-kde.mk`` instead of running ``dh``.
es: Algunos paquetes más modernos de KDE usan el sistema ``dhmk``, una alternativa a ``dh`` desarrollada por el equipo QT/KDE de Debian. Puede leer sobre el mismo en /usr/share/pkg-kde-tools/qt-kde-team/2/README. Los paquetes que lo usen incluirán ``include /usr/share/pkg-kde-tools/qt-kde-team/2/debian-qt-kde.mk`` en lugar de ejecutar ``dh``.

en: Translations
es: Traducciones

en: Packages in main have their translations imported into Launchpad and exported from Launchpad into Ubuntu's language-packs.
es: Las traducciones de los paquetes de «main» en se importan en Launchpad y se exportan de Launchpad a los paquetes de idiomas de Ubuntu.

en: So any KDE package in main must generate translation templates, include or make available upstream translations and handle ``.desktop`` file translations.
es: Así que todos los paquetes de «main» de KDE deben generar plantillas de traducción, incluir o hacer disponibles aguas arriba las traducciones y gestionar los archivos ``.desktop`` de traducciones.

en: To generate translation templates the package must include a ``Messages.sh`` file; complain to the upstream if it does not.  You can check it works by running ``extract-messages.sh`` which should produce one or more ``.pot`` files in ``po/``.  This will be done automatically during build if you use the ``--with=kde`` option to ``dh``.
es: Para generar las plantillas de traducción el paquete debe incluir un archivo ``Messages.sh``; quéjese aguas arriba si no lo hace. Puede comprobar si funciona ejecutando ``extract-messages.sh`` lo que debería producir uno o más archivos ``.pot`` en el directorio ``po/``. Esto se hará automáticamente durante la compilación si usa la opción ``--with=kde`` de ``dh``.

en: If a package is moved from universe to main it will need to be re-uploaded before the translations get imported into Launchpad.
es: Si un paquete se mueve desde «universe» a «main» tendrá que ser vuelto a subir antes de que las traducciones se importen en Launchpad.

en: ``.desktop`` files also need translations.  We patch KDELibs to read translations out of ``.po`` files which are pointed to by a line ``X-Ubuntu-Gettext-Domain=`` added to ``.desktop`` files at package build time.  A .pot file for each package is be generated at build time and .po files need to be downloaded from upstream and included in the package or in our language packs.  The list of .po files to be downloaded from KDE's repositories is in ``/usr/lib/kubuntu-desktop-i18n/desktop-template-list``.
es: Los archivos ``.desktop`` también necesitan traducciones. Se parchea KDELibs para que lea las traducciones de los archivos ``.po`` que están apuntados por una línea ``X-Ubuntu-Gettext-Domain=`` añadida a los archivos ``.desktop`` en el momento de compilar el paquete. Se genera un archivo .pot para cada paquete en el momento de la compilación y los archivos .po necesarios se descargan desde aguas arriba y se incluyen en el paquete o en los paquetes de idiomas. La lista de archivos .po a descargar de los repositorios de KDE está en ``/usr/lib/kubuntu-desktop-i18n/desktop-template-list``.

en: Library Symbols
es: Símbolos de biblioteca

en: Shared Libraries
es: Bibliotecas compartidas

en: Shared libraries are compiled code which is intended to be shared among several different programs.  They are distributed as ``.so`` files in ``/usr/lib/``.
es: Las bibliotecas compartidas es código compilado que se supone que será compartido por diferentes programas. Se distribuyen como archivos ``.so`` en ``/usr/lib/``.

en: A library exports symbols which are the compiled versions of functions, classes and variables.  A library has a name called an SONAME which includes a version number.  This SONAME version does not necessarily match the public release version number.  A program gets compiled against a given SONAME version of the library.  If any of the symbols is removed or changes then the version number needs to be changed which forces any packages using that library to be recompiled against the new version.  Version numbers are usually set by upstream and we follow them in our binary package names called an ABI number, but sometimes upstreams do not use sensible version numbers and packagers have to keep separate version numbers.
es: Una biblioteca exporta símbolos que son versiones compiladas de funciones, clases y variables. Una biblioteca tiene un nombre denominado SONAME que incluye un número de versión. Esta versión de SONAME no tiene por qué coincidir con el número de versión de emisión pública. Un programa se compila contra una versión determinada de SONAME de la biblioteca. Si cualquiera de los símbolos es eliminado o modificado, entonces el número de versión debe ser cambiado lo que fuerza que que cualquier paquete que use la biblioteca sea recompilado contra la nueva versión. Los números de versiones normalmente son establecidos aguas arriba y los mantenemos en los nombres de los paquetes binarios, llamado número ABI, pero en ocasiones aguas arriba no usan números de versiones razonables y los empaquetadores tienen que mantener números de versiones separados.

en: Libraries are usually distributed by upstream as standalone releases. Sometimes they are distributed as part of a program.  In this case they can be included in the binary package along with the program (this is called bundling) if you do not expect any other programs to use the library, more often they should be split out into separate binary packages.
es: Las bibliotecas se distribuyen normalmente aguas arriba como emisiones independientes. Algunas veces se distribuyen como partes de un programa. En este caso se pueden incluir en el paquete binario junto con el programa (esto se denomina «bundling», atado) si no espera que ningún otro programa use la biblioteca, pero lo más frecuente es que sean separadas en paquetes binarios independientes.

en: The libraries themselves are put into a binary package named ``libfoo1`` where ``foo`` is the name of the library and ``1`` is the version from the SONAME. Development files from the package, such as header files, needed to compile programs against the library are put into a package called ``libfoo-dev``.
es: Las propias bibliotecas se meten en un paquete binario llamado ``libfoo1`` donde ``foo`` es el nombre de la biblioteca y ``1`` es la versión del SONAME. Los archivos de desarrollo del paquete, como los archivos de cabecera, necesitan compilar programas contra la biblioteca que se ha metido en el paquete llamado ``libfoo-dev``.

en: An Example
es: Un ejemplo

en: We will use libnova as an example::
es: Usaremos libnova como un ejemplo::

en: To find the SONAME of the library run::
es: Para encontrar el SONAME de una biblioteca ejecute::

en: The SONAME is ``libnova-0.12.so.2``, which matches the file name (usually the case but not always). Here upstream has put the upstream version number as part of the SONAME and given it an ABI version of ``2``.  Library package names should follow the SONAME of the library they contain. The library binary package is called ``libnova-0.12-2`` where ``libnova-0.12`` is the name of the library and ``2`` is our ABI number.
es: El SONAME es ``libnova-0.12.so.2``, lo que coincide con el nombre del archivo (es lo normal, pero no siempre ocurre). En este caso aguas arriba han puesto el número de versión como parte del SONAME y le han dado una versión ABI de ``2``. Los nombres de paquetes de bibliotecas deberían seguir el SONAME de la biblioteca que contienen. El paquete binario de la biblioteca se llama ``libnova--0.12-2``, donde ``libnova-0.12`` es el nombre de la biblioteca y ``2`` es nuestro número ABI.

en: If upstream makes incompatible changes to their library they will have to reversion their SONAME and we will have to rename our library.  Any other packages using our library package will need to recompiled against the new version, this is called a transition and can take some effort. Hopefully our ABI number will continue to match upstream's SONAME but sometimes they introduce incompatibilities without changing their version number and we will need to change ours.
es: SI aguas arriban hacen cambios incompatible a su biblioteca tendrá que revisionar su SONAME y nosotros tendremos que cambiar de nombre a nuestra biblioteca. Cualquier otro paquete que use nuestra biblioteca deberá ser recompilado contra la nueva versión, esto es lo que se llama una transición y puede suponer cierto esfuerzo. Afortunadamente nuestro número ABI seguirá coincidiendo con el SONAME de aguas arriba, pero en ocasiones se introducen incompatibilidades sin cambiar el número de versión lo que nos fuerza a hacer cambios en el nuestro.

en: Looking in debian/libnova-0.12-2.install we see it includes two files::
es: Si miramos en debian/libnova-0.12-2.install vemos que incluye estos dos archivos::

en: The last one is the actual library, complete with minor and point version number.  The first one is a symlink which points to the actual library.  The symlink is what programs using the library will look for, the running programs do not care about the minor version number.
es: El último es la biblioteca en sí, completada con el número de menor de la versión y punto. El primero es un enlace simbólico que apunta a la biblioteca real. El enlace simbólico es lo que buscarán los programas que empleen la biblioteca, ya que los programas que se ejecutan no se preocupan por el número de menor de la versión.

en: ``libnova-dev.install`` includes all the files needed to compile a program with this library.  Header files, a config binary, the ``.la`` libtool file and ``libnova.so`` which is another symlink pointing at the library, programs compiling against the library do not care about the major version number (although the binary they compile into will).
es: ``libnova-dev.install`` incluye todo los archivos necesarios para compilar un programa con esta biblioteca. Los archivo de cabeceras, una configuración binaria, el archivo ``.la`` de libtool y ``libnova.so`` que es otro enlace simbólico apuntando a la misma biblioteca, programas compilados contra la biblioteca no se preocupan del número mayor de la versión (aunque el binario en el que se compilarán sí lo hará).

en: Static Libraries
es: Bibliotecas estáticas

en: The -dev package also ships ``usr/lib/libnova.a``.  This is a static library, an alternative to the shared library.  Any program compiled against the static library will include the code directory into itself.  This gets round worrying about binary compatibility of the library.  However it also means that any bugs, including security issues, will not be updated along with the library until the program is recompiled.  For this reason programs using static libraries are discouraged.
es: El paquete -dev también incluye ``usr/lib/libnova.a``. Es una biblioteca estática, una alternativa a las librerías compartidas. Cualquier programa compilado contra una biblioteca estática incluya el directorio de código dentro de sí mismo. Esto evita tener que preocuparse sobre la compatibilidad binaria de la biblioteca. Sin embargo, también significa que cualquier error, incluyendo las incidencias de seguridad, no serán actualizados junto con la biblioteca hasta que se recompile el programa. Por esta razón se desaconseja el uso de programas  que usen librerías estáticas.

en: Symbol Files
es: Archivos de símbolos

en: When a package builds against a library the ``shlibs`` mechanism will add a package dependency on that library.  This is why most programs will have ``Depends: ${shlibs:Depends}`` in ``debian/control``.  That gets replaced with the library dependencies at build time.  However shlibs can only make it depend on the major ABI version number, ``2`` in our libnova example, so if new symbols get added in libnova 2.1 a program using these symbols could still be installed against libnova ABI 2.0 which would then crash.
es: Cuando un paquete se compila contra una biblioteca el mecanismo de ``shlibs`` añadirá una dependencia del paquete a esa biblioteca. Este es el motivo de que la mayoría de los programas tengan ``Depends: ${shlibs:Depends}`` en el archivo ``debian/control``. Eso se sustituye por las dependencias de la biblioteca en tiempo de compilación. Sin embargo, shlibs solo puede hacerla depender del número mayor de versión ABI, ``2`` en el ejemplo, así que si se añaden nuevos símbolos a libnova 2.1 un programa que use estos símbolos podría todavía seguir instalado contra libnova ABI 2.0, lo que podría producir un fallo.

en: To make the library dependencies more precise we keep ``.symbols`` files that list all the symbols in a library and the version they appeared in.
es: Para hacer más precisas las dependencias de las bibliotecas matenemos archivos ``.symbols`` que listan todos los símbolos de una librería y la versión en la que aparecen.

en: libnova has no symbols file so we can create one.  Start by compiling the package::
es: libnova no tiene archivo de símbolos así que podemos crear uno. Comience por compilar el paquete::

en: The ``-nc`` will cause it to finish at the end of compilation without removing the built files.  Change to the build and run ``dpkg-gensymbols`` for the library package::
es: La opción ``-nc`` hará que se finalice al completar la compilación sin que se eliminen los archivos compilados. Cámbiese al directorio compilado y ejecute ``dpkg-gensymbols`` para el paquete de la biblioteca::

en: This makes a diff file which you can self apply::
es: Esto genera un archivo de diferencias (diff) que puede aplicar::

en: Which will create a file named similar to ``dpkg-gensymbolsnY_WWI`` that lists all the symbols.  It also lists the current package version.  We can remove the packaging version from that listed in the symbols file because new symbols are not generally added by new packaging versions, but by the upstream developers::
es: Lo que creará un archivo con un nombre similar a ``dpkg-gensymbolsnY_WWI`` que lista todos los símbolos. También lista la versión de paquete actual. Podemos eliminar la versión de empaquetado que se lista en el archivo de símbolos porque generalmente no se añaden nuevos símbolos por versiones más modernas de empaquetado, sino por los desarrolladores aguas arriba::

en: Now move the file into its location, commit and do a test build::
es: Ahora mueva el archivo a su ubicación, confirme y haga una prueba de compilación::

en: If it successfully compiles the symbols file is correct.  With the next upstream version of libnova you would run dpkg-gensymbols again and it will give a diff to update the symbols file.
es: Si compila con éxito es que el archivo de símbolos es correcto. Con la siguiente versión aguas arriba de libnova podría ejecutar de nuevo dpkg-gensymbols  y obtendrá un archivo de diferencias para actualizar el archivo de símbolos.

en: C++ Library Symbols Files
es: Archivos de símbolos de bibliotecas de C++

en: Packaging New Software
es: Empaquetando nuevo software

en: While there are thousands of packages in the Ubuntu archive, there are still a lot nobody has gotten to yet. If there is an exciting new piece of software that you feel needs wider exposure, maybe you want to try your hand at creating a package for Ubuntu or a PPA_. This guide will take you through the steps of packaging new software.
es: A pesar de que hay miles de paquetes en el repositorio de Ubuntu, todavía hay muchos que nadie ha conseguido. Si hay una nueva y excitante porción de software que siente que necesita una exposición más amplia, quizá quiera intentar crear un paquete para Ubuntu o un PPA_. Esta guía le acompañará a través de los pasos del empaquetado de nuevo software.

en: You will want to read the :doc:`Getting Set Up<./getting-set-up>` article first in order to prepare your development environment.
es: Probablemente quiera leer el artículo :doc:`Getting Set Up<./getting-set-up>` antes para preparar su entorno de desarrollo.

en: Checking the Program
es: Comprobar el programa

en: The first stage in packaging is to get the released tar from upstream (we call the authors of applications "upstream") and check that it compiles and runs.
es: La primera fase del empaquetado es obtener el archivo tar liberado aguas arriba (llamamos a los autores de las aplicación aguas arriba, «upstream») y comprobar que compila y se ejecuta.

en: This guide will take you through packaging a simple application called GNU Hello which has been posted on GNU.org_.
es: Esta guía le llevará a través del empaquetado de una aplicación sencilla llamada GNU Hello, la cual ha sido publicada en GNU.org_.

en: This application uses the autoconf build system so we want to run ``./configure`` to prepare for compilation.
es: Esta aplicación usa el sistema de compilación autoconf, así que debemos ejecutar «./configure» para preparar la compilación.

en: This will check for the required build dependencies. As ``hello`` is a simple example, ``build-essential`` should provide everything we need. For more complex programs, the command will fail if you do not have the needed libraries and development files. Install the needed packages and repeat until the command runs successfully.::
es: Esto comprobará las dependencias de compilación necesarias. Como ``hello`` es un ejemplo sencillo, ``build-essential`` debería proporcionar todo lo que necesitamos. Para programas más complejos, la orden fallará si no tiene las bibliotecas y archivos de desarrollo necesarios. Instale los paquetes necesarios y repita hasta que la orden se ejecute correctamente.::

en: Now you can compile the source::
es: Ahora puede compilar el fuente::

en: If compilation completes successfully you can install and run the program::
es: Si la compilación finaliza con éxito puede instalar y ejecutar el programa::

en: Starting a Package
es: Iniciar un paquete

en: When it asks what type of package type ``s`` for single binary. This will import the code into a branch and add the ``debian/`` packaging directory.  Have a look at the contents.  Most of the files it adds are only needed for specialist packages (such as Emacs modules) so you can start by removing the optional example files::
es: Cuando pregunte por el tipo de paquete escriba ``s`` para binario simple. Esto importará el código en u n rama y añadirá el directorio de empaquetado ``debian/``. Eche un vistazo al contenido. La mayoría de los archivos que añade son sólo necesarios para paquetes especialistas (como los módulos de Emacs) así que puede comenzar por eliminar los archivos de ejemplo opcionales::

en: You should now customise each of the files.
es: Ahora debería personalizar cada uno de los archivos.

en: Much of the package building work is done by a series of scripts called ``debhelper``.  The exact behaviour of ``debhelper`` changes with new major versions, the compat file instructs ``debhelper`` which version to act as.  You will generally want to set this to the most recent version which is ``9``.
es: Mucho del trabajo de compilación de paquetes se hace mediante una serie de scripts llamados ``debhelper``. El comportamiento exacto de ``debhelper`` cambia con las nuevas versiones mayores y el archivo de compatibilidad instruye a ``debhelper`` sobre la versión como la que debe comportarse. Generalmente querrá establecerla a la versión más reciente, que es la ``9``.

en: ``control`` contains all the metadata of the package.  The first paragraph describes the source package. The second and following paragraphs describe the binary packages to be built.  We will need to add the packages needed to compile the application to ``Build-Depends:``. For ``hello``, make sure that it includes at least::
es: ``control`` contiene todos los metadatos del paquete. El primer párrafo describe el paquete fuente. El segundo y siguientes describen los paquetes binarios a construir. Necesitaremos añadir los paquetes necesarios para compilar la aplicación a ``Build-Depends:``. Para ``hello``, asegúrese de que incluye al menos::

en: You will also need to fill in a description of the program in the ``Description:`` field.
es: También necesitará rellenar la descripción del programa en el campo ``Description:``.

en: ``copyright`` needs to be filled in to follow the licence of the upstream source.  According to the hello/COPYING file this is GNU GPL 3 or later.
es: Debe rellenar ``copyright`` para que siga la licencia de los fuentes aguas arriba. Según el archivo hello/COPYING es GNU GPL 3 o superior.

en: ``docs`` contains any upstream documentation files you think should be included in the final package.
es: ``docs`` contiene cualquier archivo de documentación de aguas arriba que piense que debería ser incluido en el paquete final.

en: ``README.source`` and ``README.Debian`` are only needed if your package has any non-standard features, we don't so you can delete them.
es: ``README.source`` y ``README.Debian`` solo son necesarios si su paquete tiene características no estándar. No las tiene, así que se pueden borrar.

en: ``source/format`` can be left as is, this describes the version format of the source package and should be ``3.0 (quilt)``.
es: ``source/format`` se puede dejar como está. Describe el formato de la versión del paquete fuente y debería ser ``3.0 (quilt)``.

en: ``rules`` is the most complex file.  This is a Makefile which compiles the code and turns it into a binary package.  Fortunately most of the work is automatically done these days by ``debhelper 7`` so the universal ``%`` Makefile target just runs the ``dh`` script which will run everything needed.
es: ``rules`` es el archivo más complejo. Es un Makefile que compila el código y lo convierte en un paquete binario. Afortunadamente la mayor parte del trabajo hoy en día se realiza automáticamente por ``debhelper 7`` así que el objetivo Makefile ``%`` universal simplemente ejecuta el script ``dh`` que a su vez ejecutará todo lo que haga falta.

en: All of these file are explained in more detail in the :doc:`overview of the debian directory<./debian-dir-overview>` article.
es: Todos estos archivos se explican con más detalle en el artículo :doc:`resumen del directorio debian<./debian-dir-overview>`.

en: Finally commit the code to your packaging branch::
es: Finalmente confirme el código en su rama de empaquetado::

en: Building the package
es: Construir el paquete

en: Now we need to check that our packaging successfully compiles the package and builds the .deb binary package::
es: Ahora necesitamos comprobar que el empaquetado compila con éxito el paquete y genera el paquete binario .deb::

en: ``bzr builddeb`` is a command to build the package in its current location. The ``-us -uc`` tell it there is no need to GPG sign the package.  The result will be placed in ``..``.
es: ``bzr builddeb`` es una orden para compilar el paquete en su ubicación actual. Los parámetros ``-us -uc`` le indicarán que no es necesario firmar con GPG el paquete. El resultado se dejará en ``..``.

en: You can view the contents of the package with::
es: Puede ver el contenido del paquete con::

en: Next Steps
es: Siguientes pasos

en: After making a fix to the packaging you can rebuild using ``-nc`` "no clean" without having to build from scratch::
es: Después de realizar una corrección al empaquetado puede reconstruirlo usando la opción ``-nc`` («no clean», sin limpiar) para no tener que compilarlo desde el principio::

en: Having checked that the package builds locally you should ensure it builds on a clean system using ``pbuilder``. Since we are going to upload to a PPA (Personal Package Archive) shortly, this upload will need to be *signed* to allow Launchpad to verify that the upload comes from you (you can tell the upload will be signed because the ``-us`` and ``-uc`` flags are not passed to ``bzr builddeb`` like they were before). For signing to work you need to have set up GPG. If you haven't set up ``pbuilder-dist`` or GPG yet, :doc:`do so now<./getting-set-up>`::
es: Después de comprobar que el paquete se compila en local debería asegurarse de que lo hace también en un sistema limpio usando ``pbuilder``. Puesto que se va a subir en breve a un PPA (archivo de paquetes personal), esta proceso de subida deberá ser *firmado* para permitir a Launchpad que verifique que la carga proviene de usted (puede saber que la carga se firmará porque no se pasan los marcadores ``-us`` y ``-uc`` a ``bzr builddeb`` como se hizo antes). Para firmar su trabajo necesita haber configurado GPG. Si no ha configurado todavía ``pbuilder-dist`` o GPG todavía, :doc:`do so now<./getting-set-up>`::

en: When you are happy with your package you will want others to review it.  You can upload the branch to Launchpad for review::
es: Cuando esté satisfecho con su paquete deseará que otros lo revisen. Puede subirlo la rama a Launchpad para su revisión::

en: Uploading it to a PPA will ensure it builds and give an easy way for you and others to test the binary packages.  You will need to set up a PPA in Launchpad and then upload with ``dput``::
es: Al subirlo a un PPA se asegurará de que compila y le proporcionará una manera fácil de probar los paquetes binarios para usted y para otros.  Necesitará configurar un PPA en Launchpad y luego cargarlo con ``dput``::

en: Submitting for inclusion
es: Enviar para su inclusión

en: There are a number of paths that a package can take to enter Ubuntu. In most cases, going through Debian first can be the best path. This way ensures that your package will reach the largest number of users as it will be available in not just Debian and Ubuntu but all of their derivatives as well. Here are some useful links for submitting new packages to Debian:
es: Existe varios caminos por los que un paquete puede entrar en Ubuntu. En la mayoría de los casos, ir antes por Debian puede ser la mejor alternativa. De esta forma se asegura de que su paquete llegará al mayor número de usuarios, ya que también estará disponible no solo para Debian y Ubuntu, sino para todos sus derivados también. Estos son algunos enlaces útiles para enviar nuevos paquetes a Debian:

en: Once you have uploaded a package to debian, you should add screenshots to allow propective users to see what the program is like. These should be uploaded to http://screenshots.debian.net/upload .
es: Una vez que se ha cargado el paquete a Debian, se recomienda añadir capturas de pantalla para que el usuario pueda ver el aspecto del programa. Estas imágenes pueden cargarse en http://screenshots.debian.net/upload .

en: Patches to Packages
es: Parches a los paquetes

en: Sometimes, Ubuntu package maintainers have to change the upstream source code in order to make it work properly on Ubuntu.  Examples include, patches to upstream that haven't yet made it into a released version, or changes to the upstream's build system needed only for building it on Ubuntu.  We could change the upstream source code directly, but doing this makes it more difficult to remove the patches later when upstream has incorporated them, or extract the change to submit to the upstream project.  Instead, we keep these changes as separate patches, in the form of diff files.
es: A veces, los mantenedores de paquetes de Ubuntu tienen que cambiar el código fuente recibido desde aguas arriba para que funcione correctamente en Ubuntu. Ejemplos de esto incluyen parches aguas arriba que no han llegado todavía a la versión emitida, o cambios al sistema de compilación aguas arribas que son necesarios únicamente para compilarlos en Ubuntu. Se podría cambiar el código recibido de aguas arriba directamente, pero al hacerlo que dificulta la eliminación de los parches posteriormente cuando se hayan incorporado los cambios aguas arriba, o extraer el cambio para enviarlo al proyecto aguas arriba. En su lugar, se mantienen los cambios como parches independientes, en forma de archivos de diferencias (diff).

en: There are a number of different ways of handling patches in Debian packages, fortunately we are standardizing on one system, `Quilt`_, which is now used by most packages.
es: Hay varias formas diferentes de gestionar los parches de paquetes de Debian, aunque afortunadamente se está estandarizando en un único sistema, `Quilt`_, que se usa ya para la mayoría de los paquetes.

en: The patches are kept in ``debian/patches``.  This package has one patch ``kubuntu_01_fix_qmax_on_armel.diff`` to fix a compile failure on ARM.  The patch has been given a name to describe what it does, a number to keep the patches in order (two patches can overlap if they change the same file) and in this case the Kubuntu team adds their own prefix to show the patch comes from them rather than from Debian.
es: Los parches se mantienen en ``debian/patches``. Este paquete tiene un parche ``kubuntu_01_fix_qmax_on_armel.diff`` para arreglar un fallo de compilación en ARM. Al parche se le ha dado un nombre descriptivo de lo que hace, un número para mantener los parches ordenados (dos parches se puede solapar si cambian el mismo archivo) y en este caso el equipo de Kubuntu añade su propio prefijo para mostrar que el parche proviene de ellos en lugar de venir de Debian.

en: The order of patches to apply is kept in ``debian/patches/series``.
es: El orden de los parches a aplicar se mantiene en ``debian/patches/series``.

en: Patches with Quilt
es: Parches con Quilt

en: Before working with Quilt you need to tell it where to find the patches.  Add this to your ``~/.bashrc``::
es: Antes de comenzar a trabajar con Quilt necesita indicarle dónde encontrar los parches. Añádalo a su archivo ``~/.bashrc``::

en: And source the file to apply the new export::
es: Y como fuente el archivo para aplicar la nueva exportación::

en: By default all patches are applied already to UDD checkouts or downloaded packages.  You can check this with::
es: Por defecto todos los parches ya están aplicados a las extracción UDD o a los paquetes descargados. Puede comprobarlo con::

en: If you wanted to remove the patch you would run ``pop``::
es: Si quería eliminar el parche debería ejecutar ``pop``::

en: And to apply a patch you use ``push``::
es: Y para aplicar un parche use ``push``::

en: Adding a New Patch
es: Añadir un nuevo parche

en: To add a new patch you need to tell Quilt to create a new patch, tell it which files that patch should change, edit the files then refresh the patch::
es: Para añadir un nuevo parche necesita indicarle a Quilt que cree un nuevo parche, qué archivos debería cambiar ese parche, editar los archivos y refrescar el parche::

en: The ``quilt add`` step is important, if you forget it the files will not end up in the patch.
es: El paso ``quilt add`` es importante, si lo olvida los archivos no terminarán en el parche.

en: The change will now be in ``debian/patches/kubuntu_02_program_description.diff`` and the ``series`` file will have had the new patch added to it.  You should add the new file to the packaging::
es: El cambio estará ahora en ``debian/patches/kubuntu_02_program_description.diff`` y en el archivo ``series`` se habrá añadido el parche. Ahora debería añadir el archivo al empaquetado::

en: Quilt keeps its metadata in the ``.pc/`` directory, so currently you need to add that to the packaging too.  This should be improved in future.
es: Quilt mantiene sus metadatos en el directorio ``.pc/``, así que actualmente necesita añadirlo también al empaquetado. Esto debería mejorarse en el futuro.

en: As a general rule you should be careful adding patches to programs unless they come from upstream, there is often a good reason why that change has not already been made.  The above example changes a user interface string for example, so it would break all translations.  If in doubt, do ask the upstream author before adding a patch.
es: Como regla general debería tener cuidado al añadir parches a programas a menos que lleguen desde aguas arriba, frecuentemente hay una buena razón para que el cambio no se haya hecho todavía. El ejemplo anterior cambia una cadena de la interfaz de usuario por ejemplo, así que invalidaría todas las traducciones. Si duda, pregunte al autor aguas arriba antes de añadir el parche.

en: Patch Headers
es: Cabeceras de parche

en: We recommend that you tag every patch with DEP-3_ headers by putting them at the top of patch file. Here are some headers that you can use:
es: Le recomendamos que etiquete cada parche con cabeceras DEP-3_ añadiéndolas al comienzo de cada archivo de parche. Estas son algunas de las cabeceras que puede usar:

en: Who wrote the patch (i.e. "Jane Doe <packager@example.com>").
es: Quién escribió el parque (por ejemplo, «Juana Nadie <empaquetador@ejemplo.com>").

en: Where this patch comes from (i.e. "upstream"), when *Author* is not present.
es: De dónde proviene el parche (por ejemplo, «upstream», aguas arriba), cuando no se indica el autor (*Author*).

en: A link to Launchpad bug, a short form is preferred (like *https://bugs.launchpad.net/bugs/XXXXXXX*). If there are also bugs in upstream or Debian bugtrackers, add *Bug* or *Bug-Debian* headers.
es: Un enlace al error en Launchpad, prefiriéndose una forma corta (como *https://bugs.launchpad.net/bugs/XXXXXXX*). Si existen tambien errores aguas arriba o , añadir cabeceras *Bug* o *Bug-Debian*.

en: Whether the patch was forwarded upstream. Either "yes", "no" or "not-needed".
es: Si el parche se reenvió aguas arriba. Uno de «yes» (sí), «no» (no) o «not-needed» (no necedsario).

en: Date of the last revision (in form "YYYY-MM-DD").
es: Fecha de la última revisión (en formato «YYYY-MM-DD»).

en: Upgrading to New Upstream Versions
es: Actualizar a nuevas versiones de aguas arriba

en: To upgrade to the new version, you can use ``bzr merge-upstream`` command::
es: Para actualizar a la nueva versión, puede usar la orden ``bzr merge-upstream``::

en: When you run this command, all patches will be unapplied, because they can become out of date. They might need to be refreshed to match the new upstream source or they might need to be removed altogether. To check for problems, apply the patches one at a time::
es: Cuando ejecute esa orden, se des-aplicarán todos los parches, porque pueden quedarse obsoletos. Podría ser necesario refrescarlos para que se adapten al nuevo código fuentes aguas arriba o deban ser eliminados completamente. Para comprobar posibles problemas, aplique los parches uno a uno::

en: If it can be reverse-applied this means the patch has been applied already by upstream, so we can delete the patch::
es: Si puede ser aplicado a la inversa significa que el parche ya ha sido aplicado aguas arriba, de forma que ya se puede borrar::

en: Then carry on::
es: Luego continúe::

en: It is a good idea to run refresh, this will update the patch relative to the changed upstream source::
es: Es una buena idea hacer un refresco, lo que actualizará el parche relativo a los fuentes cambiados aguas arriba::

en: Then commit as usual::
es: Luego confirme como siempre::

en: Making A Package Use Quilt
es: Hacer que un paquete use Quilt

en: Modern packages use Quilt by default, it is built into the packaging format.  Check in ``debian/source/format`` to ensure it says ``3.0 (quilt)``.
es: Los paquetes modernos usan Quilt de forma predeterminada, están incluido en el formato de empaquetado. Compruebe ``debian/source/format`` para asegurarse que pone ``3.0 (quilt)``.

en: Older packages using source format 1.0 will need to explicitly use Quilt, usually by including a makefile into ``debian/rules``.
es: Los paquetes más antiguos que usen el formato fuente 1.0 necesitarán usar Quilt explícitamente, normalmente incluyendo un archivo makefile en ``debian/rules``.

en: Configuring Quilt
es: Configurando Quilt

en: You can use ``~/.quiltrc`` file to configure quilt. Here are some options that can be useful for using quilt with debian/packages:
es: Puede usar el archivo ``~/.quiltrc`` para configurar quilt. Estas son algunas opciones que pueden resultar útiles para usar quilt con paquetes debian:

en: Other Patch Systems
es: Otros sistemas de parches

en: Other patch systems used by packages include ``dpatch`` and ``cdbs simple-patchsys``, these work similarly to Quilt by keeping patches in ``debian/patches`` but have different commands to apply, un-apply or create patches. You can find out which patch system is used by a package by using the ``what-patch`` command (from the ``ubuntu-dev-tools`` package). You can use ``edit-patch``, shown in :ref:`previous chapters <working-on-a-fix>`, as a reliable way to work with all systems.
es: Otros sistemas de parches que se usan por los paquetes incluyen ``dpatch`` y ``cdbs simple-patchsys``, los cuales funcionan de forma similar a Quilt, manteniendo los parches en ``debian/patches``, pero emplean órdenes distintas para aplicar, des-aplicar o crear parches. Puede averiguar qué sistema de parches se usa por un paquete mediante la orden ``what-patch`` (del paquete  ``ubuntu-dev-tools``). Puede usar ``edit-patch``,  como se ha mostrado en :ref:`capítulos previos <working-on-a-fix>`, como una manera fiable de trabajar con todos los sistemas.

en: In even older packages changes will be included directly to sources and kept in the ``diff.gz`` source file.  This makes it hard to upgrade to new upstream versions or differentiate between patches and is best avoided.
es: En paquetes todavía más antiguos los cambios se incluirán directamente en los fuentes y los mantendrán el archivo fuente ``diff.gz``. Esto complica la actualización a nuevas versiones de aguas arribas o distinguir entre parches por lo que lo mejor es evitarlo.

en: Do not change a package's patch system without discussing it with the Debian maintainer or relevant Ubuntu team.  If there is no existing patch system then feel free to add Quilt.
es: No cambie el sistema de parches de un paquete sin haberlo discutido con el mantenedor de Debian o el equipo pertinente de Ubuntu. Si no existe un sistema parches no tenga problemas en añadir Quilt.

en: Security and Stable Release Updates
es: Actualizaciones de seguridad y de versiones estables

en: Fixing a Security Bug in Ubuntu
es: Corregir un error de seguridad en Ubuntu

en: Obtaining the source
es: Obtener el código fuente

en: Patching the source
es: Parchear el código fuente

en: To create your patch using ``edit-patch``::
es: Para crear un parche usando ``edit-patch``::

en: This will apply the existing patches and put the packaging in a temporary directory. Now edit the files needed to fix the vulnerability.  Often upstream will have provided a patch so you can apply that patch::
es: Esto aplicará los parches existentes y dejará el empaquetado en un directorio temporal. Ahora edite los archivos necesarios para solucionar la vulnerabilidad. Frecuentemente se habrá proporcionado un parche desde aguas arriba de forma que pueda aplicarlo::

en: After making the necessary changes, you just hit Ctrl-D or type exit to leave the temporary shell.
es: Después de hacer los cambios necesarios, simplemente pulse Ctrl+D o escriba «exit» para dejar el intérprete de órdenes temporal.

en: Formatting the changelog and patches
es: Formatear el registro de cambios («changelog») y los parches

en: Update your patch to use the appropriate patch tags. Your patch should have at a minimum the Origin, Description and Bug-Ubuntu tags. For example, edit debian/patches/99-fix-a-vulnerability.patch to have something like::
es: Actualice su parche para usar las etiquetas de parche adecuadas. Su parche debería tener por lo menos  las etiquetas «Origin», «Description» y «Bug-Ubuntu». Por ejemplo, edite debian/patches/99-fix-a-vulnerability.patch para que tenga es siguiente aspecto::

en: Multiple vulnerabilities can be fixed in the same security upload; just be sure to use different patches for different vulnerabilities.
es: Muchas vulnerabilidades se puede solucionar en la misma carga de seguridad, pero asegúrese de usar parches distintos para las diferentes vulnerabilidades.

en: Test and Submit your work
es: Probar y enviar el trabajo

en: At this point the process is the same as for :doc:`fixing a regular bug in Ubuntu<./fixing-a-bug>`. Specifically, you will want to:
es: En este punto el proceso es el mismo que para :doc:`arreglar un bug normal de Ubuntu<./fixing-a-bug>`. Más concretamente, deseará:

en: Build your package and verify that it compiles without error and without any added compiler warnings
es: Construir el paquete y comprobar que compila sin errores y sin ningún aviso del compilador añadido.

en: Upgrade to the new version of the package from the previous version
es: Actualizar a la nueva versión del paquete desde la versión anterior

en: Test that the new package fixes the vulnerability and does not introduce any regressions
es: Probar que el nuevo paquete corrige la vulnerabilidad y no introduce ninguna regresión

en: Submit your work via a Launchpad merge proposal and file a Launchpad bug being sure to mark the bug as a security bug and to subscribe ``ubuntu-security-sponsors``
es: Enviar el trabajo mediante una propuesta de integración de Launchpad y rellenar un error en Launchpad asegurándose de marcar el error como un fallo de seguridad y de suscribirse a ``ubuntu-security-sponsors``.

en: If the security vulnerability is not yet public then do not file a merge proposal and ensure you mark the bug as private.
es: Si la vulnerabilidad de seguridad no es pública todavía no presente una propuesta de integración y asegúrese de marcar el error como privado.

en: The filed bug should include a Test Case, i.e. a comment which clearly shows how to recreate the bug by running the old version then how to ensure the bug no longer exists in the new version.
es: El presentado debe incluir un caso de prueba, es decir, un comentario que indique claramente cómo recrear el error ejecutando la versión antigua y luego cómo asegurarse de que el error no existe en la nueva versión.

en: Stable Release Updates
es: Actualizaciones de versiones estables

en: We also allow updates to releases where a package has a high impact bug such as a severe regression from a previous release or a bug which could cause data loss.  Due to the potential for such updates to themselves introduce bugs we only allow this where the change can be easily understood and verified.
es: También se permite actualizaciones de emisiones en las que un paquete tiene un error de gran impacto, como por ejemplo una regresión severa de una emisión anterior o un error que podría causar pérdida de datos. Debido al potencia de que esas actualizaciones a su vez introduzcan errores solo se permiten cuando los cambios pueden ser fácilmente comprendidos y verificados.

en: The process for Stable Release Updates is just the same as the process for security bugs except you should subscribe ``ubuntu-sru`` to the bug.
es: El proceso de actualizaciones de versiones estables es el mismo que el proceso para errores de seguridad excepto que debería suscribir ``ubuntu-sru`` al error.
