0 - en to id-ID translation catalogue (116 entries)

en: Source package
id-ID: Paket sumber

en: Archive
id-ID: Arsip

en: Debian Developer
id-ID: Pengembang Debian

en: Creating a Debian Package
id-ID: Membuat paket Debian

en: It is quite common, for an administrator who has been handling Debian packages in a regular fashion, to eventually feel the need to create their own packages, or to modify an existing package. This chapter aims to answer the most common questions in this field, and provide the required elements to take advantage of the Debian infrastructure in the best way. With any luck, after trying your hand for local packages, you may even feel the need to go further than that and join the Debian project itself!
id-ID: Sudah menjadi hal umum bagi administrator yang rutin menangani paket Debian, pada suatu saat ingin membuat paket Debian-nya sendiri, atau memodifikasi paket yang sudah ada. Bab ini berusaha menjawab pertanyaan yang paling sering diajukan dalam topik paket Debian, dan menyediakan bagian-bagian yang diperlukan untuk memanfaatkan keunggulan infrastruktur Debian dengan cara terbaik. Dengan sedikit keberuntungan, setelah mencoba sendiri membuat paket Debian, bisa jadi Anda merasa tertarik untuk melanjutkan dan bergabung dengan proyek Debian itu sendiri!

en: Rebuilding a Package from its Sources
id-ID: Membangun ulang sebuah Paket dari Source-nya

en: Rebuilding a binary package is required under several sets of circumstances. In some cases, the administrator needs a software feature that requires the software to be compiled from sources, with a particular compilation option; in others, the software as packaged in the installed version of Debian is not recent enough. In the latter case, the administrator will usually build a more recent package taken from a newer version of Debian — such as <emphasis role="distribution">Testing</emphasis> or even <emphasis role="distribution">Unstable</emphasis> — so that this new package works in their <emphasis role="distribution">Stable</emphasis> distribution; this operation is called “backporting”. As usual, care should be taken, before undertaking such a task, to check whether it has been done already — a quick look on the Debian Package Tracker for that package will reveal that information. <ulink type="block" url="https://tracker.debian.org/" /> <indexterm><primary>backport</primary></indexterm>
id-ID: Membangun ulang sebuah paket biner dibutuhkan dalam beberapa kondisi. Dalam kondisi tertentu, administrator membutuhkan fitur perangkat lunak yang mensyaratkan untuk di-compile dari source, dengan opsi kompilasi tertentu; pada kasus lain, perangkat yang dipaketkan dalam Debian yang terpasang tidak cukup anyar. Pada kasus kedua, administrator umumnya akan mem-build paket yang lebih terkini diambil dari Debian dengan versi yang lebih baru — seperti <emphasis role="distribution">Testing</emphasis> atau bahkan <emphasis role="distribution">Unstable</emphasis> — sehingga paket yang lebih baru ini dapat bekerja pada distribusi <emphasis role="distribution">Stable</emphasis> mereka; operasi ini disebut dengan “backporting”. Seperti biasa, perlu waspada sebelum memutuskan melakukan tugas seperti itu, dengan memeriksa apakah sebelumnya sudah pernah dilakukan — pencarian cepat pada Debian Package Tracker untuk paket tersebut akan mengungkap informasi itu. <ulink type="block" url="https://tracker.debian.org/" />. <indexterm><primary>backport</primary></indexterm>

en: Getting the Sources
id-ID: Mendapatkan Sumber

en: Making Changes
id-ID: Membuat Perubahan

en: Let us use the <emphasis role="pkg">samba</emphasis> package as an example.
id-ID: Mari kita gunakan paket <emphasis role="pkg">samba</emphasis> sebagai contoh.

en: The last command invokes a text editor (<command>sensible-editor</command> — this should be your favorite editor if it is mentioned in the <varname>VISUAL</varname> or <varname>EDITOR</varname> environment variables, and the default editor otherwise) to allow documenting the differences brought by this rebuild. This editor shows us that <command>dch</command> really did change the <filename>debian/changelog</filename> file.
id-ID: Perintah terakhir memanggil penyunting teks (<command>sensible-editor</command> — ini harus menjadi editor favorit Anda jika disebutkan di variabel lingkungan <varname>VISUAL</varname> atau <varname>EDITOR</varname>, dan penyunting default sebaliknya) untuk memungkinkan mendokumentasikan perbedaan yang dibawa oleh rebuild ini. Penyunting ini menunjukkan kepada kita bahwa <command>dch</command> sungguh mengubah berkas <filename>debian/changelog</filename>.

en: Depending on the local changes to the packages, an update may also be required in the <filename>debian/control</filename> file, which contains a description of the generated packages. In particular, this file contains <literal>Build-Depends</literal> lines controlling the list of dependencies that must be fulfilled at package build time. These often refer to versions of packages contained in the distribution the source package comes from, but which may not be available in the distribution used for the rebuild. There is no automated way to determine if a dependency is real or only specified to guarantee that the build should only be attempted with the latest version of a library — this is the only available way to force an <emphasis>autobuilder</emphasis> to use a given package version during build, which is why Debian maintainers frequently use strictly versioned build-dependencies.
id-ID: Tergantung pada perubahan lokal pada paket, pemutakhiran bisa jadi dibutuhkan dalam berkas <filename>debian/control</filename>, yang berisi deskripsi dari paket yang dihasilkan. Secara spesifik, berkas ini berisi baris <literal>Build-Depends</literal> yang mengendalikan daftar dependensi yang perlu dipenuhi pada paket yang dibangun. Hal ini seringkali mengacu pada versi paket yang ada di dalam distribusi dari sumber paket asal, namun tidak tersedia di dalam distribusi yang digunakan untuk rebuild. Tidak ada cara otomatis untuk menentukan jika dependensi benar-benar dibutuhkan atau hanya disebutkan untuk menjamin bahwa build hanya dicoba dengan versi terbaru dari pustaka — ini merupakan satu-satunya cara untuk memaksa <emphasis>autobuilder</emphasis> untuk menggunakan versi paket yang diberikan selama proses build, hal inilah mengapa Debian maintainer seringkali menggunakan versi build-dependencies yang ketat.

en: If you know for sure that these build-dependencies are too strict, you should feel free to relax them locally. Reading the files which document the standard way of building the software — these files are often called <filename>INSTALL</filename> — will help you figure out the appropriate dependencies. Ideally, all dependencies should be satisfiable from the distribution used for the rebuild; if they are not, a recursive process starts, whereby the packages mentioned in the <literal>Build-Depends</literal> field must be backported before the target package can be. Some packages may not need backporting, and can be installed as-is during the build process (a notable example is <emphasis role="pkg">debhelper</emphasis>). Note that the backporting process can quickly become complex if you are not careful. Therefore, backports should be kept to a strict minimum when possible.
id-ID: Jika Anda tahu secara yakin bahwa build-dependencies terlalu ketat, Anda bebas untuk melonggarkannya secara lokal. Dengan membaca berkas yang mendokumentasikan standar membangun perangkat lunak — berkas ini sering disebut sebagai <filename>INSTALL</filename> — akan membantu Anda mengetahui dependensi yang sesuai. Idealnya, semua dependensi harus dapat dipenuhi dari distribusi yang digunakan untuk rebuild; jika tidak, sebuah proses rekursif dimulai, yaitu saat paket yang disebutkan dalam field <literal>Build-Depends</literal> harus di-backport sebelum paket target dapat di-backport. Beberapa paket bisa jadi tidak perlu di-backport, dan dapat di-install apa-adanya selama proses build (contoh yang jelas adalah <emphasis role="pkg">debhelper</emphasis>). Perlu dicatat bahwa proses backport dapat dengan cepat menjadi kompleks jika Anda tidak hati-hati. Oleh karena itu, backport sedapat mungkin diminimalisir.

