dgit_13.13_dgit-user_7 - en to nl translation catalogue (81 entries)

note: type: =head1
en: NAME
nl: NAAM

note: type: =head1
en: SEE ALSO
nl: ZIE OOK

note: type: =head1
en: SUMMARY
nl: SAMENVATTING

note: type: textblock
en: dgit-user - making and sharing changes to Debian packages, with git
nl: dgit-user - maken en delen van wijzigingen aan Debian-pakketten, met git

note: type: =head1
en: INTRODUCTION
nl: INLEIDING

note: type: textblock
en: dgit lets you fetch the source code to every package on your system as if your distro used git to maintain all of it.
nl: dgit laat u toe de broncode van elk pakket op uw systeem op te halen alsof uw distributie gebruik maakte van git om die allemaal te onderhouden.

note: type: textblock
en: You can then edit it, build updated binary packages (.debs)  and install and run them.  You can also share your work with others.
nl: U kunt deze broncode dan bewerken, bijgewerkte binaire pakketten (.deb's) bouwen en ze installeren en uitvoeren. U kunt uw werk ook delen met anderen.

note: type: textblock
en: This tutorial gives some recipes and hints for this.  It assumes you have basic familiarity with git.  It does not assume any initial familiarity with Debian's packaging processes.
nl: Deze handleiding geeft hiervoor enkele procedures en suggesties. Ze gaat ervan uit dat u beschikt over basale noties van git. Ze veronderstelt niet dat u enigszins vertrouwd bent met de processen van pakketbeheer van Debian.

note: type: textblock
en: If you are a package maintainer within Debian; a DM or DD; and/or a sponsee: this tutorial is not for you.  Try L<dgit-nmu-simple(7)>, L<dgit-maint-*(7)>, or L<dgit(1)> and L<dgit(7)>.
nl: Indien u een pakketonderhouder bent binnen Debian, een Onderhouder (DM -Debian Maintainer) of Ontwikkelaar (DD - Debian Developper) van Debian, en/of iemand wiens werk gesponsord wordt, dan is deze handleiding niet voor u. Raadpleeg in dat geval L<dgit-nmu-simple(7)>, L<dgit-maint-*(7)>, of L<dgit(1)> en L<dgit(7)>.

note: type: textblock
en: (These runes will be discussed later.)
nl: (Deze runen worden later besproken.)

note: type: verbatim
en:     % dgit clone glibc bookworm,-security
        % cd glibc
        % curl 'https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=28250;mbox=yes;msg=89' | patch -p1 -u
        % git commit -a -m 'Fix libc lost output bug'
        % gbp dch -S --since=dgit/dgit/sid --ignore-branch --commit
        % sudo apt-get build-dep .
        % dpkg-buildpackage -uc -b
        % sudo dpkg -i ../libc6_*.deb
nl:     % dgit clone glibc bookworm,-security
        % cd glibc
        % curl 'https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=28250;mbox=yes;msg=89' | patch -p1 -u
        % git commit -a -m 'Reparatie van libc-bug waarbij verlies van uitvoer optreedt'
        % gbp dch -S --since=dgit/dgit/sid --ignore-branch --commit
        % sudo apt-get build-dep .
        % dpkg-buildpackage -uc -b
        % sudo dpkg -i ../libc6_*.deb

note: type: textblock
en: Occasionally:
nl: Sporadisch:

note: type: =head1
en: FINDING THE RIGHT SOURCE CODE - DGIT CLONE
nl: DE JUISTE BRONCODE VINDEN - DGIT CLONE

note: type: textblock
en: dgit clone needs to be told the source package name (which might be different to the binary package name, which was the name you passed to "apt-get install")  and the codename or alias of the Debian release (this is called the "suite").
nl: Aan dgit clone moet de naam van het broncodepakket opgegeven worden (die kan verschillen van de naam van het binaire pakket; het was deze laatste naam die u opgaf aan "apt-get install") en de codenaam of de alias van de Debian-release (welke men de "suite" noemt)

note: type: =head2
en: Finding the source package name
nl: De naam van het broncodepakket te weten komen

note: type: textblock
en: For many packages, the source package name is obvious.  Otherwise, if you know a file that's in the package, you can look it up with dpkg:
nl: Bij veel pakketten is de naam van het broncodepakket voor de hand liggend. Anders kunt u hem opzoeken met dpkg, indien u een bestand kent dat in het pakket zit:

note: type: verbatim
en:     % dpkg -S /lib/i386-linux-gnu/libc.so.6 
        libc6:i386: /lib/i386-linux-gnu/libc.so.6
        % dpkg -s libc6:i386
        Package: libc6
        Status: install ok installed
        ...
        Source: glibc
nl:     % dpkg -S /lib/i386-linux-gnu/libc.so.6 
        libc6:i386: /lib/i386-linux-gnu/libc.so.6
        % dpkg -s libc6:i386
        Package (Pakket): libc6
        Status (Toestand): install ok installed (geïnstalleerd)
        ...
        Source (Bron): glibc

note: type: textblock
en: (In this example, libc6 is a "multi-arch: allowed" package, which means that it exists in several different builds for different architectures.  That's where C<:i386> comes from.)
nl: (In dit voorbeeld is
    libc6 een pakket van het type "multi-arch: allowed",
    hetgeen betekent dat het voorkomt in verschillende andere vormen/compilaties
    voor verschillende architecturen.
    Daarvandaan komt C<:i386>.)

note: type: =head2
en: Finding the Debian release (the "suite")
nl: De Debian-release (de "suite") te weten komen

note: type: textblock
en: Internally, Debian (and derived) distros normally refer to their releases by codenames.  Debian also has aliases which refer to the current stable release etc.  So for example, at the time of writing Debian C<bookworm> (Debian 12) is Debian C<stable>; and the current version of Ubuntu is C<plucky> (Plucky Puffin, 25.04).  You can specify either the codename C<bookworm> or the alias C<stable>.  If you don't say, you get C<sid>, which is Debian C<unstable> - the main work-in progress branch.
nl: Intern verwijzen Debian (en de ervan afgeleide distributies) gewoonlijk naar hun releases met een codenaam. Debian gebruikt ook aliassen die verwijzen naar de huidige stabiele release, enz. Bijvoorbeeld, bij het schrijven van deze handleiding was Debian C<bookworm> (Debian 12) Debian C<stable> (de stabiele uitgave van Debian), en was de actuele versie van Ubuntu C<plucky> (Plucky Puffin, 25.04). U kunt zowel de codenaam C<bookworm> als de alias C<stable> opgeven. Indien u niets opgeeft, dan krijgt u C<sid>, welke Debian C<unstable>  is - de centrale tak van de voortgaande ontwikkeling.

note: type: textblock
en: If you don't know what you're running, please refer to your apt configuration in /etc/apt/sources* or in /etc/debian_version
nl: Als u niet weet welke versie u gebruikt, raadpleeg dan uw apt-configuratie in /etc/apt/sources* of in /etc/debian_version.

note: type: textblock
en: For Debian, you should add C<,-security> to the end of the suite name, unless you're on unstable or testing.  Hence, in our example C<bookworm> becomes C<bookworm,-security>.  (Yes, with a comma.)
nl: Voor Debian moet u aan het eind van de naam van de suite C<,-security> toevoegen, tenzij u met de suite unstable of testing werkt. Dus in ons voorbeeld wordt C<bookworm> C<bookworm,-security>. (Wel degelijk met de komma.)

note: type: =head1
en: WHAT DGIT CLONE PRODUCES
nl: WAT DGIT CLONE AANMAAKT

note: type: =head2
en: What branches are there
nl: Welke takken er zijn

note: type: textblock
en: dgit clone will give you a new working tree, and arrange for you to be on a branch named like C<dgit/bookworm,-security> (yes, with a comma in the branch name).
nl: dgit clone zal voor u een verse werkkopie aanmaken en ervoor zorgen dat u zich bevindt op een tak met een naam als C<dgit/bookworm,-security> (inderdaad, met een komma in de naam van de tak).

note: type: textblock
en: For each release (like C<bookworm>)  there is a tracking branch for the contents of the archive, called C<remotes/dgit/dgit/bookworm> (and similarly for other suites).  This can be updated with C<dgit fetch bookworm>.  This, the I<remote suite branch>, is synthesized by your local copy of dgit.  It is fast forwarding.
nl: Voor elke release (zoals C<bookworm>) bestaat een meelopende tak voor de inhoud van het archief, genoemd C<remotes/dgit/dgit/bookworm> (en net zo voor andere suites). Deze kan bijgewerkt worden met C<dgit fetch bookworm>. Deze, de I<externe suitetak>, wordt samengesteld door uw lokale kopie van dgit. Een lineaire veranderingsgeschiedenis wordt opgebouwd (N.v.d.V.: fast forwarding in git-terminologie).

note: type: textblock
en: Debian separates out the security updates, into C<*-security>.  Telling dgit C<bookworm,-security> means that it should include any updates available in C<bookworm-security>.  The comma notation is a request to dgit to track bookworm, or bookworm-security if there is an update for the package there.
nl: De veiligheidsupdates worden door Debian afgezonderd in C<*-security>. Aan dgit de opdracht C<bookworm,-security> geven, betekent dat het de eventueel in C<bookworm-security> aanwezige updates moet opnemen. De notatie met de komma houdt de vraag aan dgit in om bookworm op te volgen of bookworm-security als zich daarin een update voor het pakket bevindt.

note: type: textblock
en: (You can also dgit fetch in a tree that wasn't made by dgit clone.  If there's no C<debian/changelog> you'll have to supply a C<-p>I<package> option to dgit fetch.)
nl: (U kunt ook het commando dgit fetch gebruiken in een mappenboom die niet door git clone aangemaakt werd. Indien daarin geen C<debian/changelog> aanwezig is, zult u met dgit fetch de optie C<-p>I<pakket> moeten gebruiken.)

note: type: =head2
en: What kind of source tree do you get
nl: Welk soort broncodeboom u verkrijgt

note: type: textblock
en: If the Debian package is based on some upstream release, the code layout should be like the upstream version.  You should find C<git grep> helpful to find where to edit.
nl: Indien het Debian-pakket gebaseerd is op een release van een toeleveraar, dan zal de indeling van de broncode eruit zien als die van de versie van de toeleveraar. U kunt zich laten helpen door C<git grep> om uit te zoeken waar u met bewerken wilt beginnen.

note: type: textblock
en: The package's Debian metadata and the scripts for building binary packages are under C<debian/>.  C<debian/control>, C<debian/changelog> and C<debian/rules> are the starting points.  The Debian Policy Manual has most of the in-depth technical details.
nl: De metagegevens van Debian over het pakket en de scripts voor het bouwen van de binaire pakketten bevinden zich in C<debian/>. Aanknopingspunten zijn C<debian/control>, C<debian/changelog> en C<debian/rules>. In het beleidshandboek van Debian vindt u meestal de nodige diepgaande technische informatie.

note: type: textblock
en: For many Debian packages, there will also be some things in C<debian/patches/>.  It is best to ignore these.  Insofar as they are relevant the changes there will have been applied to the actual files, probably by means of actual commits in the git history.  The contents of debian/patches are ignored when building binaries from dgitish git branches.
nl: Bij veel Debian-pakketten zijn ook zaken te vinden in C<debian/patches/>. U kunt deze best negeren. Voor zover deze relevant zijn, zullen deze toegepast zijn in de eigenlijke bestanden, vermoedelijk via feitelijke vastleggingen in de git-geschiedenis. Wanneer binaire pakketten gebouwd worden vanuit met dgit verkregen git-takken, wordt de inhoud van debian/patches genegeerd.

note: type: textblock
en: (For Debian afficionados: the git trees that come out of dgit are "patches-applied packaging branches without a .pc directory".)
nl: (Voor Debian-ingewijden: de git-boomstructuren die met dgit verkregen worden zijn "verpakkingstakken met toegepaste patches, maar zonder .pc-map".)

note: type: =head2
en: What kind of history you get
nl: Welk soort geschiedenis u verkrijgt

note: type: textblock
en: If you're lucky, the history will be a version of, or based on, the Debian maintainer's own git history, or upstream's git history.
nl: Indien u geluk heeft, zal de geschiedenis een versie zijn van, of gebaseerd zijn op de eigen git-geschiedenis van de pakketonderhouder van Debian, of van de git-geschiedenis van de toeleveraar.

note: type: textblock
en: But for many packages the real git history does not exist, or has not been published in a dgitish form.  So you may find that the history is a rather short history invented by dgit.
nl: Maar van veel pakketten bestaat geen echte git-geschiedenis of werd die niet in een dgit-achtige vorm gepubliceerd. Het is dus mogelijk dat u vaststelt dat de geschiedenis eerder kort is en door dgit bedacht.

note: type: textblock
en: dgit histories often contain automatically-generated commits, including commits which make no changes but just serve to make a rebasing branch fast-forward.  This is particularly true of combining branches like C<bookworm,-security>.
nl: dgit-geschiedenissen bevatten vaak automatisch gegenereerde vastleggingen (commits), met inbegrip van vastleggingen die geen wijzigingen aanbrengen, maar enkel dienen om een zich herintegrerende aftakking in te passen in de lineaire vorm van de veranderingsgeschiedenis (N.v.d.V.: "make a rebasing branch fast-forward" in git-terminologie). Dit is in het bijzonder het geval bij gecombineerde takken zoals C<bookworm,-security>.

note: type: textblock
en: If the package maintainer is using git then after dgit clone you may find that there is a useful C<vcs-git> remote referring to the Debian package maintainer's repository for the package.  You can see what's there with C<git fetch vcs-git>.  But use what you find there with care: Debian maintainers' git repositories often have contents which are very confusing and idiosyncratic.  In particular, you may need to manually apply the patches that are in debian/patches before you do anything else!
nl: Indien de pakketonderhouder gebruik maakt van git, dan kunt u na een dgit clone een handig C<vcs-git> remote opmerken, wat verwijst naar het git-archief waarvan de pakketonderhouder gebruik maakt voor het pakket. U kunt zien wat zich daar bevindt met C<git fetch vcs-git>. Maar gebruik wat u daar vindt met zorg: de git-archieven van onderhouders van Debian bevatten vaak zaken die erg verwarrend en zonderling kunnen zijn. In het bijzonder zult u mogelijk handmatig de patches moeten toepassen die zich in debian/patches bevinden voor u iets anders doet!

note: type: =head1
en: BUILDING
nl: BOUWPROCES

note: type: =head2
en: Always commit before building
nl: Leg steeds veranderingen vast (N.v.d.V.: "commit" in git-terminologie) voor u begint te bouwen

note: type: verbatim
en:     % wget 'https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=28250;mbox=yes;msg=89' | patch -p1 -u
        % git commit -a -m 'Fix libc lost output bug'
nl:     % wget 'https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=28250;mbox=yes;msg=89' | patch -p1 -u
        % git commit -a -m 'Reparatie van libc-bug waarbij verlies van uitvoer optreedt'

note: type: textblock
en: Debian package builds are often quite messy: they may modify files which are also committed to git, or leave outputs and temporary files not covered by C<.gitignore>.
nl: Het bouwproces van een Debian-pakket verloopt vaak erg rommelig: het kan bestanden wijzigen die ook vastgelegd zijn in git of uitvoer en tijdelijke bestanden achterlaten die niet door C<.gitignore> afgedekt zijn.

note: type: textblock
en: If you always commit, you can use
nl: Indien u steeds een vastlegging doet, kunt u gebruik maken van

note: type: textblock
en: to tidy up after a build.  (If you forgot to commit, don't use those commands; instead, you may find that you can use C<git add -p> to help commit what you actually wanted to keep.)
nl: om na het bouwproces een opruimactie te doen. (Indien u vergat vast te leggen, gebruik dan deze commando's niet; in de plaats kunt u misschien C<git add -p> gebruiken om te helpen vastleggen wat u werkelijk wenst te bewaren.)

note: type: textblock
en: These are destructive commands which delete all new files (so you B<must> remember to say C<git add>)  and throw away edits to every file (so you B<must> remember to commit).
nl: Dit zijn verwoestende commando's die alle nieuwe bestanden wissen (dus B<moet> u eraan denken om C<git add>) uit te voeren) en elke aanpassing aan een bestand weggooien (u B<moet> er dus aan denken om een vastlegging uit te voeren).

note: type: =head2
en: Update the changelog (at least once) before building
nl: Werk het bestand changelog (minstens eenmaal) bij voor u bouwt

note: type: textblock
en: The binaries you build will have a version number which ultimately comes from the C<debian/changelog>.  You want to be able to tell your binaries apart from your distro's.
nl: De binaire pakketten welke u bouwt zullen een versienummer hebben dat uiteindelijk afkomstig is uit het bestand C<debian/changelog>. U wilt toch uw binaire pakketten kunnen onderscheiden van die van uw distributie.

note: type: textblock
en: So you should update C<debian/changelog> to add a new stanza at the top, for your build.
nl: En dus moet u C<debian/changelog> bijwerken en er bovenaan een item toevoegen voor u de bouw uitvoert.

note: type: textblock
en: This rune provides an easy way to do this.  It adds a new changelog entry with an uninformative message and a plausible version number (containing a bit of your git commit id).
nl: Deze rune geeft een makkelijke manier om dit te doen. Het voegt een nieuw item toe aan changelog met een niet-informatieve mededeling en een plausibel versienummer (dat een stukje van het id van uw vastlegging bevat).

note: type: textblock
en: If you want to be more sophisticated, the package C<dpkg-dev-el> has a good Emacs mode for editing changelogs.  Alternatively, you could edit the changelog with another text editor, or run C<dch> or C<gbp dch> with different options.  Choosing a good version number is slightly tricky and a complete treatment is beyond the scope of this tutorial.
nl: Indien u een meer gesofisticeerde manier wilt, biedt het pakket C<dpkg-dev-el> een goede Emacs-modus voor het bewerken van changelogs. U kunt anders de changelog ook bewerken met een andere teksteditor, of C<dch> of C<gbp dch> uitvoeren met verschillende opties. Het kiezen van een goed versienummer is een beetje een netelige kwestie en een volledige behandeling van dit onderwerp valt buiten het bestek van deze handleiding.

note: type: =head2
en: Actually building
nl: Het eigenlijke bouwen

note: type: textblock
en: dpkg-buildpackage is the primary tool for building a Debian source package.  C<-uc> means not to pgp-sign the results.  C<-b> means build all binary packages, but not to build a source package.
nl: dpkg-buildpackage is het belangrijkste gereedschap voor het bouwen van een Debian-broncodepakket. C<-uc> betekent: geen pgp-ondertekening toevoegen aan de resultaten. C<-b> betekent: alle binaire pakketten bouwen, maar geen broncodepakket.

note: type: =head2
en: Using sbuild
nl: Gebruik maken van sbuild

note: type: textblock
en: You can build in an schroot chroot, with sbuild, instead of in your main environment.  (sbuild is used by the Debian build daemons.)
nl: In plaats van in uw hoofdomgeving, kunt u de bouw uitvoeren in een "schroot chroot" met sbuild (sbuild wordt door de build-achtergronddiensten van Debian gebruikt.)

note: type: verbatim
en:     % git clean -xdf
        % sbuild -d trixie -A --no-clean-source \
                 --dpkg-source-opts='-Zgzip -z1 --format=1.0 -sn'
nl:     % git clean -xdf
        % sbuild -c trixie -A --no-clean-source \
                 --dpkg-source-opts='-Zgzip -z1 --format=1.0 -sn'

note: type: textblock
en: Note that this will seem to leave a "source package" (.dsc and .tar.gz)  in the parent directory, but that source package should not be used.  It is likely to be broken.  For more information see Debian bug #868527.
nl: Merk op dat dit een "broncodepakket" (.dsc en .tar.gz) lijkt achter te laten in de bovenliggende map, maar u moet dit broncodepakket niet gebruiken. Waarschijnlijk is het defect. Zie voor bijkomende informatie Debian-bug #868527.

note: type: =head1
en: INSTALLING
nl: INSTALLEREN

note: type: textblock
en: You can use C<dpkg -i> to install the .debs that came out of your package.
nl: U kunt C<dpkg -i> gebruiken om de .deb-bestanden te installeren die uit uw pakket voortkwamen.

note: type: textblock
en: If the dependencies aren't installed, you will get an error, which can usually be fixed with C<apt-get -f install>.
nl: Indien de vereisten niet geïnstalleerd zijn, zult u een foutmelding krijgen die gewoonlijk gerepareerd kan worden met C<apt-get -f install>.

note: type: textblock
en: If you're working on a library package and your system has multiple architectures enabled, you may see something like this:
nl: Indien u aan een bibliotheekpakket werkt en op uw systeem multi-architectuurondersteuning geactiveerd is, krijgt u mogelijk iets te zien als dit:

note: type: verbatim
en:     dpkg: error processing package libpcre3-dev:amd64 (--configure):
         package libpcre3-dev:amd64 2:8.39-3~3.gbp8f25f5 cannot be configured because libpcre3-dev:i386 is at a different version (2:8.39-2)
nl:     dpkg: fout bij verwerken van pakket libpcre3-dev:amd64 (--configure):
         pakket libpcre3-dev:amd64 2:8.39-3~3.gbp8f25f5 kan niet geconfigureerd worden omdat libpcre3-dev:i386 een andere versie (2:8.39-2) heeft

note: type: textblock
en: The multiarch system used by Debian requires each package which is present for multiple architectures to be exactly the same across all the architectures for which it is installed.
nl: Het multi-architectuursysteem dat door Debian toegepast wordt, vereist dat elk pakket dat voor meerdere architecturen aanwezig is, exact hetzelfde is bij alle architecturen waarvoor het geïnstalleerd is.

note: type: textblock
en: The proper solution is to build the package for all the architectures you have enabled.  You'll need a chroot for each of the secondary architectures.  This is somewhat tiresome, even though Debian has excellent tools for managing chroots.  C<sbuild-debian-developer-setup> from the package of the same name and C<sbuild-createchroot> from the C<sbuild> package are good starting points.
nl: De geëigende oplossing is om het pakket te bouwen voor alle architecturen die u geactiveerd heeft. U zult een chroot nodig hebben voor elk van de secundaire architecturen. Dit is enigszins vermoeiend, ook al beschikt Debian over uitstekende hulpmiddelen voor het beheren van chroots. Goede aanknopingspunten zijn C<sbuild-debian-developer-setup> uit het pakket met dezelfde naam en C<sbuild-createchroot> uit het pakket C<sbuild>.

note: type: textblock
en: Otherwise you could deinstall the packages of interest for those other architectures with something like C<dpkg --remove libpcre3:i386>.
nl: Een andere mogelijkheid is dat u de betreffende pakketten bij de andere architecturen de-installeert met iets zoals C<dpkg --remove libpcre3:i386>.

note: type: textblock
en: If neither of those are an option, your desperate last resort is to try using the same version number as the official package for your own package.  (The version is controlled by C<debian/changelog> - see above.)  This is not ideal because it makes it hard to tell what is installed, and because it will mislead and confuse apt.
nl: Indien geen van beide mogelijkheden een optie is, dan is een mogelijke laatste wanhoopsdaad, voor uw eigen pakket hetzelfde versienummer gebruiken als van het officiële pakket. Dit is niet ideaal omdat dit het moeilijk maakt om te weten wat geïnstalleerd is, en omdat het apt zal misleiden en in de war brengen.

note: type: textblock
en: With the "same number" approach you may still get errors like
nl: Met de "hetzelfde-nummer"-benadering kunt u nog steeds foutmeldingen krijgen zoals

note: type: textblock
en: trying to overwrite shared '/usr/include/pcreposix.h', which is different from other instances of package libpcre3-dev
nl: poging tot overschrijven van gedeelde '/usr/include/pcreposix.h', welke verschilt van andere exemplaren van pakket libpcre3-dev

note: type: textblock
en: but passing C<--force-overwrite> to dpkg will help - assuming you know what you're doing.
nl: maar de optie C<--force-overwrite> meegeven aan dpkg zal helpen - in de veronderstelling dat u weet wat u doet.

note: type: =head1
en: SHARING YOUR WORK
nl: UW WERK DELEN

note: type: textblock
en: The C<dgit/bookworm,-security> branch (or whatever) is a normal git branch.  You can use C<git push> to publish it on any suitable git server.
nl: De tak C<dgit/bookworm,-security> (of wat dan ook) is een gewone git-tak. U kunt C<git push> gebruiken om hem te publiceren op elke geschikte git-server.

note: type: textblock
en: Anyone who gets that git branch from you will be able to build binary packages (.deb)  just as you did.
nl: Iedereen die deze git-tak van u krijgt, zal in staat zijn om binaire pakketten (.deb) te bouwen, zoals u het deed.

note: type: textblock
en: If you want to contribute your changes back to Debian, you should probably send them as attachments to an email to the L<Debian Bug System|https://bugs.debian.org/> (either a followup to an existing bug, or a new bug).  Patches in C<git-format-patch> format are usually very welcome.
nl: Indien u uw wijzigingen terug wilt bijdragen aan Debian, dan zult u ze wellicht als bijlage bij een e-mail moeten sturen naar het L<Debian Bugvolgsysteem|https://bugs.debian.org/> (ofwel als opvolging van een bestaande bug, of als een nieuwe bug). Patches in de indeling C<git-format-patch> zijn gewoonlijk erg welkom.

note: type: =head2
en: Source packages
nl: Broncodepakketten

note: type: textblock
en: The git branch is not sufficient to build a source package the way Debian does.  Source packages are somewhat awkward to work with.  Indeed many plausible git histories or git trees cannot be converted into a suitable source package.  So I recommend you share your git branch instead.
nl: De git-tak volstaat niet om een broncodepakket te bouwen volgens de manier van Debian. Broncodepakketten zijn wat lastig om ermee te werken. Vele aannemelijke git-geschiedenissen of git-bomen kunnen namelijk niet omgezet worden naar een geschikt broncodepakket. Dus beveel ik aan om in de plaats daarvan uw git-tak te delen.

note: type: textblock
en: If a git branch is not enough, and you need to provide a source package but don't care about its format/layout (for example because some software you have consumes source packages, not git histories)  you can use this recipe to generate a C<3.0 (native)> source package, which is just a tarball with accompanying .dsc metadata file:
nl: Indien een git-tak niet voldoende is en u een broncodepakket moet aanleveren, maar het formaat/de indeling ervan niet van belang is (bijvoorbeeld omdat u bepaalde software heeft die met broncodepakketten werkt en niet met git-geschiedenissen), kunt u deze methode gebruiken om een broncodepakket van het type C<3.0 (native)> te genereren. Dit is niet meer dan een tar-archief met een bijhorend .dsc-metadatabestand:

note: type: verbatim
en:     % echo '3.0 (native)' >debian/source/format
        % git commit -m 'switch to native source format' debian/source/format
        % dgit -wgf build-source
nl:     % echo '3.0 (native)' >debian/source/format
        % git commit -m 'overgang naar de broncode-indeling native' debian/source/format
        % dgit -wgf build-source

note: type: textblock
en: If you need to provide a good-looking source package, be prepared for a lot more work.  You will need to read much more, perhaps starting with L<dgit-nmu-simple(7)>, L<dgit-sponsorship(7)> or L<dgit-maint-*(7)>
nl: Indien u een goed ogend broncodepakket moet aanleveren, dan zult u bereid moeten zijn er heel wat meer werk in te investeren. U zult heel wat meer moeten lezen, misschien te beginnen bij L<dgit-nmu-simple(7)>, L<dgit-sponsorship(7)> of L<dgit-maint-*(7)>

note: type: =head1
en: INSTALLING NEWER DGIT ON OLDER DISTROS
nl: NIEUWERE DGIT INSTALLEREN OP OUDERE DISTRIBUTIES

note: type: textblock
en: If dgit breaks with the source package you are working with, this might be due to a bug which would be fixed by upgrading.
nl: Als dgit niet werkt met het bronpakket waarmee u werkt, kan dit te wijten zijn aan een bug. Deze kan worden verholpen door een upgrade.

note: type: textblock
en: You can probably directly C<apt install> the latest version of dgit.deb from Debian stable, or Debian testing.
nl: U kunt waarschijnlijk rechtstreeks de nieuwste versie van dgit.deb installeren via C<apt install> vanuit Debian stable of Debian testing.

note: type: textblock
en: Versions of dgit from Debian 13 (trixie) onwards document their installability on old releases in the manpage.  For example, for current Debian testing, see L<https://manpages.debian.org/testing/dgit/dgit.1.en.html>, and look in the section SUPPORT ON OLD DISTRIBUTIONS.
nl: Versies van dgit vanaf Debian 13 (trixie) documenteren hun installeerbaarheid op oude releases in de manpagina. Zie bijvoorbeeld L<https://manpages.debian.org/testing/dgit/dgit.1.en.html> voor het huidige Debian testing en kijk in de sectie ONDERSTEUNING OP OUDE DISTRIBUTIES..