en: <emphasis>TIP</emphasis> Installing <literal>Build-Depends</literal>
id-ID: <emphasis>TIP</emphasis> Menginstall <literal>Build-Depends</literal>

en: Starting the Rebuild
id-ID: Memulai Rebuild

en: When all the needed changes have been applied to the sources, we can start generating the actual binary package (<filename>.deb</filename> file). The whole process is managed by the <command>dpkg-buildpackage</command> command.
id-ID: Saat semua perubahan yang diperlukan telah diterapkan pada sumber, kita dapat memulai membuat paket binari sesungguhnya (<filename>.deb</filename> file). Semua proses ini dikelola oleh perintah <command>dpkg-buildpackage</command>.

en: Rebuilding a package
id-ID: Membangun ulang sebuah paket

en: <emphasis>TOOL</emphasis> <command>fakeroot</command>
id-ID: <emphasis>PERKAKAS</emphasis> <command>fakeroot</command>

en: In essence, the package creation process is a simple matter of gathering in an archive a set of existing (or built) files; most of the files will end up being owned by <emphasis>root</emphasis> in the archive. However, building the whole package under this user would imply increased risks; fortunately, this can be avoided with the <command>fakeroot</command> command. This tool can be used to run a program and give it the impression that it runs as <emphasis>root</emphasis> and creates files with arbitrary ownership and permissions. When the program creates the archive that will become the Debian package, it is tricked into creating an archive containing files marked as belonging to arbitrary owners, including <emphasis>root</emphasis>. This setup is so convenient that <command>dpkg-buildpackage</command> uses <command>fakeroot</command> by default when building packages.
id-ID: Esensinya, proses pembuatan paket adalah sesederhana mengumpulkan suatu set berkas yang ada (atau yang dibangun) ke dalam sebuah arsip; mayoritas berkas akan berakhir menjadi milik <emphasis>root</emphasis> dalam arsip. Namun, membangun seluruh paket di bawah pengguna ini berarti meningkatkan risiko; untungnya hal ini dapat dihindari dengan perintah <command>fakeroot</command>. Perkakas ini dapat digunakan untuk menjalankan sebuah program dan memberikan kesan seolah berjalan sebagai <emphasis>root</emphasis> dan membuat berkas dengan kepemilikan dan izin sebarang. Saat program membuat arsip yang akan menjadi paket Debian, hal ini diakali dengan membuat sebuah archive yang mengandung berkas ditandai dengan kepemilikan sebarang, termasuk <emphasis>root</emphasis>. Penyiapan ini sungguh nyaman sehingga <command>dpkg-buildpackage</command> menggunakan <command>fakeroot</command> secara baku saat membangun paket.

en: Note that the program is only tricked into “believing” that it operates as a privileged account, and the process actually runs as the user running <command>fakeroot <replaceable>program</replaceable></command> (and the files are actually created with that user's permissions). At no time does it actually get root privileges that it could abuse.
id-ID: Perhatikan bahwa program hanya mengakali sehingga “seolah-olah percaya” beroperasi dengan akun ber-privilege, dan proses sesungguhnya berjalan sebagai pengguna menjalankan <command>fakeroot <replaceable>program</replaceable></command> (dan berkas sesungguhnya dibuat dengan permission pengguna). Dalam proses ini sama sekali tidak menggunakan privilege root sehingga tidak mungkin terjadi abuse.

en: Building your First Package
id-ID: Membangun Ulang Paket Pertama Anda

en: Meta-Packages or Fake Packages
id-ID: Meta-Packages atau Paket Palsu

en: Fake packages and meta-packages are similar, in that they are empty shells that only exist for the effects their meta-data have on the package handling stack.
id-ID: Paket palsu dan meta-package sebenarnya mirip. Keduanya merupakan cangkang kosong yang ada hanya untuk membuat meta-data mereka berdampak di dalam tumpukan penanganan paket.

en: The purpose of a fake package is to trick <command>dpkg</command> and <command>apt</command> into believing that some package is installed even though it is only an empty shell. This allows satisfying dependencies on a package when the corresponding software was installed outside the scope of the packaging system. Such a method works, but it should still be avoided whenever possible, since there is no guarantee that the manually installed software behaves exactly like the corresponding package would and other packages depending on it would not work properly.
id-ID: Tujuan dari paket palsu adalah mengakali <command>dpkg</command> dan <command>apt</command> sehingga percaya bahwa paket terpasang biarpun hanya berupa cangkang kosong. Hal ini memungkinkan memenuhi dependensi dari paket saat perangkat lunak terkait terpasang di luar ruang lingkup sistem pemaketan. Metode seperti ini bekerja, namun sedapat mungkin dihindari, karena tidak ada jaminan bahwa perangkat lunak yang terpasang berperilaku persis seperti paket terkait dan paket lainnya yang tergantung padanya tidak bekerja sebagaimana mestinya.

en: On the other hand, a meta-package exists mostly as a collection of dependencies, so that installing the meta-package will actually bring in a set of other packages in a single step.
id-ID: Di sisi lain, sebuah meta-package mayoritas ada sebagai kumpulan dari dependensi, sehingga meng-install meta-package sesungguhnya akan mendatangkan paket lain dalam satu langkah.

en: Both these kinds of packages can be created by the <command>equivs-control</command> and <command>equivs-build</command> commands (in the <emphasis role="pkg">equivs</emphasis> package). The <command>equivs-control <replaceable>file</replaceable></command> command creates a Debian package header file that should be edited to contain the name of the expected package, its version number, the name of the maintainer, its dependencies, and its description. Other fields without a default value are optional and can be deleted. The <literal>Copyright</literal>, <literal>Changelog</literal>, <literal>Readme</literal> and <literal>Extra-Files</literal> fields are not standard fields in Debian packages; they only make sense within the scope of <command>equivs-build</command>, and they will not be kept in the headers of the generated package.
id-ID: Kedua jenis paket ini dapat dibuat dengan perintah <command>equivs-control</command> dan <command>equivs-build</command>(dalam paket <emphasis role="pkg">equivs</emphasis>). Perintah <command>equivs-control <replaceable>berkas</replaceable></command> membuat berkas header paket Debian yang harus disunting agar memuat nama dari paket yang diinginkan, nomor versinya, nama dari maintainer, dependensi, dan deskripsinya. Field lainnya tanpa nilai default adalah opsional dan dapat dihapus. Field <literal>Copyright</literal>, <literal>Changelog</literal>, <literal>Readme</literal> dan <literal>Extra-Files</literal> bukan merupakan field standar dalam paket Debian; mereka hanya relevan dalam ruang lingkup <command>equivs-build</command>, dan mereka tidak akan disimpan dalam header dari paket yang dihasilkan.

en: Header file of the <emphasis>libxml-libxml-perl</emphasis> fake package
id-ID: Berkas header dari <emphasis>libxml-libxml-perl</emphasis> paket palsu

en: The next step is to generate the Debian package with the <command>equivs-build <replaceable>file</replaceable></command> command. Voilà: the package is created in the current directory and it can be handled like any other Debian package would.
id-ID: Langkah selanjutnya adalah membuat paket Debian dengan perintah <command>equivs-build <replaceable>berkas</replaceable></command>. Voilà: paket dibuat pada direktori saat ini dan dapat dapat ditangani sebagaimana paket Debian lainnya.

en: Simple File Archive
id-ID: Berkas Archive Sederhana

en: The Falcot Corp administrators need to create a Debian package in order to ease deployment of a set of documents on a large number of machines. The administrator in charge of this task first reads the “New Maintainer's Guide”, then starts working on their first package. <ulink type="block" url="https://www.debian.org/doc/manuals/maint-guide/" />
id-ID: Administrator Falcot Corp butuh membuat paket Debian agar dapat mempermudah proses penggelaran sekumpulan dokumen pada banyak mesin. Administrator yang bertanggung jawab atas pekerjaan ini pertama perlu membaca “New Maintainer's Guide” (Panduan Maintainer Baru), lalu mulai bekerja pada paket pertamanya.<ulink type="block" url="https://www.debian.org/doc/manuals/maint-guide/" />

en: The first step is creating a <filename>falcot-data-1.0</filename> directory to contain the target source package. The package will logically, be named <literal>falcot-data</literal> and bear the <literal>1.0</literal> version number. The administrator then places the document files in a <filename>data</filename> subdirectory. Then they invoke the <command>dh_make</command> command (from the <emphasis role="pkg">dh-make</emphasis> package) to add files required by the package generation process, which will all be stored in a <filename>debian</filename> subdirectory:
id-ID: Langkah pertama adalah membuat direktori <filename>falcot-data-1.0</filename> berisi target dari paket sumber. Paket secara logika akan dinamakan <literal>falcot-data</literal> dan dengan nomor versi <literal>1.0</literal>. Administrator selanjutnya meletakkan berkas dokumen dalam subdirektori <filename>data</filename>. Lalu mereka meng-invoke perintah <command>dh_make</command> (dari paket <emphasis role="pkg">dh-make</emphasis>) untuk menambah berkas yang dibutuhkan oleh proses pembuatan paket, yang akan disimpan dalam subdirektori <filename>debian</filename>:

en: <primary>package</primary><secondary>types</secondary>
id-ID: <primary>paket</primary><secondary>tipe</secondary>

en: The <emphasis>library</emphasis> type corresponds to a source package leading to several binary packages. It is useful for shared libraries, since they need to follow strict packaging rules.
id-ID: Tipe <emphasis>library</emphasis> terkait ke paket sumber yang menghasilkan beberapa paket biner. Itu berguna untuk pustaka bersama, karena mereka perlu mengikuti aturan pemaketan yang ketat.

en: <emphasis>TIP</emphasis> Maintainer's name and email address
id-ID: <emphasis>TIP</emphasis> Nama dan alamat surel Maintainer

en: Most of the programs involved in package maintenance will look for your name and email address in the <varname>DEBFULLNAME</varname> and <varname>DEBEMAIL</varname> or <varname>EMAIL</varname> environment variables. Defining them once and for all will avoid you having to type them multiple times. If your usual shell is <command>bash</command>, it is a simple matter of adding the following two lines in your <filename>~/.bashrc</filename> file (you will obviously replace the values with more relevant ones!):
id-ID: Kebanyakan program yang terlibat dalam pengelolaan paket akan mencari nama Anda dan alamat surel dalam variabel environment <varname>DEBFULLNAME</varname> dan <varname>DEBEMAIL</varname> atau <varname>EMAIL</varname>. Definisikan variabel ini sekali dan selamanya akan menghindari Anda dari harus mengisinya berulang kali. Jika shell Anda adalah <command>bash</command>, sesederhana menambahkan dua baris berikut dalam berkas <filename>~/.bashrc</filename> (tentunya Anda akan mengisi dengan nilai yang relevan!):

en: The <filename>control</filename> file
id-ID: Berkas <filename>control</filename>

en: The <filename>changelog</filename> file
id-ID: Berkas <filename>changelog</filename>

en: The <filename>copyright</filename> file
id-ID: Berkas <filename>copyright</filename>

en: <emphasis>BACK TO BASICS</emphasis> <filename>Makefile</filename> file
id-ID: <emphasis>KEMBALI KE DASAR</emphasis> Berkas <filename>Makefile</filename>

en: A <filename>Makefile</filename> file is a script used by the <command>make</command> program; it describes rules for how to build a set of files from each other in a tree of dependencies (for instance, a program can be built from a set of source files). The <filename>Makefile</filename> file describes these rules in the following format:
id-ID: Berkas <filename>Makefile</filename> adalah sebuah script yang digunakan oleh program <command>make</command>; Berkas ini mendeskripsikan bagaimana mem-build sekumpulan berkas dari berkas lainnya dalam dependensi tree (contohnya, sebuah program dapat di-build dari beberapa berkas sumber). Berkas <filename>Makefile</filename> mendeskripsikan aturan ini dalam format berikut:

en: Note that the command lines must start with a tab character; also note that when a command line starts with a dash character (<literal>-</literal>), failure of the command does not interrupt the whole process.
id-ID: Perhatikan bahwa command line harus dimulai dengan karakter tab; perhatikan juga bahwa saat command line dimulai dengan karakter dash (<literal>-</literal>), kegagalan dari perintah meng-interupsi seluruh proses.

en: The <filename>rules</filename> file usually contains a set of rules used to configure, build and install the software in a dedicated subdirectory (named after the generated binary package). The contents of this subdirectory is then archived within the Debian package as if it were the root of the filesystem. In our case, files will be installed in the <filename>debian/falcot-data/usr/share/falcot-data/</filename> subdirectory, so that installing the generated package will deploy the files under <filename>/usr/share/falcot-data/</filename>. The <filename>rules</filename> file is used as a <filename>Makefile</filename>, with a few standard targets (including <literal>clean</literal> and <literal>binary</literal>, used respectively to clean the source directory and generate the binary package).
id-ID: Berkas <filename>rules</filename> umumnya berisi sekumpulan rules yang digunakan untuk meng-konfigurasi, build dan install perangkat lunak dalam subdirektori terdedikasi (dinamakan setelah paket binari dihasilkan). Isi dari subdirektori ini selanjutnya diarsipkan dalam paket Debian seolah sebagai root dari filesystem. Dalam kasus kami, berkas akan di-install dalam subdirektori <filename>debian/falcot-data/usr/share/falcot-data/</filename>, jadi meng-install paket yang dihasilkan akan men-deploy berkas di bawah <filename>/usr/share/falcot-data/</filename>. Berkas <filename>rules</filename> digunakan sebagai <filename>Makefile</filename>, dengan beberapa target standar (termasuk <literal>clean</literal> dan <literal>binary</literal>, digunakan untuk membersihkan direktori sumber dan menghasilkan paket binari).

en: Although this file is the heart of the process, it increasingly contains only the bare minimum for running a standard set of commands provided by the <command>debhelper</command> tool. Such is the case for files generated by <command>dh_make</command>. To install our files, we simply configure the behavior of the <command>dh_install</command> command by creating the following <filename>debian/falcot-data.install</filename> file:
id-ID: Walaupun berkas ini merupakan jantung dari proses, lama kelamaan hanya berisi bare minimum untuk menjalankan sekumpulan perintah yang disediakan oleh perkakas <command>debhelper</command>. Sebagai contoh dalam kasus untuk berkas yang dihasilkan oleh <command>dh_make</command>. Untuk menginstall berkas, kita hanya perlu mengkonfigurasi perilaku dari perintah <command>dh_install</command> dengan membuat berkas berikut <filename>debian/falcot-data.install</filename>:

en: At this point, the package can be created. We will, however, add a lick of paint. Since the administrators want the documents to be easily accessed from the menus of graphical desktop environments, we add a <filename>falcot-data.desktop</filename> file and get it installed in <filename>/usr/share/applications</filename> by adding a second line to <filename>debian/falcot-data.install</filename>.
id-ID: Pada titik ini, paket dapat dibuat. Namun kita akan menambahkan sedikit polesan. Karena administrator ingin dokumen dapat diakses dengan mudah dari menu dalam lingkungan grafis desktop, kita membuat sebuah berkas <filename>falcot-data.desktop</filename> dan meletakkannya di <filename>/usr/share/applications</filename> dengan menambahkan baris kedua pada <filename>debian/falcot-data.install</filename>.

en: The <filename>falcot-data.desktop</filename> file
id-ID: Berkas <filename>falcot-data.desktop</filename>

en: The updated <filename>debian/falcot-data.install</filename> looks like this:
id-ID: Pembaharuan <filename>debian/falcot-data.install</filename> terlihat seperti ini:

en: Our source package is now ready. All that is left to do is to generate the binary package, with the same method we used previously for rebuilding packages: we run the <command>dpkg-buildpackage -us -uc</command> command from within the <filename>falcot-data-1.0</filename> directory.
id-ID: Paket sumber kita sekarang sudah siap. Yang perlu dilakukan hanya membuat paket biner, dengan metode yang sama yang kita gunakan sebelumnya untuk membangun ulang paket: kita jalankan perintah <command>dpkg-buildpackage -us -uc</command> dari direktori <filename>falcot-data-1.0</filename>.

en: Creating a Package Repository for APT
id-ID: Membuat Repositori Paket untuk APT

en: <primary>package</primary><secondary>Debian</secondary><tertiary>archive of</tertiary>
id-ID: <primary>paket</primary><secondary>Debian</secondary><tertiary>arsip dari</tertiary>

en: Falcot Corp gradually started maintaining a number of Debian packages either locally modified from existing packages or created from scratch to distribute internal data and programs.
id-ID: Falcor Corp perlahan mulai mengelola sejumlah paket Debian baik dimodifikasi lokal dari paket yang sudah ada atau membuat dari awal untuk mendistribusikan data internal dan program.

en: To make deployment easier, they want to integrate these packages in a package archive that can be directly used by APT. For obvious maintenance reasons, they wish to separate internal packages from locally-rebuilt packages. The goal is for the matching entries in a <filename>/etc/apt/sources.list.d/falcot.list</filename> file to be as follows:
id-ID: Agar penggelaran lebih mudah, mereka ingin mengintegrasikan paket-paket ini ke dalam sebuah arsip paket yang dapat digunakan secara langsung oleh APT. Untuk alasan-alasan pengelolaan yang gamblang, mereka ingin memisahkan paket internal dari paket yang dibangun-ulang-lokal. Tujuannya adalah agar entri yang cocok dalam berkas <filename>/etc/apt/sources.list.d/falcot.list</filename> menjadi sebagai berikut:

en: The administrators therefore configure a virtual host on their internal HTTP server, with <filename>/srv/vhosts/packages/</filename> as the root of the associated web space. The management of the archive itself is delegated to the <command>mini-dinstall</command> command (in the similarly-named package). This tool keeps an eye on an <filename>incoming/</filename> directory (in our case, <filename>/srv/vhosts/packages/mini-dinstall/incoming/</filename>) and waits for new packages there; when a package is uploaded, it is installed into a Debian archive at <filename>/srv/vhosts/packages/</filename>. The <command>mini-dinstall</command> command reads the <filename>*.changes</filename> file created when the Debian package is generated. These files contain a list of all other files associated with the version of the package (<filename>*.deb</filename>, <filename>*.dsc</filename>, <filename>*.diff.gz</filename>/<filename>*.debian.tar.gz</filename>, <filename>*.orig.tar.gz</filename>, or their equivalents with other compression tools), and these allow <command>mini-dinstall</command> to know which files to install. <filename>*.changes</filename> files also contain the name of the target distribution (often <literal>unstable</literal>) mentioned in the latest <filename>debian/changelog</filename> entry, and <command>mini-dinstall</command> uses this information to decide where the package should be installed. This is why administrators must always change this field before building a package, and set it to <literal>internal</literal> or <literal>updates</literal>, depending on the target location. <command>mini-dinstall</command> then generates the files required by APT, such as <filename>Packages.gz</filename>.
id-ID: Maka administrator mengonfigurasi suatu host virtual pada server HTTP internal mereka, dengan <filename>/srv/vhosts/packages/</filename> sebagai root dari ruang web terkait. Manajemen arsip itu sendiri didelegasikan ke perintal <command>mini-dinstall</command> (dalam paket yang bernama mirip). Alat ini mengawasi suatu direktori <filename>incoming/</filename> (dalam kasus kita, <filename>/srv/vhost/packages/mini-dinstall/incoming/</filename>) dan menunggu paket-paket baru di sana; ketika suatu paket diunggah, itu dipasang ke dalam sebuah arsip Debian pada <filename>/srv/vhosts/packages/</filename>. Perintah <command>mini-dinstall</command> membaca berkas <filename>*.changes</filename> yang dibuat saat paket Debian dijangkitkan. Berkas-berkas ini memuat suatu daftar dari semua berkas lain yang terkait dengan versi paket (<filename>*.deb</filename>, <filename>*.dsc</filename>, <filename>*.diff.gz</filename>/<filename>*.debian.tar.gz</filename>, <filename>*.orig.tar.gz</filename>, atau ekuivalennya dengan alat kompresi lain), dan ini mengizinkan <command>mini-dinstall</command> untuk tahu berkas mana yang akan dipasang. Berkas <filename>*.changes</filename> juga memuat nama distribusi target (seringkali <literal>unstable</literal>) yang disinggung dalam entri <filename>debian/changelog</filename> terakhir, dan <command>mini-dinstall</command> memakai informasi ini untuk menentukan di mana paket mesti dipasang. Inilah kenapa administrator mesti selalu mengubah ruas ini sebelum membangun suatu paket, dan menatanya ke <literal>internal</literal> atau <literal>updates</literal>, bergantung pada lokasi target. <command>mini-dinstall</command> kemudian menjangkitkan berkas-berkas yang diperlukan oleh APT, seperti misalnya <filename>Packages.gz</filename>.

en: If <command>mini-dinstall</command> seems too complex for your Debian archive needs, you can also use the <command>apt-ftparchive</command> command. This tool scans the contents of a directory and displays (on its standard output) a matching <filename>Packages</filename> file. In the Falcot Corp case, administrators could upload the packages directly into <filename>/srv/vhosts/packages/updates/</filename> or <filename>/srv/vhosts/packages/internal/</filename>, then run the following commands to create the <filename>Packages.gz</filename> files:
id-ID: Jika <command>mini-dinstall</command> tampaknya terlalu rumit untuk kebutuhan arsip Debian, Anda juga dapat menggunakan perintah <command>apt-ftparchive</command>. Alat ini memindai isi direktori dan menampilkan (pada keluaran standar) berkas <filename>Package</filename> yang cocok. Dalam kasus Falcot Corp, administrator dapat mengunggah paket langsung ke <filename>/srv/vhosts/packages/updates/</filename> atau <filename>/srv/vhosts/packages/internal/</filename>, kemudian menjalankan perintah berikut untuk membuat berkas <filename>Packages.gz</filename>:

en: The <command>apt-ftparchive sources</command> command allows creating <filename>Sources.gz</filename> files in a similar fashion.
id-ID: Perintah <command>apt-ftparchive sources</command> mengizinkan membuat berkas <filename>Sources.gz</filename> dengan cara yang mirip.

en: Configuring <command>mini-dinstall</command> requires setting up a <filename>~/.mini-dinstall.conf</filename> file; in the Falcot Corp case, the contents are as follows:
id-ID: Mengkonfigurasi <command>mini-dinstall</command> membutuhkan menyiapkan sebuah berkas <filename>~/.mini-dinstall.conf</filename>; dalam kasus Falcot Corp, isinya adalah sebagai berikut:

en: One decision worth noting is the generation of <filename>Release</filename> files for each archive. This can help manage package installation priorities using the <filename>/etc/apt/preferences</filename> configuration file (see <xref linkend="sect.apt.priorities" /> for details).
id-ID: Satu keputusan yang perlu diperhatikan adalah membuat berkas <filename>Release</filename> untuk setiap arsip. Hal ini bisa membantu mengelola prioritas instalasi paket menggunakan berkas konfigurasi <filename>/etc/apt/preferences</filename> (lihat <xref linkend="sect.apt.priorities" /> untuk detailnya).

en: <emphasis>SECURITY</emphasis> <command>mini-dinstall</command> and permissions
id-ID: <emphasis>SECURITY</emphasis> <command>mini-dinstall</command> dan permission

en: Since <command>mini-dinstall</command> has been designed to run as a regular user, there is no need to run it as root. The easiest way is to configure everything within the user account belonging to the administrator in charge of creating the Debian packages. Since only this administrator has the required permissions to put files in the <filename>incoming/</filename> directory, we can deduce that the administrator authenticated the origin of each package prior to deployment and <command>mini-dinstall</command> does not need to do it again. This explains the <literal>verify_sigs = 0</literal> parameter (which means that signatures need not be verified). However, if the contents of packages are sensitive, we can reverse the setting and elect to authenticate with a keyring containing the public keys of persons allowed to create packages (configured with the <literal>extra_keyrings</literal> parameter); <command>mini-dinstall</command> will then check the origin of each incoming package by analyzing the signature integrated to the <filename>*.changes</filename> file.
id-ID: Karena <command>mini-dinstall</command> telah dirancang untuk dijalankan sebagai pengguna biasa, tidak perlu dijalankan sebagai root. Cara termudah adalah untuk mengkonfigurasi semuanya dalam akun pengguna milik administrator yang bertanggung jawab menciptakan paket-paket Debian. Karena hanya administrator ini yang memiliki izin yang diperlukan untuk menempatkan berkas-berkas dalam direktori <filename>incoming/</filename>, kita dapat simpulkan bahwa administrator mengotentikasi asal dari masing-masing paket sebelum penggelaran dan <command>mini-dinstall</command> tidak perlu untuk melakukannya lagi. Ini menjelaskan parameter <literal>verify_sigs = 0</literal> (yang berarti bahwa tanda tangan tidak perlu diverifikasi). Namun, jika isi paket sensitif, kami dapat membalik pengaturan dan memilih untuk melakukan otentikasi dengan keyring berisi kunci publik dari orang-orang yang diperbolehkan untuk membuat paket (dikonfigurasi dengan parameter <literal>extra_keyrings</literal>); <command>mini-dinstall</command> kemudian akan memeriksa asal masing-masing paket masuk dengan menganalisis tanda tangan yang terintegrasi ke berkas <filename>*.changes</filename>.

en: Invoking <command>mini-dinstall</command> actually starts a daemon in the background. As long as this daemon runs, it will check for new packages in the <filename>incoming/</filename> directory every half-hour; when a new package arrives, it will be moved to the archive and the appropriate <filename>Packages.gz</filename> and <filename>Sources.gz</filename> files will be regenerated. If running a daemon is a problem, <command>mini-dinstall</command> can also be manually invoked in batch mode (with the <literal>-b</literal> option) every time a package is uploaded into the <filename>incoming/</filename> directory. Other possibilities provided by <command>mini-dinstall</command> are documented in its <citerefentry><refentrytitle>mini-dinstall</refentrytitle> <manvolnum>1</manvolnum></citerefentry> manual page.
id-ID: Menjalankan <command>mini-dinstall</command> sebenarnya memulai daemon di latar belakang. Selama daemon ini berjalan, itu akan memeriksa paket baru di direktori <filename>incoming/</filename> setiap setengah jam; ketika suatu paket baru telah tiba, itu akan dipindahkan ke arsip dan berkas-berkas <filename>Packages.gz</filename> dan <filename>Sources.gz</filename> yang sesuai akan diregenerasi. Jika menjalankan daemon adalah masalah, <command>mini-dinstall</command> dapat juga secara manual dipanggil dalam mode batch (dengan opsi <literal>-b</literal>) setiap kali sebuah paket diunggah ke dalam direktori <filename>incoming/</filename>. Kemungkinan lain yang disediakan oleh <command>mini-dinstall</command> didokumentasikan di halaman manual <citerefentry><refentrytitle>mini-dinstall</refentrytitle> <manvolnum>1</manvolnum></citerefentry>.

en: <emphasis>EXTRA</emphasis> Generating a signed archive
id-ID: <emphasis>EKSTRA</emphasis> Membuat sebuah signed archive

en: The APT suite checks a chain of cryptographic signatures on the packages it handles before installing them, in order to ensure their authenticity (see <xref linkend="sect.package-authentication" />). Private APT archives can then be a problem, since the machines using them will keep displaying warnings about unsigned packages. A diligent administrator will therefore integrate private archives with the secure APT mechanism.
id-ID: Keluarga APT memeriksa rantai tanda tangan kriptografik dari paket yang ditanganinya sebelum memasang mereka, untuk memastikan keaslian mereka (lihat <xref linkend="sect.package-authentication" />). Arsip APT privat dapat menjadi masalah, karena mesin yang menggunakan mereka akan terus menampilkan peringatan tentang paket tanpa-tanda-tangan. Maka administrator yang rajin akan mengintegrasikan arsip pribadi dengan mekanisme APT aman.

en: To help with this process, <command>mini-dinstall</command> includes a <literal>release_signscript</literal> configuration option that allows specifying a script to use for generating the signature. A good starting point is the <filename>sign-release.sh</filename> script provided by the <emphasis role="pkg">mini-dinstall</emphasis> package in <filename>/usr/share/doc/mini-dinstall/examples/</filename>; local changes may be relevant.
id-ID: Untuk membantu dengan proses ini, <command>mini-dinstall</command> memuat <literal>release_signscript</literal> opsi konfigurasi yang memungkinkan menspesifikasikan sebuah script untuk digunakan untuk menghasilkan signature. Titik mulai yang bagus adalah script <filename>sign-release.sh</filename> yang disediakan oleh <emphasis role="pkg">mini-dinstall</emphasis> paket <filename>/usr/share/doc/mini-dinstall/examples/</filename>; perubahan lokal bisa jadi relevan.

en: Becoming a Package Maintainer
id-ID: Menjadi seorang Maintainer Paket

en: Learning to Make Packages
id-ID: Belajar untuk Membuat Perubahan

en: Rules
id-ID: Aturan

en: A Debian package must comply with the precise rules compiled in the Debian policy, and each package maintainer must know them. There is no requirement to know them by heart, but rather to know they exist and to refer to them whenever a choice presents a non-trivial alternative. Every Debian maintainer has made mistakes by not knowing about a rule, but this is not a huge problem as long as the error gets fixed when a user reports it as a bug report (which tends to happen fairly soon thanks to advanced users). The <literal>Standards-Version</literal> field in <filename>debian/control</filename> specifies the version of the Debian policy with which a package complies. Maintainers should comply to the latest version of the Debian policy. <ulink type="block" url="https://www.debian.org/doc/debian-policy/" />
id-ID: Sebuah paket Debian harus patuh dengan aturan presisi yang terkumpul dalam kebijakan Debian, dan setiap pengelola paket harus mengetahuinya. Tidak terdapat persyaratan untuk hafal mereka luar kepala, namun perlu mengetahui mereka ada dan mengacu padanya saat suatu pilihan menghadirkan alternatif yang non-trivial. Setiap pengelola Debian membuat kesalahan dengan tidak mengetahui suatu aturan, namun ini bukan masalah besar selama kesalahan diperbaiki saat pengguna melaporkannya dalam laporan bug (yang cenderung terjadi cukup segera terima kasih pada pengguna mahir).Ruas <literal>Standards-Version</literal> dalam <filename>debian/control</filename> menyatakan versi kebijakan Debian mana yang dipatuhi oleh paket. Pengelola mesti patuh ke versi terakhir kebijakan Debian. <ulink type="block" url="https://www.debian.org/doc/debian-policy/" />

en: Procedures
id-ID: Prosedur

en: Debian is not a simple collection of individual packages. Everyone's packaging work is part of a collective project; being a Debian developer involves knowing how the Debian project operates as a whole. Every developer will, sooner or later, interact with others. The Debian Developer's Reference (in the <emphasis role="pkg">developers-reference</emphasis> package) summarizes what every developer must know in order to interact as smoothly as possible with the various teams within the project, and to take the best possible advantages of the available resources. This document also enumerates a number of duties a developer is expected to fulfill. <ulink type="block" url="https://www.debian.org/doc/manuals/developers-reference/" />
id-ID: Debian bukanlah koleksi sederhana dari paket-paket individual. Semua pekerjaan pemaketan merupakan bagian dari proyek kolektif; menjadi pengembang Debian meliputi mengetahi bagaimana proyek Debian beroperasi ... Setiap pengembang akan, cepat atau lambat, berinteraksi satu sama lain. Referensi pengembang Debian (dalam paket <emphasis role="pkg">developers-reference</emphasis>) menyarikan apa yang harus diketahui oleh setiap pengembang Debian agar dapat berinteraksi dengan baik mungkin dengan beragam tim dalam proyek, dan untuk keuntungan terbaik dari sumber daya yang tersedia. Dokumen ini juga ... beberapa tanggung jawab pengembang yang diharapkan dipenuhi. <ulink type="block" url="https://www.debian.org/doc/manuals/developers-reference/" />

en: Tools
id-ID: Perkakas

en: Many tools help package maintainers in their work. This section describes them quickly, but does not give the full details, since they all have comprehensive documentation of their own.
id-ID: Banyak perkakas membantu maintainer paket dalam pekerjaannya. Bagian ini menjelaskan mereka secara cepat, namun tidak memberikan detail sepenuhnya, karena mereka semua memiliki dokumentasi komprehensifnya sendiri.

en: The <emphasis role="pkg">devscripts</emphasis> package contains many programs helping with a wide array of a Debian developer's job:
id-ID: Paket <emphasis role="pkg">devscripts</emphasis> berisi banyak program yang membantu beragam pekerjaan pengembang Debian:

en: <command>debuild</command> allows generating a package (with <command>dpkg-buildpackage</command>) and running <command>lintian</command> to check its compliance with the Debian policy afterwards.
id-ID: <command>debuild</command> memungkinkan menghasilkan sebuah paket (dengan <command>dpkg-buildpackage</command>) dan menjalankan <command>lintian</command> untuk memeriksa kepatuhan dengan kebijakan Debian.

en: <command>debclean</command> cleans a source package after a binary package has been generated.
id-ID: <command>debclean</command> membersihkan paket sumber setelah paket binari dihasilkan.

en: <command>dch</command> allows quick and easy editing of a <filename>debian/changelog</filename> file in a source package.
id-ID: <command>dch</command> memungkinkan penyuntingan cepat dan mudah dari berkas <filename>debian/changelog</filename> dalam paket sumber.

en: <command>uscan</command> checks whether a new version of a software has been released by the upstream author; this requires a <filename>debian/watch</filename> file with a description of the location of such releases.
id-ID: <command>uscan</command> memeriksa apakah terdapat versi baru perangkat lunak yang dirilis oleh penulis upstream; hal ini membutuhkan berkas <filename>debian/watch</filename> dengan deskripsi dari lokasi rilis.

en: <command>debi</command> allows installing (with <command>dpkg -i</command>) the Debian package that was just generated without the need to type its full name and path.
id-ID: <command>debi</command> memungkinkan memasang (dengan <command>dpkg -i</command>) paket Debian yang baru saja dibuat tanpa perlu mengetik nama lengkap dan pathnya.

en: In a similar fashion, <command>debc</command> allows scanning the contents of the recently-generated package (with <command>dpkg -c</command>), without needing to type its full name and path.
id-ID: Hal yang mirip, <command>debc</command> memungkinkan pencarian isi dari paket yang baru dibuat (dengan <command>dpkg -c</command>), tanpa harus mengetik nama lengkap dan path.

en: <command>debrelease</command> uploads a recently-generated package to a remote server, without needing to type the full name and path of the related <filename>.changes</filename> file.
id-ID: <command>debrelease</command> menggunggah paket yang baru dibuat ke server remote, tanpa harus mengisi nama lengkap dan path dari berkas <filename>.changes</filename> terkait.

en: <command>debsign</command> signs the <filename>*.dsc</filename> and <filename>*.changes</filename> files.
id-ID: <command>debsign</command> menandatangani berkas <filename>*.dsc</filename> dan <filename>*.changes</filename>.

en: <command>uupdate</command> automates the creation of a new revision of a package when a new upstream version has been released.
id-ID: <command>uupdate</command> ... proses pembuatan dari revisi baru paket saat versi upstream telah dirilis.

en: <emphasis role="pkg">debhelper</emphasis> and <emphasis role="pkg">dh-make</emphasis>
id-ID: <emphasis role="pkg">debhelper</emphasis> dan <emphasis role="pkg">dh-make</emphasis>

en: The <command>dh_make</command> script (in the <emphasis>dh-make</emphasis> package) creates files required for generating a Debian package in a directory initially containing the sources for a piece of software. As can be guessed from the name of the program, the generated files use debhelper by default.
id-ID: Skrip <command>dh_make</command> (dalam paket <emphasis>dh-make</emphasis>) membuat berkas yang dibutuhkan untuk membuat paket Debian dalam direktori yang pada awalnya berisi sumber untuk perangkat lunak. Seperti sudah bisa ditebak dari nama program, berkas yang dihasilkan menggunakan Debhelper secara default.

en: This tool is one of the most important: it is the Debian package checker. It is based on a large array of tests created from the Debian policy, and detects quickly and automatically many errors that can then be fixed before packages are released.
id-ID: Perkakas ini adalah salah satu yang paling penting: pemeriksa paket Debian. Itu berlandaskan pada kumpulan besar dari tes yang dibuat dari kebijakan Debian, dan mendeteksi secara cepat dan secara otomatis banyak kesalahan yang dapat diperbaiki sebelum paket dirilis.

en: This tool is only a helper, and it sometimes gets it wrong (for instance, since the Debian policy changes over time, <command>lintian</command> is sometimes outdated). It is also not exhaustive: not getting any Lintian error should not be interpreted as a proof that the package is perfect; at most, it avoids the most common errors.
id-ID: Perkakas ini hanyalah pembantu, dan sesekali salah (contohnya, sejak kebijakan Debian berubah seiring waktu, <command>lintian</command> sesekali ....) ... juga tidak lengkap: tidak mendapatkan kesalahan Lintian bukan berarti bukti bahwa paket sudah sempurna; ... mencegah kesalahan yang paling umum.

en: This is another important tool: it automates the installation, upgrade, removal and purge of a package (in an isolated environment), and checks that none of these operations leads to an error. It can help in detecting missing dependencies, and it also detects when files are incorrectly left over after the package got purged.
id-ID: Ini adalah alat penting lain: mengotomatisasi instalasi, upgrade, penghapusan, dan pembersihan paket (dalam lingkungan yang terisolasi), dan memeriksa bahwa tidak satupun dari operasi ini menyebabkan kesalahan. Itu dapat membantu dalam mendeteksi dependensi yang hilang, dan juga mendeteksi ketika berkas-berkas masih tersisa setelah paket dibersihkan.

en: <command>reprotest</command> builds the same source code twice in different environments, and then checks the binaries produced by each build for differences. If any are found, then <command>diffoscope</command> (if unavailable, <command>diff</command>) is used to display them in detail for later analysis.
id-ID: <command>reprotest</command> membangun kode sumber yang sama dua kali di lingkungan yang berbeda, dan kemudian memeriksa biner yang dihasilkan oleh masing-masing build untuk mencari perbedaan. Jika ada yang ditemukan, maka <command>diffoscope</command> (bila tidak tersedia, <command>diff</command>) digunakan untuk menampilkannya secara rinci untuk analisis nanti.

en: <command>dupload</command> and <command>dput</command>
id-ID: <command>dupload</command> dan <command>dput</command>

en: Acceptance Process
id-ID: Proses Penerimaan

en: Becoming a “Debian developer” is not a simple administrative matter. The process comprises several steps, and is as much an initiation as it is a selection process. In any case, it is formalized and well-documented, so anyone can track their progression on the website dedicated to the new member process. <ulink type="block" url="https://nm.debian.org/" />
id-ID: Menjadi pengembang Debian bukanlah hal administratif sederhana. Proses ini terdiri dari beberapa langkah, sekaligus merupakan inisiasi dan proses seleksi. Pada kasus apapun, hal ini diformalkan dan terdokumentasi dengan baik, jadi siapapun dapat melacak perkembangan mereka pada situs yang khusus ditujukan untuk pemrosesan anggota baru. <ulink type="block" url="http://nm.debian.org/" />

en: <emphasis>EXTRA</emphasis> Lightweight process for “Debian Maintainers”
id-ID: <emphasis>EXTRA</emphasis> Proses lightweight untuk “Debian Maintainers”

en: “Debian Maintainer” is another status that gives less privileges than “Debian developer” but whose associated process is quicker. With this status, the contributors can maintain their own packages only. A Debian developer only needs to perform a check on an initial upload, and issue a statement to the effect that they trust the prospective maintainer with the ability to maintain the package on their own.
id-ID: “Debian Maintainer” adalah status lain yang memberi hak kurang dari "Debian Developer" tapi dengan proses terkait yang lebih cepat. Dengan status ini, para kontributor hanya dapat mengelola paket mereka sendiri. Seorang pengembang Debian hanya perlu melakukan pemeriksaan pada unggahan awal, dan mengeluarkan penyataan yang kurang lebih mengatakan bahwa mereka percaya dengan kandidat maintainer yang mampu mengelola sendiri paket tersebut.

en: Prerequisites
id-ID: Persyaratan

en: All candidates are expected to have at least a working knowledge of the English language. This is required at all levels: for the initial communications with the examiner, of course, but also later, since English is the preferred language for most of the documentation; also, package users will be communicating in English when reporting bugs, and they will expect replies in English.
id-ID: Semua kandidat diharapkan memiliki pengetahuan ... dari bahasa Inggris. Hal ini dibutuhkan pada semua tingkat: untuk komunikasi awal dengan penguji, tentunya, dan tentu nanti, sejak bahasa Inggris adalah bahasa yang ... untuk hampir semua dokumentasi; juga, pengguna paket akan berkomunikasi dengan bahasa Inggris saat melaporkan bug, dan mereka berharap balasan dalam bahasa Inggris.

en: The other prerequisite deals with motivation. Becoming a Debian developer is a process that only makes sense if the candidate knows that their interest in Debian will last for many months. The acceptance process itself may last for several months, and Debian needs developers for the long haul; each package needs permanent maintenance, and not just an initial upload.
id-ID: Persyaratan lainnya berkaitan dengan motivasi. Menjadi pengembang Debian merupakan proses yang hanya masuk akal jika kandidat mengetahui bahwa minat mereka dalam Debian akan bertahan hingga berbulan-bulan. Proses penerimaanya itu sendiri bisa jadi berlangsung beberapa bulan, dan Debian membutuhkan pengembang untuk jangka waktu panjang; setiap paket perlu pengelolaan permanen, dan tidak hanya unggah di awal saja.

en: Registration
id-ID: Registrasi

en: The first (real) step consists in finding a sponsor or advocate; this means an official developer willing to state that they believe that accepting <emphasis>X</emphasis> would be a good thing for Debian. This usually implies that the candidate has already been active within the community, and that their work has been appreciated. If the candidate is shy and their work is not publicly touted, they can try to convince a Debian developer to advocate them by showing their work in a private way.
id-ID: Langkah pertama (nyata) terdiri dari mencari sponsor atau advokat; ini berarti seorang pengembang resmi bersedia menyatakan bahwa mereka yakin bahwa menerima <emphasis>X</emphasis> akan baik untuk Debian. Ini biasanya berarti menandakan bahwa kandidat telah aktif di dalam komunitas, dan karya mereka telah diapresiasi. Jika kandidat pemalu dan karya mereka tidak digembar-gemborkan secara publik, mereka dapat mencoba meyakinkan pengembang Debian untuk mengadvokasi dan menunjukkan karya mereka secara privat.

en: <primary>key pair</primary>
id-ID: <primary>pasangan kunci</primary>

en: At the same time, the candidate must generate a public/private RSA key pair with GnuPG, which should be signed by at least two official Debian developers. The signature authenticates the name on the key. Effectively, during a key signing party, each participant must show an official identification (usually an ID card or passport) together with their key identifiers. This step confirms the link between the human and the keys. This signature thus requires meeting in real life. If you have not yet met any Debian developers in a public free software conference, you can explicitly seek developers living nearby using the list on the following webpage as a starting point. <ulink type="block" url="https://wiki.debian.org/Keysigning" />
id-ID: Pada saat yang sama, kandidat harus menghasilkan sebuah pasangan kunci RSA publik/privat dengan GnuPG, yang mesti ditandatangani oleh setidaknya dua pengembang Debian resmi. Tanda tangan mengotentikasi nama pada kunci. Secara efektif, selama key signing party, setiap peserta harus menunjukkan identifikasi resmi (biasanya KTP atau paspor) bersamaan dengan pengidentifikasi kunci mereka. Langkah ini menegaskan hubungan antara manusia dan kunci. Maka tanda tangan ini memerlukan pertemuan di kehidupan nyata. Jika Anda belum pernah bertemu dengan pengembang Debian manapun dalam konferensi publik perangkat lunak bebas, Anda dapat secara eksplisit mencari pengembang yang tinggal di dekat Anda menggunakan daftar pada halaman web berikut sebagai titik awal. <ulink type="block" url="https://wiki.debian.org/Keysigning" />

en: Once the registration on <literal>nm.debian.org</literal> has been validated by the advocate, an <emphasis>Application Manager</emphasis> is assigned to the candidate. The application manager will then drive the process through multiple pre-defined steps and checks.
id-ID: Sekali registrasi pada <literal>nm.debian.org</literal> telah divalidasi oleh advokat, seorang <emphasis>Manajer Lamaran</emphasis> ditugaskan ke kandidat. Manajer lamaran selanjutnya akan mengikuti prosedur dan memvalidasi beragam langkah proses ini.

en: The first verification is an identity check. If you already have a key signed by two Debian developers, this step is easy; otherwise, the application manager will try and guide you in your search for Debian developers close by to organize a meet-up and a key signing.
id-ID: Verifikasi pertama adalah pemeriksaan identitas. Jika Anda telah memiliki kunci yang ditandatangani oleh dua orang pengembang Debian, langkah ini sangat mudah; sebaliknya, manajer aplikasi akan mencoba mencari dan memandu Anda dalam mencari pengembang Debian yang dekat atau mengadakan kopdar dan penandatanganan kunci.

en: Accepting the Principles
id-ID: Menerima Prinsip-prinsip

en: These administrative formalities are followed by philosophical considerations. The point is to make sure that the candidate understands and accepts the social contract and the principles behind Free Software. Joining Debian is only possible if one shares the values that unite the current developers, as expressed in the founding texts (and summarized in <xref linkend="the-debian-project" />).
id-ID: Semua formalitas administratif ini diikuti dengan pertimbangan filosofis. Poinnya adalah memastikan bahwa kandidat memahami dan menerima kontrak sosial dan prinsip di balik Perangkat Lunak Bebas. Bergabung dengan Debian hanya mungkin jika seseorang berbagi nilai yang menyatukan pengembang saat ini, seperti yang dinyatakan dalam teks pendirian (dan diringkas dalam <xref linkend="the-debian-project" />).

en: In addition, each candidate wishing to join the Debian ranks is expected to know the workings of the project, and how to interact appropriately to solve the problems they will doubtless encounter as time passes. All of this information is generally documented in manuals targeting the new maintainers, and in the Debian developer's reference. An attentive reading of this document should be enough to answer the examiner's questions. If the answers are not satisfactory, the candidate will be informed. They will then have to read (again) the relevant documentation before trying again. In the cases where the existing documentation does not contain the appropriate answer for the question, the candidate can usually reach an answer with some practical experience within Debian, or potentially by discussing with other Debian developers. This mechanism ensures that candidates get involved somewhat in Debian before becoming a full part of it. It is a deliberate policy, by which candidates who eventually join the project are integrated as another piece of an infinitely extensible jigsaw puzzle.
id-ID: Sebagai tambahan, setiap kandidat yang ingin bergabung Debian ranks diharapkan mengetahui cara kerja dari proyek, dan bagaimana berinteraksi dengan tepat untuk memecahkan masalah yang pasti akan mereka temui seiring berjalannya waktu. Semua informasi ini secara umum didokumentasikan di dalam manual yang ditujukan kepada maintainer baru, dan dalam referensi pengembang Debian. Pembacaan teliti dari dokumen ini seharusnya cukup untuk menjawab pertanyaan penguji. Jika jawaban tidak cukup memuaskan, kandidat akan dikabari. Ia akan harus membaca (lagi) dokumentasi yang relevan sebelum mencoba lagi. Pada kasus di mana dokumentasi saat ini tidak mengandung jawaban yang tepat untuk pertanyaan, kandidat umumnya dapat mencapai jawaban dengan pengalaman praktikal selama di Debian, atau mendiskusikannya dengan pengembang Debian lainnya. Mekanisme ini memastikan bahwa kandidat sedikit terlibat dalam Debian sebelum bergabung secara utuh. Ini merupakan kebijakan yang disengaja, agar kandidat yang pada akhirnya bergabung ke proyek terintegrasi sebagai kepingan lain dari teka teki gambar yang dapat diperluas tak hingga.

en: This step is usually known as the <emphasis>Philosophy &amp; Procedures</emphasis> (P&amp;P for short) in the lingo of the developers involved in the new member process.
id-ID: Langkah ini umumnya dikenal sebagai <emphasis>Philosophy &amp; Procedures</emphasis> (disingkat P&amp;P) dalam lingo para pengembang yang terlibat dalam proses anggota baru.

en: <primary><emphasis>Philosophy &amp; Procedures</emphasis></primary>
id-ID: <primary><emphasis>Filosofi &amp; Prosedur</emphasis></primary>

en: Checking Skills
id-ID: Pemeriksaan Keahlian

en: Each application to become an official Debian developer must be justified. Becoming a project member requires showing that this status is legitimate, and that it facilitates the candidate's job in helping Debian. The most common justification is that being granted Debian developer status eases maintenance of a Debian package, but it is not the only one. Some developers join the project to contribute to porting to a specific architecture, others want to improve documentation, and so on.
id-ID: Setiap aplikasi untuk menjadi pengembang resmi Debian harus dijustifikasi. Menjadi anggota proyek membutuhkan ... menunjukkan status ini legitimasi, dan memfasilitasi pekerjaan kandidat dalam membantu Debian. Justifikasi yang paling umum adalah ... diberikan Debian developer status ... memudahkan pengelolaan paket Debian, namun ini bukan satu-satunya. Beberapa pengembang bergabung ke proyek untuk aktif berkontribusi dengan mem-porting ke arsitektur spesifik, lainnya ingin meningkatkan dokumentasi, dan seterusnya.

en: This step represents the opportunity for the candidate to state what they intend to do within the Debian project and to show what they have already done towards that end. Debian is a pragmatic project and saying something is not enough, if the actions do not match what is announced. Generally, when the intended role within the project is related to package maintenance, a first version of the prospective package will have to be validated technically and uploaded to the Debian servers by a sponsor among the existing Debian developers.
id-ID: Langkah ini merepresentasikan peluang bagi kandidat untuk menyatakan bahwa mereka ingin ... dalam proyek Debian dan menunjukkan bahwa mereka telah bergerak maju... Debian adalah proyek pragmatis dan mengatakan sesuatu tidak cukup, jika tindakan tidak sesuai dengan apa yang dikatakan. Umumnya, saat ... dalam proyek berkaitan dengan pengelolaan paket, versi pertama dari prospektif pakt akan harus divalidasi secara teknis dan diunggah ke server Debian oleh sponsor dari pengembang Debian saat ini.

en: <emphasis>COMMUNITY</emphasis> Sponsoring
id-ID: <emphasis>KOMUNITAS</emphasis> Sponsoring

en: <primary>sponsoring</primary>
id-ID: <primary>mensponsori</primary>

en: Debian developers can “sponsor” packages prepared by someone else, meaning that they publish them in the official Debian repositories after having performed a careful review. This mechanism enables external persons, who have not yet gone through the new member process, to contribute occasionally to the project. At the same time, it ensures that all packages included in Debian have always been checked by an official member.
id-ID: Pengembang Debian dapat “sponsor” paket yang disiapkan oleh orang lain, berarti bahwa mereka mempublikasikan mereka dalam repositori Debian resmi setelah melakukan review ... Mekanisme ini memungkinkan orang lain, yang ... melalui proses anggota baru, untuk berkontribusi ... pada proyek. Pada waktu yang bersamaan, memastikan bahwa semua paket yang dimasukkan dalam Debian telah diperiksa oleh anggota resmi.

en: This step is known as the <emphasis>Tasks &amp; Skills</emphasis> step (T&amp;S for short) in the examiners' jargon.
id-ID: Langkah ini dikenal sebagai langkah <emphasis>Tasks &amp; Skills</emphasis> (disingkat dengan T&amp;S) pada jargon penguji.

en: <primary><emphasis>Tasks &amp; Skills</emphasis></primary>
id-ID: <primary><emphasis>Tugas &amp; Keahlian</emphasis></primary>

en: Final Approval
id-ID: Persetujuan Akhir

en: At the very last step, the whole process is reviewed by a DAM (<emphasis>Debian Account Manager</emphasis>). The DAM will review all the information about the candidate that the examiner collected, and makes the decision on whether or not to create an account on the Debian servers. In cases where extra information is required, the account creation may be delayed. Refusals are rather rare if the examiner does a good job of following the process, but they sometimes happen. They are never permanent, and the candidate is free to try again at a later time.
id-ID: Pada langkah terakhir, seluruh proses di-review oleh DAM (<emphasis>Debian Account Manager</emphasis>). DAM akan me-review semua informasi kandidat yang telah dikumpulkan penguji dan membuat keputusan apakah akan membuat akun pada server Debian atau tidak. Pada keadaan di mana informasi tambahan dibutuhkan, pembuatan akun bisa jadi tertunda. Penolakan jarang terjadi jika penguji melakukan pekerjaannya dengan baik, namun sesekali terjadi penolakan. Hal ini tidak pernah permanen, dan kandidat bebas untuk mencoba lagi pada waktu berikutnya.

en: The DAM's decision is authoritative and (almost) without appeal, which explains why the people in that seat have often been criticized in the past.
id-ID: Keputusan DAM bersifat otoritatif dan (hampir) tanpa sanggahan, yang menerangkan mengapa orang yang menjabat seringkali pada masa lalu dikritik.
