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

en: Process
id-ID: Proses

en: Hierarchy
id-ID: Hirarki

en: Basic Commands
id-ID: Perintah-perintah Dasar

en: Short Remedial Course
id-ID: Kursus Remedial Singkat

en: Even though this book primarily targets administrators and “power-users”, we wouldn't like to exclude motivated beginners. This appendix will therefore be a crash-course describing the fundamental concepts involved in handling a Unix computer.
id-ID: Meskipun buku ini terutama menarget administrator dan pengguna mahir, kita tidak ingin mengecualikan para pemula yang termotivasi. Lampiran ini karena itu adalah kursus kilat yang menggambarkan konsep-konsep fundamental yang terlibat dalam menangani komputer Unix.

en: Shell and Basic Commands
id-ID: Perintah-perintah Dasar dan Shell

en: In the Unix world, every administrator has to use the command line sooner or later; for example, when the system fails to start properly and only provides a command-line rescue mode. Being able to handle such an interface, therefore, is a basic survival skill for these circumstances.
id-ID: Di dunia Unix, setiap administrator pada akhirnya mesti menggunakan baris perintah; sebagai contoh, ketika sistem gagal untuk memulai dengan benar dan hanya menyediakan mode pertolongan baris perintah. Mampu menangani antarmuka seperti itu, karenanya, adalah keterampilan dasar untuk bertahan hidup dalam keadaan ini.

en: <emphasis>QUICK LOOK</emphasis> Starting the command interpreter
id-ID: <emphasis>SEKILAS</emphasis> Memulai interpreter perintah

en: This section only gives a quick peek at the commands. They all have many options not described here, so please refer to the abundant documentation in their respective manual pages.
id-ID: Bagian ini hanya memberikan kilasan atas perintah-perintah. Mereka semua punya banyak opsi yang tidak dijelaskan di sini, maka silakan mengacu ke dokumentasi yang banyak tersedia dalam masing-masing halaman manual.

en: Browsing the Directory Tree and Managing Files
id-ID: Meramban Pohon Direktori dan Mengelola Berkas

en: Once a session is open, the <command>pwd</command> command (which stands for <emphasis>print working directory</emphasis>) displays the current location in the filesystem. The current directory is changed with the <command>cd <replaceable>directory</replaceable></command> command (<command>cd</command> is for <emphasis>change directory</emphasis>). The parent directory is always called <literal>..</literal> (two dots), whereas the current directory is also known as <literal>.</literal> (one dot). The <command>ls</command> command allows <emphasis>listing</emphasis> the contents of a directory. If no parameters are given, it operates on the current directory.
id-ID: Sekali suatu sesi dibuka, perintah <command>pwd</command> (yang merupakan kepanjangan dari <emphasis>print working directory</emphasis>, cetak direktori kerja) menampilkan lokasi saat ini dalam sistem berkas. Direktori saat ini berubah dengan perintah <command>cd <replaceable>direktori</replaceable></command> (<command>cd</command> adalah <emphasis>change directory</emphasis>, pindah direktori). Direktori induk selalu dinamai <literal>..</literal> (dua titik), sedangkan direktori saat ini juga dikenal sebagai <literal>.</literal> (satu titik). Perintah <command>ls</command> mengizinkan <emphasis>menampilkan</emphasis> isi dari suatu direktori. Bila suatu parameter diberikan, itu beroperasi pada direktori saat ini.

en: A new directory can be created with <command>mkdir <replaceable>directory</replaceable></command>, and an existing (empty) directory can be removed with <command>rmdir <replaceable>directory</replaceable></command>. The <command>mv</command> command allows <emphasis>moving</emphasis> and/or renaming files and directories; <emphasis>removing</emphasis> a file is achieved with <command>rm <replaceable>file</replaceable></command>.
id-ID: Suatu direktori baru dapat dibuat dengan <command>mkdir <replaceable>direktori</replaceable></command>, dan suatu direktori (kosong) yang telah ada dapat dihapus dengan <command>rmdir <replaceable>direktori</replaceable></command>. Perintah <command>mv</command> mengizinkan <emphasis>memindah</emphasis> dan/atau mengubah nama berkas dan direktori; <emphasis>menghapus</emphasis> suatu berkas dicapai dengan <command>rm <replaceable>berkas</replaceable></command>.

en: Displaying and Modifying Text Files
id-ID: Menampilkan dan Mengubah Berkas Teks

en: The <command>cat <replaceable>file</replaceable></command> command (intended to <emphasis>concatenate</emphasis> files to the standard output device) reads a file and displays its contents on the terminal. If the file is too big to fit on a screen, use a pager such as <command>less</command> (or <command>more</command>) to display it page by page.
id-ID: Perintah <command>cat <replaceable>berkas</replaceable> </command> (dimaksudkan untuk <emphasis>concatenate</emphasis> berkas ke perangkat keluaran standar) membaca berkas dan menampilkan isinya pada terminal. Jika berkas terlalu besar untuk tampil utuh di layar, gunakan pager seperti <command>less</command> (atau <command>more</command>) untuk menampilkan halaman demi halaman.

en: The <command>editor</command> command starts a text editor (such as <command>vi</command> or <command>nano</command>) and allows creating, modifying and reading text files. The simplest files can sometimes be created directly from the command interpreter thanks to redirection: <command>echo "<replaceable>text</replaceable>" &gt;<replaceable>file</replaceable></command> creates a file named <replaceable>file</replaceable> with “<replaceable>text</replaceable>” as its contents. Adding a line at the end of this file is possible too, with a command such as <command>echo "<replaceable>moretext</replaceable>" &gt;&gt;<replaceable>file</replaceable></command>. Note the <literal>&gt;&gt;</literal> in this example.
id-ID: Perintah <command>editor</command> memulai suatu penyunting teks (seperti misalnya <command>vi</command> atau <command>nano</command>) dan mengizinkan pembuatan, pengubahan, dan pembacaan berkas teks. Berkas paling sederhana kadang dapat dibuat secara langsung dari interpreter perintah, terima kasih ke redireksi: <command>echo "<replaceable>teks</replaceable>" &gt;<replaceable>berkas</replaceable></command> membuat suatu berkas bernama <replaceable>berkas</replaceable> dengan "<replaceable>teks</replaceable>" sebagai isinya. Menambahkan suatu baris di akhir berkas ini juga mungkin, dengan suatu perintah seperti <command>echo "<replaceable>tekslain</replaceable>" &gt;&gt;<replaceable>berkas</replaceable></command>. Perhatikan <literal>&gt;&gt;</literal> dalam contoh ini.

en: Searching for Files and within Files
id-ID: Mencari Berkas dan di dalam Berkas

en: The <command>find <replaceable>directory</replaceable> <replaceable>criteria</replaceable></command> command looks for files in the hierarchy under <replaceable>directory</replaceable> according to several criteria. The most commonly used criterion is <literal>-name <replaceable>name</replaceable></literal>: that allows looking for a file by its name.
id-ID: Perintah <command>find <replaceable>direktori</replaceable> <replaceable>kriteria</replaceable></command> mencari berkas dalam hirarki di bawah <replaceable>direktori</replaceable> sesuai dengan beberapa kriteria. Kriteria yang paling sering dipakai adalah <literal>-name <replaceable>name</replaceable></literal>: yang mengizinkan pencarian berkas menurut namanya.

en: The <command>grep <replaceable>expression</replaceable> <replaceable>files</replaceable></command> command searches the contents of the files and extracts the lines matching the regular expression (see sidebar <xref linkend="sidebar.regexp" />). Adding the <literal>-r</literal> option enables a recursive search on all files contained in the directory passed as a parameter. This allows looking for a file when only a part of the contents are known.
id-ID: Perintah <command>grep <replaceable>ekpresi</replaceable> <replaceable>berkas</replaceable></command> mencari isi dari berkas dan mengekstrak baris-baris yang cocok dengan ekspresi reguler (lihat bilah sisi <xref linkend="sidebar.regexp" />). Menambahkan opsi <literal>-r</literal> memungkinkan pencarian rekursif pada semua berkas yang ada dalam direktori yang disebut sebagai parameter. Hal ini memungkinkan mencari berkas ketika hanya sebagian dari isinya diketahui.

en: Managing Processes
id-ID: Mengelola Proses

en: The <command>ps aux</command> command lists the processes currently running and helps identifying them by showing their <emphasis>pid</emphasis> (process id). Once the <emphasis>pid</emphasis> of a process is known, the <command>kill -<replaceable>signal</replaceable> <replaceable>pid</replaceable></command> command allows sending it a signal (if the process belongs to the current user). Several signals exist; most commonly used are <literal>TERM</literal> (a request to terminate gracefully) and <literal>KILL</literal> (a forced kill).
id-ID: Perintah <command>ps aux</command> menampilkan daftar proses yang saat ini sedang berjalan dan membantu mengidentifikasi mereka dengan menunjukkan <emphasis>pid</emphasis> (id proces) mereka. Sekali <emphasis>pid</emphasis> dari suatu proses diketahui, perintah <command>kill -<replaceable>signal</replaceable> <replaceable>pid</replaceable></command> mengizinkan mengirim sinyal ke sana (bila proses milik dari pengguna saat ini). Ada beberapa sinyal; yang paling sering dipakai adalah <literal>TERM</literal> (suatu permintaan untuk mengakhiri secara baik-baik) dan <literal>KILL</literal> (mematikan paksa proses).

en: The command interpreter can also run programs in the background if the command is followed by a “&amp;”. By using the ampersand, the user resumes control of the shell immediately even though the command is still running (hidden from the user; as a background process). The <command>jobs</command> command lists the processes running in the background; running <command>fg %<replaceable>job-number</replaceable></command> (for <emphasis>foreground</emphasis>) restores a job to the foreground. When a command is running in the foreground (either because it was started normally, or brought back to the foreground with <command>fg</command>), the <keycombo action="simul"><keycap>Control</keycap><keycap>Z</keycap></keycombo> key combination pauses the process and resumes control of the command-line. The process can then be restarted in the background with <command>bg %<replaceable>job-number</replaceable></command> (for <foreignphrase>background</foreignphrase>).
id-ID: Interpreter perintah juga dapat menjalankan program di latar belakang bila perintah diikuti dengan suatu "&amp;". Dengan memakai ampersand, pengguna meneruskan kendali shell seketika walaupun perintah masih berjalan (tersembunyi dari pengguna; sebagai suatu proses latar belakang). Perintah <command>jobs</command> menampilkan daftar proses yang sedang berjalan di latar belakang; menjalankan <command>fg %<replaceable>nomor-tugas</replaceable></command> (untuk <emphasis>foreground</emphasis>) mengembalikan tugas ke latar depan. Ketika suatu perintah dijalankan di latar depan (baik karena itu mulai dijalankan secara normal, atau dibawa kembali ke latar depan dengan <command>fg</command>), kombinasi tombol <keycombo action="simul"><keycap>Control</keycap><keycap>Z</keycap></keycombo> mengistirahatkan proses dan meneruskan kendali baris perintah. Proses kemudian dapat dijalankan ulang di latar belakang dengan <command>bg %<replaceable>nomor-tugas</replaceable></command> (untuk <foreignphrase>background</foreignphrase>).

en: System Information: Memory, Disk Space, Identity
id-ID: Informasi Sistem: Memori, Ruang Disk, Identitas

en: The <command>free</command> command displays information on memory; <command>df</command> (<emphasis>disk free</emphasis>) reports on the available disk space on each of the disks mounted in the filesystem. Its <literal>-h</literal> option (for <emphasis>human readable</emphasis>) converts the sizes into a more legible unit (usually mebibytes or gibibytes). In a similar fashion, the <command>free</command> command supports the <literal>-m</literal> and <literal>-g</literal> options, and displays its data either in mebibytes or in gibibytes, respectively.
id-ID: Perintah <command>free</command> menampilkan informasi tentang memori; <command>df</command> (<emphasis>disk free</emphasis>) melaporkan ruang disk yang tersedia pada setiap disk yang di-mount dalam sistem berkas. Opsi <literal>-h</literal> (untuk <emphasis>human readable</emphasis>, dapat dibaca manusia) mengubah ukuran ke dalam satuan yang lebih mudah dibaca (biasanya mebibita or gibibita). Mirip itu, perintah <command>free</command> mendukung opsi-opsi <literal>-m</literal> dan <literal>-g</literal>, dan menampilkan datanya masing-masing dalam mebibita atau dalam gigabita.

en: The <command>id</command> command displays the identity of the user running the session, along with the list of groups they belong to. Since access to some files or devices may be limited to group members, checking available group membership may be useful.
id-ID: Perintah <command>id</command> menampilkan identitas pengguna yang sedang menjalankan sesi, bersama dengan daftar group dimana dia menjadi anggota. Karena akses ke beberapa berkas atau peranti mungkin dibatasi ke anggota grup, memeriksa keanggotaan grup yang tersedia mungkin berguna.

en: Organization of the Filesystem Hierarchy
id-ID: Organisasi dari Hirarki Sistem Berkas

en: <primary>Filesystem Hierarchy</primary>
id-ID: <primary>Hirarki Sistem Berkas</primary>

en: The Root Directory
id-ID: Direktori Root

en: A Debian system is organized along the <emphasis>Filesystem Hierarchy Standard</emphasis> (FHS). This standard defines the purpose of each directory. For instance, the top-level directories are described as follows:
id-ID: Suatu sistem Debian yang diorganisasikan mengikuti <emphasis>Filesystem Hierarchy Standard</emphasis> (FHS). Standar ini mendefinisikan tujuan masing-masing direktori. Sebagai contoh, direktori tingkat paling atas diuraikan sebagai berikut:

en: <filename>/bin/</filename>: basic programs;
id-ID: <filename>/bin/</filename>: program-program dasar;

en: <filename>/boot/</filename>: Linux kernel and other files required for its early boot process;
id-ID: <filename>/boot</filename>: Kernel Linux dan berkas-berkas lain yang diperlukan untuk proses boot awal;

en: <filename>/dev/</filename>: device files;
id-ID: <filename>/dev</filename>: berkas peranti;

en: <filename>/etc/</filename>: configuration files;
id-ID: <filename>/etc</filename>: berkas konfigurasi;

en: <filename>/home/</filename>: user's personal files;
id-ID: <filename>/home</filename>: berkas pribadi pengguna;

en: <filename>/lib/</filename>: basic libraries;
id-ID: <filename>/lib</filename>: pustaka dasar;

en: <filename>/media/*</filename>: mount points for removable devices (CD-ROM, USB keys and so on);
id-ID: <filename>/media/*</filename>: titik kait untuk peranti lepas pasang (CD-ROM, flash disk USB, dan sebagainya);

en: <filename>/mnt/</filename>: temporary mount point;
id-ID: <filename>/mnt</filename>: titik kait temporer;

en: <filename>/opt/</filename>: extra applications provided by third parties;
id-ID: <filename>/opt</filename>: aplikasi ekstra yang disediakan oleh pihak ketiga;

en: <filename>/root/</filename>: administrator's (root's) personal files;
id-ID: <filename>/root</filename>: berkas pribadi administrator (root);

en: <filename>/run/</filename>: volatile runtime data that does not persist across reboots;
id-ID: <filename>/run</filename>: data runtime volatile yang tidak bertahan antar reboot;

en: <filename>/sbin/</filename>: system programs;
id-ID: <filename>/sbin</filename>: program-program sistem;

en: <filename>/srv/</filename>: data used by servers hosted on this system;
id-ID: <filename>/srv</filename>: data yang dipakai oleh server yang diwadahi oleh sistem ini;

en: <filename>/tmp/</filename>: temporary files; this directory is often emptied at boot;
id-ID: <filename>/tmp</filename>: berkas temporer; direktori ini seringkali dikosongkan saat boot;

en: <filename>/usr/</filename>: applications; this directory is further subdivided into <filename>bin</filename>, <filename>sbin</filename>, <filename>lib</filename> (according to the same logic as in the root directory). Furthermore, <filename>/usr/share/</filename> contains architecture-independent data. <filename>/usr/local/</filename> is meant to be used by the administrator for installing applications manually without overwriting files handled by the packaging system (<command>dpkg</command>).
id-ID: <filename>/usr/</filename>: aplikasi; direktori ini dibagi lagi menjadi <filename>bin</filename>, <filename>sbin</filename>, <filename>lib</filename> (menurut logika yang sama seperti dalam direktori root). Selain itu, <filename>/usr/share/</filename> berisi data arsitektur-independen. <filename>/usr/local/</filename> dimaksudkan untuk digunakan oleh administrator untuk menginstal aplikasi secara manual tanpa menimpa berkas-berkas yang ditangani oleh sistim pemaketan (<command>dpkg</command>).

en: <filename>/var/</filename>: variable data handled by daemons. This includes log files, queues, spools, caches and so on.
id-ID: <filename>/var/</filename>: data variabel yang ditangani oleh daemon. Ini termasuk berkas log, antrian, spool, cache, dan seterusnya.

en: <filename>/proc/</filename> and <filename>/sys/</filename> are specific to the Linux kernel (and not part of the FHS). They are used by the kernel for exporting data to user space (see <xref linkend="sect.userspace-presentation" /> and <xref linkend="sect.user-space" /> for explanations about this concept).
id-ID: <filename>/proc/</filename> dan <filename>/sys/</filename> spesifik ke kernel Linux (dan bukan bagian dari FHS). Mereka dipakai oleh kernel untuk mengekspor data ke user space (lihat <xref linkend="sect.userspace-presentation" /> dan <xref linkend="sect.user-space" /> untuk penjelasan tentang konsep ini).

en: <primary>merged <filename>/usr</filename></primary>
id-ID: <primary>tergabung <filename>/usr</filename></primary>

en: Note that many modern distributions, Debian included, are shipping <filename>/bin</filename>, <filename>/sbin</filename> and <filename>/lib</filename> as symlinks to the corresponding directories below <filename>/usr</filename> so that all programs and libraries are available in a single tree. It makes it easier to protect the integrity of the system files, and to share those system files among multiple containers, etc.
id-ID: Perhatikan bahwa banyak distro modern, termasuk Debian, mengirim <filename>/bin</filename>, <filename>/sbin</filename>, dan <filename>/lib</filename> sebagai symlink ke direktori yang sesuai di bawah <filename>/usr</filename> sehingga semua program dan pustaka tersedia dalam satu pohon tunggal. Ini membuat lebih mudah untuk melindungi integritas sistem berkas, dan untuk berbagi sistem berkas tersebut di antara beberapa container, dsb.

en: The User's Home Directory
id-ID: Direktori Home Milik Pengguna

en: The contents of a user's home directory is not standardized, but there are still a few noteworthy conventions. One is that a user's home directory is often referred to by a tilde (“~”). That is useful to know because command interpreters automatically replace a tilde with the correct directory (usually <filename>/home/<replaceable>user</replaceable>/</filename>).
id-ID: Isi dari direktori home pengguna tidak distandarkan, tetapi masih ada beberapa konvensi yang patut dicatat. Salah satunya adalah bahwa direktori home pengguna sering disebut dengan sebuah tilde ("~"). Yang sangat berguna untuk diketahui karena interpreter perintah secara otomatis mengganti sebuah tilde dengan direktori yang benar (biasanya <filename>/home/<replaceable>pengguna</replaceable>/</filename>).

en: Traditionally, application configuration files are often stored directly under the user's home directory, but their names usually start with a dot (for instance, the <command>mutt</command> email client stores its configuration in <filename>~/.muttrc</filename>). Note that filenames that start with a dot are hidden by default; and <command>ls</command> only lists them when the <literal>-a</literal> option is used, and graphical file managers need to be told to display hidden files.
id-ID: Secara tradisional, berkas konfigurasi aplikasi sering tersimpan langsung di bawah direktori home pengguna, namun nama mereka biasanya mulai dengan sebuah titik (misalnya, klien surel <command>mutt</command> menyimpan konfigurasinya di <filename>~/.muttrc</filename>). Perhatikan bahwa nama berkas yang dimulai dengan sebuah titik tersembunyi secara default; dan <command>ls</command> hanya menampilkan daftar mereka ketika opsi <literal>-a</literal> digunakan, dan manajer berkas grafis harus diberitahu untuk menampilkan berkas yang tersembunyi.

en: Graphical desktops usually display the contents of the <filename>~/Desktop/</filename> directory (or whatever the appropriate translation is for systems not configured in English) on the desktop (i.e. what is visible on screen once all applications are closed or iconized).
id-ID: Desktop grafis biasanya menampilkan isi dari direktori <filename>~/Desktop/</filename> (atau apa pun terjemahan yang tepat untuk sistem yang tidak dikonfigurasi dalam bahasa Inggris) pada desktop (yaitu, apa terlihat pada layar setelah semua aplikasi tertutup atau diikonkan).

en: Finally, the email system sometimes stores incoming emails into a <filename>~/Mail/</filename> directory.
id-ID: Akhirnya, sistem surel terkadang menyimpan surel yang masuk ke dalam direktori <filename>~/Mail/</filename>.

en: Inner Workings of a Computer: the Different Layers Involved
id-ID: Jeroan dari suatu Komputer: Lapisan Berbeda yang Terlibat

en: A computer is often considered as something rather abstract, and the externally visible interface is much simpler than its internal complexity. Such complexity comes in part from the number of pieces involved. However, these pieces can be viewed in layers, where a layer only interacts with those immediately above or below.
id-ID: Komputer sering dianggap sebagai sesuatu yang agak abstrak, dan antarmuka yang terlihat secara eksternal jauh lebih sederhana daripada kompleksitas internalnya. Kerumitan seperti itu sebagian berasal dari banyaknya bagian yang terlibat. Namun, potongan-potongan ini dapat dilihat dalam lapisan-lapisan, dimana suatu lapisan hanya berinteraksi dengan yang berada tepat di atas atau di bawahnya.

en: An end-user can get by without knowing these details… as long as everything works. When confronting a problem such as, “The internet doesn't work!”, the first thing to do is to identify in which layer the problem originates. Is the network card (hardware) working? Is it recognized by the computer? Does the Linux kernel see it? Are the network parameters properly configured? All these questions isolate an appropriate layer and focus on a potential source of the problem.
id-ID: Pengguna akhir dapat bertahan tanpa mengetahui detail ini… selama semuanya berfungsi. Ketika menghadapi masalah seperti, “Internet tidak berfungsi!”, hal pertama yang harus dilakukan adalah mengidentifikasi di mana lapisan masalahnya berasal. Apakah kartu jaringan (perangkat keras) berfungsi? Apakah itu dikenali oleh komputer? Apakah kernel Linux melihatnya? Apakah parameter jaringan dikonfigurasi dengan benar? Semua pertanyaan ini mengisolasi lapisan yang tepat dan fokus pada sumber potensial masalah.

en: The Deepest Layer: the Hardware
id-ID: Lapisan Terdalam: Perangkat Keras

en: Let us start with a basic reminder that a computer is, first and foremost, a set of hardware elements. There is generally a main board (known as the <emphasis>motherboard</emphasis>), with one (or more) processor(s), some RAM, device controllers, and extension slots for option boards (for other device controllers). Most noteworthy among these controllers are IDE (Parallel ATA), SCSI and Serial ATA, for connecting to storage devices such as hard disks. Other controllers include USB, which is able to host a great variety of devices (ranging from webcams to thermometers, from keyboards to home automation systems) and IEEE 1394 (Firewire). These controllers often allow connecting several devices so the complete subsystem handled by a controller is therefore usually known as a “bus”. Option boards include graphics cards (into which monitor screens will be plugged), sound cards, network interface cards, and so on. Some main boards are pre-built with these features, and don't need option boards.
id-ID: Mari kita mulai dengan pengingat dasar bahwa suatu komputer, pertama dan terpenting, adalah sekumpulan elemen perangkat keras. Biasanya ada suatu papan utama (dikenal sebagai <emphasis>motherboard</emphasis>), dengan satu (atau lebih) prosesor, RAM, pengendali perangkat, dan slot ekstensi untuk papan opsi (untuk pengendali perangkat lain). Yang paling penting di antara pengendali ini adalah IDE (Parallel ATA), SCSI, dan Serial ATA, untuk menghubungkan ke perangkat penyimpanan seperti hard disk. Pengontrol lainnya termasuk USB, yang dapat menghosting berbagai perangkat (mulai dari webcam hingga termometer, dari papan ketik hingga sistem otomasi rumah) dan IEEE 1394 (Firewire). Kontroler ini sering memungkinkan menghubungkan beberapa perangkat sehingga subsistem lengkap yang ditangani oleh pengontrol oleh karena itu biasanya dikenal sebagai ”bus”. Kartu-kartu opsi termasuk kartu grafis (di mana layar monitor akan dipasang), kartu suara, kartu antarmuka jaringan, dan sebagainya. Beberapa papan utama sudah dibangun sebelumnya dengan fitur-fitur ini, dan tidak perlu kartu opsi.

en: <emphasis>IN PRACTICE</emphasis> Checking that the hardware works
id-ID: <emphasis>DALAM PRAKTEK</emphasis> Memeriksa bahwa perangkat keras bekerja

en: Checking that a piece of hardware works can be tricky. On the other hand, proving that it doesn't work is sometimes quite simple.
id-ID: Memeriksa bahwa suatu perangkat keras bekerja bisa rumit. Di sisi lain, membuktikan bahwa itu tidak bekerja kadang-kadang cukup sederhana.

en: A hard disk drive is made of spinning platters and moving magnetic heads. When a hard disk is powered up, the platter motor makes a characteristic whir. It also dissipates energy as heat. Consequently, a hard disk drive that stays cold and silent when powered up is broken.
id-ID: Hard disk drive terbuat dari piringan berputar dan kepala magnetik yang bergerak. Ketika hard disk dinyalakan, motor piringan membuat desir yang khas. Ini juga membuang energi sebagai panas. Akibatnya, hard disk drive yang tetap dingin dan diam saat dinyalakan berarti rusak.

en: Network cards often include LEDs displaying the state of the link. If a cable is plugged in and leads to a working network hub or switch, at least one LED will be on. If no LED lights up, either the card itself, the network device, or the cable between them, is faulty. The next step is therefore testing each component individually.
id-ID: Kartu jaringan sering menyertakan LED yang menampilkan status link. Jika kabel dicolokkan dan mengarah ke hub atau switch jaringan yang berfungsi, setidaknya satu LED akan menyala. Jika tidak ada lampu LED yang menyala, kartu itu sendiri, perangkat jaringan, atau kabel di antara keduanya, rusak. Langkah selanjutnya adalah menguji setiap komponen secara individual.

en: Some option boards — especially 3D video cards — include cooling devices, such as heat sinks and/or fans. If the fan does not spin even though the card is powered up, a plausible explanation is the card overheated. This also applies to the main processor(s) located on the main board.
id-ID: Beberapa kartu opsi — terutama kartu video 3D — menyertakan perangkat pendinginan, seperti heat sink dan/atau kipas. Jika kipas tidak berputar meskipun kartu dinyalakan, penjelasan yang masuk akal adalah kartu terlalu panas. Ini juga berlaku untuk prosesor utama yang terletak di papan utama.

en: The Starter: the BIOS or UEFI
id-ID: Awal: BIOS atau UEFI

en: Hardware, on its own, is unable to perform useful tasks without a corresponding piece of software driving it. Controlling and interacting with the hardware is the purpose of the operating system and applications. These, in turn, require functional hardware to run.
id-ID: Perangkat keras, berdiri sendiri, tidak mampu melakukan tugas-tugas yang berguna tanpa perangkat lunak terkait yang menggerakkannya. Mengendalikan dan berinteraksi dengan perangkat keras adalah tujuan dari sistem operasi dan aplikasi. Ini, pada gilirannya, memerlukan perangkat keras yang fungsional untuk berjalan.

en: <emphasis>TOOL</emphasis> Setup, the BIOS/UEFI configuration tool
id-ID: <emphasis>PERKAKAS</emphasis> Penyiapan, alat konfigurasi BIOS/UEFI

en: <primary><emphasis>Setup</emphasis></primary>
id-ID: <primary><emphasis>Penyiapan</emphasis></primary>

en: The boot sector (or the EFI partition), in turn, contains another piece of software, called the bootloader, whose purpose is to find and run an operating system. Since this bootloader is not embedded in the main board but loaded from disk, it can be smarter than the BIOS, which explains why the BIOS does not load the operating system by itself. For instance, the bootloader (often GRUB on Linux systems) can list the available operating systems and ask the user to choose one. Usually, a time-out and default choice is provided. Sometimes the user can also choose to add parameters to pass to the kernel, and so on. Eventually, a kernel is found, loaded into memory, and executed.
id-ID: Sektor boot (atau partisi EFI), pada gilirannya, memuat penggalan perangkat lunak lain, yang dinamai bootloader, yang berguna untuk mencari dan menjalankan suatu sistem operasi. Karena bootloader ini tidak ditanamkan dalam papan utama tapi dimuat dari disk, itu bisa lebih cerdas daripada BIOS, yang menjelaskan mengapa BIOS sendiri tidak memuat sistem operasi. Sebagai contoh, bootloader (biasanya GRUB pada sistem Linux) dapat menampilkan daftar sistem operasi yang tersedia dan menanyakan ke pengguna untuk memilih satu. Biasanya, suatu tenggat waktu dan pilihan baku disediakan. Kadang pengguna juga dapat memilih untuk menambah parameter yang dilewatkan ke kernel, dan seterusnya. Pada akhirnya, suatu kernel ditemukan, dimuat ke memori, dan dieksekusi.

en: <emphasis>NOTE</emphasis> UEFI, a modern replacement to the BIOS
id-ID: <emphasis>CATATAN</emphasis> UEFI, pengganti modern untuk BIOS

en: The BIOS/UEFI is also in charge of detecting and initializing a number of devices. Obviously, this includes the IDE/SATA devices (usually hard disk(s) and CD/DVD-ROM drives), but also PCI devices. Detected devices are often listed on screen during the boot process. If this list goes by too fast, use the <keycap>Pause</keycap> key to freeze it for long enough to read. Installed PCI devices that don't appear are a bad omen. At worst, the device is faulty. At best, it is merely incompatible with the current version of the BIOS or main board. PCI specifications evolve, and old main boards are not guaranteed to handle newer PCI devices.
id-ID: BIOS/UEFI juga bertanggung jawab mendeteksi dan mengisialisasi sejumlah perangkat. Tentu saja, ini termasuk perangkat IDE/SATA (biasanya drive CD/DVD-ROM dan hard disk), tapi juga perangkat-perangkat PCI. Perangkat-perangkat yang terdeteksi seringkali dimunculkan daftarnya dalam proses boot. Bila daftar ini berlalu terlalu cepat, gunakan tombol <keycap>Pause</keycap> untuk membekukannya cukup lama untuk dibaca. Perangkat-perangkat PCI terpasang yang tidak muncul adalah pertanda buruk. Terparahnya, perangkat bermasalah. Terbaiknya, itu sekedar tidak kompatibel dengan versi saat ini dari BIOS papan utama. Spesifikasi PCI bertumbuh, dan papan utama lama tidak dijamin menangani perangkat PCI yang lebih baru.

en: The Kernel
id-ID: Kernel

en: Both the BIOS/UEFI and the bootloader only run for a few seconds each; now we are getting to the first piece of software that runs for a longer time, the operating system kernel. This kernel assumes the role of a conductor in an orchestra, and ensures coordination between hardware and software. This role involves several tasks including: driving hardware, managing processes, users and permissions, the filesystem, and so on. The kernel provides a common base to all other programs on the system.
id-ID: BIOS/UEFI maupun bootloader masing-masing hanya berjalan selama beberapa detik; sekarang kita sampai ke bagian pertama dari perangkat lunak yang berjalan untuk waktu yang lama, kernel sistem operasi. Kernel ini mengambil peran seorang dirigen orkestra, dan menjamin koordinasi antara perangkat keras dan perangkat lunak. Peran ini melibatkan beberapa tugas termasuk: menggerakkan perangkat keras, mengelola proses, pengguna dan izin, sistem berkas, dan seterusnya. Kernel menyediakan dasar yang umum untuk semua program lain pada sistem.

en: The User Space
id-ID: Ruang Pengguna

en: Although everything that happens outside of the kernel can be lumped together under “user space”, we can still separate it into software layers. However, their interactions are more complex than before, and the classifications may not be as simple. An application commonly uses libraries, which in turn involve the kernel, but the communications can also involve other programs, or even many libraries calling each other.
id-ID: Walaupun segala sesuatu yang terjadi di luar kernel dapat dikelompok bersama di bawah ”ruang pengguna”, kita masih dapat memisahkan menjadi lapisan-lapisan perangkat lunak. Namun, interaksi mereka lebih kompleks daripada sebelumnya, dan klasifikasi mungkin tidak sederhana. Aplikasi umumnya menggunakan pustaka, yang pada gilirannya melibatkan kernel, tetapi komunikasi dapat juga melibatkan program lain, atau bahkan banyak pustaka memanggil satu sama lain.

en: Some Tasks Handled by the Kernel
id-ID: Beberapa Tugas yang Ditangani oleh Kernel

en: Driving the Hardware
id-ID: Menggerakkan Perangkat Keras

en: The kernel is, first and foremost, tasked with controlling the hardware parts, detecting them, switching them on when the computer is powered on, and so on. It also makes them available to higher-level software with a simplified programming interface, so applications can take advantage of devices without having to worry about details such as which extension slot the option board is plugged into. The programming interface also provides an abstraction layer; this allows video-conferencing software, for example, to use a webcam independently of its make and model. The software can just use the <emphasis>Video for Linux</emphasis> (V4L) interface, and the kernel translates the function calls of this interface into the actual hardware commands needed by the specific webcam in use.
id-ID: Kernel ini, pertama dan terutama, bertugas mengendalikan bagian-bagian perangkat keras, mendeteksi mereka, menyalakannya ketika komputer dihidupkan, dan seterusnya. Ini juga membuat mereka tersedia untuk perangkat lunak tingkat yang lebih tinggi dengan antarmuka pemrograman yang disederhanakan, sehingga aplikasi dapat memanfaatkan perangkat tanpa harus khawatir tentang detail seperti slot ekstensi mana tempat dipasangnya kartu opsi. Antarmuka pemrograman juga menyediakan lapisan abstraksi; ini memungkinkan perangkat lunak video-conferencing, misalnya, untuk menggunakan webcam tanpa tergantung kepada merek dan modelnya. Perangkat lunak ini hanya dapat menggunakan antarmuka <emphasis>Video for Linux</emphasis> (V4L), dan kernel menerjemahkan panggilan fungsi antarmuka ini ke perintah perangkat keras sebenarnya yang dibutuhkan oleh webcam tertentu yang digunakan.

en: Example of information provided by <command>lspci</command> and <command>lsusb</command>
id-ID: Contoh dari informasi yang disediakan oleh <command>lspci</command> dan <command>lsusb</command>

en: These programs have a <literal>-v</literal> option that lists much more detailed (but usually not necessary) information. Finally, the <command>lsdev</command> command (in the <emphasis role="pkg">procinfo</emphasis> package) lists communication resources used by devices.
id-ID: Program-program ini memiliki pilihan <literal>-v</literal>, yang mencantumkan informasi lebih rinci (tapi biasanya tidak perlu). Akhirnya, perintah <command>lsdev</command> (dalam paket <emphasis role="pkg">procinfo</emphasis>) menampilkan daftar sumber daya komunikasi yang digunakan oleh perangkat.

en: Applications often access devices by way of special files created within <filename>/dev/</filename> (see sidebar <xref linkend="sidebar.special-files" />). These are special files that represent disk drives (for instance, <filename>/dev/hda</filename> and <filename>/dev/sdc</filename>), partitions (<filename>/dev/hda1</filename> or <filename>/dev/sdc3</filename>), mice (<filename>/dev/input/mouse0</filename>), keyboards (<filename>/dev/input/event0</filename>), soundcards (<filename>/dev/snd/*</filename>), serial ports (<filename>/dev/ttyS*</filename>), and so on.
id-ID: Aplikasi sering mengakses perangkat melalui berkas khusus yang dibuat di dalam <filename>/dev/</filename> (lihat bilah sisi <xref linkend="sidebar.special-files" />). Ini adalah berkas-berkas khusus yang mewakili disk drive (sebagai contoh, <filename>/dev/hda</filename> dan <filename>/dev/sdc</filename>), partisi (<filename>/dev/hda1</filename> atau <filename>/dev/sdc3</filename>), tetikus (<filename>/dev/input/mouse0</filename>), papan ketik (<filename>/dev/input/event0</filename>), kartu suara (<filename>/dev/snd/*</filename>), port serial (<filename>/dev/ttyS*</filename>), dan seterusnya.

en: Filesystems
id-ID: Sistem Berkas

en: <primary>filesystem</primary>
id-ID: <primary>sistem berkas</primary>

en: Filesystems are one of the most prominent aspects of the kernel. Unix systems merge all the file stores into a single hierarchy, which allows users (and applications) to access data simply by knowing its location within that hierarchy.
id-ID: Sistem berkas adalah salah satu aspek yang paling menonjol dari kernel. Sistem Unix menggabungkan semua penyimpanan berkas ke dalam hirarki tunggal, yang memungkinkan pengguna (dan aplikasi) untuk mengakses data hanya dengan mengetahui lokasinya di dalam hierarki itu.

en: The starting point of this hierarchical tree is called the root, <filename>/</filename>. This directory can contain named subdirectories. For instance, the <literal>home</literal> subdirectory of <filename>/</filename> is called <filename>/home/</filename>. This subdirectory can, in turn, contain other subdirectories, and so on. Each directory can also contain files, where the actual data will be stored. Thus, the <filename>/home/rmas/Desktop/hello.txt</filename> name refers to a file named <literal>hello.txt</literal> stored in the <literal>Desktop</literal> subdirectory of the <literal>rmas</literal> subdirectory of the <literal>home</literal> directory present in the root. The kernel translates between this naming system and the actual, physical storage on a disk.
id-ID: Titik awalk dari pohon hirarkis ini disebut root, <filename>/</filename>. Direktori ini bisa memuat subdirektori-subdirektori yang dinamai. Sebagai contoh, subdirektori <literal>home</literal> dari <filename>/</filename> bernama <filename>/home/</filename>. Subdirektori ini, pada gilirannya, memuat subdirektori lain, dan seterusnya. Setiap direktori juga bisa mengandung berkas, dimana data sebenarnya akan disimpan. Maka, nama <filename>/home/rmas/Desktop/hello.txt</filename> mengacu ke sebuah berkas bernama <literal>hello.txt</literal> yang disimpan di dalam subdirektori <literal>Desktop</literal> dari subdirektori <literal>rmas</literal> subdirektori dari direktori <literal>home</literal> yang ada dalam root. Kernel menerjemahkan antara sistem penamaan ini dan penyimpanan fisik yang sebenarnya pada suatu disk.

en: Unlike other systems, there is only one such hierarchy, and it can integrate data from several disks. One of these disks is used as the root, and the others are “mounted” on directories in the hierarchy (the Unix command is called <command>mount</command>); these other disks are then available under these “mount points”. This allows storing users' home directories (traditionally stored within <filename>/home/</filename>) on a second hard disk, which will contain the <literal>rhertzog</literal> and <literal>rmas</literal> directories. Once the disk is mounted on <filename>/home/</filename>, these directories become accessible at their usual locations, and paths such as <filename>/home/rmas/Desktop/hello.txt</filename> keep working.
id-ID: Tidak seperti sistem lain, hanya ada satu hirarki seperti itu, dan itu bisa mengintegrasikan data dari beberapa disk. Salah satu dari disk ini dipakai sebagai root, dan yang lainnya ”dikait” pada direktori dalam hirarki (perintah Unix-nya bernama <command>mount</command>); disk-disk lain ini maka kemudian teredia di bawah ”titik-titik kait” ini. Ini mengizinkan menyimpan direktori rumah pengguna (secara tradisional disimpan di bawah <filename>/home/</filename> pada disk ke dua, yang akan memuat direktori <literal>rhertzog</literal> dan <literal>rmas</literal>. Sekali disk dikait pada <filename>/home/</filename>, direktori-direktori ini menjadi dapat diakses pada lokasi biasa, dan path seperti <filename>/home/rmas/Desktop/hello.txt</filename> tetap berjalan.

en: There are many filesystem formats, corresponding to many ways of physically storing data on disks. The most widely known are <emphasis>ext3</emphasis> and <emphasis>ext4</emphasis>, but others exist. For instance, <emphasis>vfat</emphasis> is the system that was historically used by DOS and Windows operating systems, which allows using hard disks under Debian as well as under Windows. In any case, a filesystem must be prepared on a disk before it can be mounted and this operation is known as “formatting”. Commands such as <command>mkfs.ext3</command> (where <command>mkfs</command> stands for <emphasis>MaKe FileSystem</emphasis>) handle formatting. These commands require, as a parameter, a device file representing the partition to be formatted (for instance, <filename>/dev/sda1</filename>). This operation is destructive and should only be run once, except if one deliberately wishes to wipe a filesystem and start afresh.
id-ID: Ada banyak format sistem berkas, terkait dengan banyaknya cara bagaimana secara fisik menyimpan data pada disk. Yang paling dikenal adalah <emphasis>ext3</emphasis> dan <emphasis>ext4</emphasis>, tapi yang lain juga ada. Sebagai contoh, <emphasis>vfat</emphasis> adalah sistem yang secara historis dipakai oleh sistem operasi Windows dan DOS, yang mengizinkan memakai hard disk di bawah Debian maupun di bawah Windows. Bagaimanapun, suatu sistem berkas mesti disiapkan pada suatu disk sebelum itu dapat dikait dan operasi ini dikenal sebagai ”memformat”. Perintah seperti <command>mkfs.ext3</command> (dimana <command>mkfs</command> merupakan kependekan dari <emphasis>MaKe FileSystem (buat sistem berkas)</emphasis> menangani pemformatan. Perintah-perintah ini memerlukan, sebagai suatu parameter, sebuah berkas peranti yang mewakili partisi yang akan diformat (sebagai contoh, <filename>/dev/sda1</filename>). Operasi ini merusak dan mesti hanya dijalankan sekali, kecuali bila seseorang dengan sengaja menghendaki membersihkan suatu sistem berkas dan memulai dari awal.

en: There are also network filesystems, such as <acronym>NFS</acronym>, where data is not stored on a local disk. Instead, data is transmitted through the network to a server that stores and retrieves them on demand. The filesystem abstraction shields users from having to care: files remain accessible in their usual hierarchical way.
id-ID: Ada juga sistem berkas jaringan, seperti <acronym>NFS</acronym>, dimana data tidak tersimpan pada disk lokal. Sebaliknya, data ditransmisikan melalui jaringan ke server yang menyimpan dan mengambil mereka saat diminta. Abstraksi sistem berkas melindungi pengguna dari keharusan untuk perawatan: berkas tetap dapat diakses dalam cara hirarkis mereka yang biasa.

en: Shared Functions
id-ID: Fungsi Bersama

en: Since a number of the same functions are used by all software, it makes sense to centralize them in the kernel. For instance, shared filesystem handling allows any application to simply open a file by name, without needing to worry where the file is stored physically. The file can be stored in several different slices on a hard disk, or split across several hard disks, or even stored on a remote file server. Shared communication functions are used by applications to exchange data independently of the way the data is transported. For instance, transport could be over any combination of local or wireless networks, or over a telephone landline.
id-ID: Karena sejumlah fungsi yang sama dipakai oleh semua perangkat lunak, layak untuk memusatkan mereka di dalam kernel. Sebagai contoh, penanganan sistem berkas bersama mengizinkan sebarang aplikasi sekedar membuka suatu berkas berdasarkan nama, tanpa perlu khawatir di mana berkas disimpan secara fisik. Berkas dapat disimpan di dalam beberapa potongan yang berbeda pada suatu hard disk, atau dipecah ke beberapa hard disk, atau bahkan disimpan pada suatu server berkas jarak jauh. Fungsi-fungsi komunikasi bersama dipakai oleh aplikasi-aplikasi untuk bertukar data secara independen dari cara data dipindahkan. Sebagai contoh, transpor bisa melalui sebarang kombinasi dari jaringa lokal atau nirkabel, atau melalui jalur telepon.

en: A process is a running instance of a program. This requires memory to store both the program itself and its operating data. The kernel is in charge of creating and tracking them. When a program runs, the kernel first sets aside some memory, then loads the executable code from the filesystem into it, and then starts the code running. It keeps information about this process, the most visible of which is an identification number known as <emphasis>pid</emphasis> (<emphasis>process identifier</emphasis>).
id-ID: Suatu proses adalah sebuah instansi program yang sedang berjalan. Ini membutuhkan memori untuk menyimpan program itu sendiri dan data operasinya. Kernel bertugas menciptakan dan melacak mereka. Ketika sebuah program berjalan, kernel terlebih dahulu menyisihkan sebagian memori, kemudian memuat kode yang dapat dieksekusi dari sistem berkas ke dalamnya, dan kemudian memulai menjalankan kode. Kernel menyimpan informasi tentang proses ini, yang paling terlihat adalah nomor identifikasi yang dikenal sebagai <emphasis>pid</emphasis> (<emphasis>process identifier</emphasis>).

en: Unix-like kernels (including Linux), like most other modern operating systems, are capable of “multi-tasking”. In other words, they allow running many processes “at the same time”. There is actually only one running process at any one time, but the kernel cuts time into small slices and runs each process in turn. Since these time slices are very short (in the millisecond range), they create the illusion of processes running in parallel, although they are actually only active during some time intervals and idle the rest of the time. The kernel's job is to adjust its scheduling mechanisms to keep that illusion, while maximizing the global system performance. If the time slices are too long, the application may not appear as responsive as desired. Too short, and the system loses time switching tasks too frequently. These decisions can be tweaked with process priorities. High-priority processes will run for longer and with more frequent time slices than low-priority processes.
id-ID: Kernel Unix-like (termasuk Linux), seperti kebanyakan sistem operasi modern lainnya, mampu ”multi-tasking”. Dengan kata lain, mereka memungkinkan menjalankan banyak proses ”pada saat yang sama”. Sebenarnya hanya ada satu proses yang berjalan pada satu waktu, tetapi kernel memotong waktu menjadi irisan-irisan kecil dan menjalankan setiap proses secara bergantian. Karena irisan waktu ini sangat pendek (dalam rentang milidetik), mereka menciptakan ilusi proses yang berjalan secara paralel, meskipun sebenarnya hanya aktif selama beberapa interval waktu dan menganggur di sisa waktu. Tugas kernel adalah menyesuaikan mekanisme penjadwalannya untuk menjaga ilusi itu, sambil memaksimalkan kinerja sistem global. Jika irisan waktu terlalu panjang, aplikasi mungkin tidak tampak responsif seperti yang diinginkan. Terlalu pendek, dan sistem kehilangan waktu karena beralih tugas terlalu sering. Keputusan-keputusan ini dapat disesuaikan dengan prioritas proses. Proses prioritas tinggi akan berjalan lebih lama dan dengan irisan waktu yang lebih sering daripada proses prioritas rendah.

en: <emphasis>NOTE</emphasis> Multi-processor systems (and variants)
id-ID: <emphasis>CATATAN</emphasis> Sistem multi-prosesor (dan varian)

en: The limitation described above of only one process being able to run at a time, doesn't always apply. The actual restriction is that there can only be one running process <emphasis>per processor core</emphasis> at a time. Multi-processor, multi-core or “hyper-threaded” systems allow several processes to run in parallel. The same time-slicing system is still used, though, so as to handle cases where there are more active processes than available processor cores. This is far from unusual: a basic system, even a mostly idle one, almost always has tens of running processes.
id-ID: Keterbatasan yang dijelaskan di atas dimana hanya satu proses yang dapat dijalankan pada satu waktu, tidak selalu berlaku. Pembatasan sebenarnya adalah hanya ada satu proses yang berjalan <emphasis>per core prosesor</emphasis> pada satu waktu. Sistem multi-prosesor, multi-core atau ”hyper-threaded” memungkinkan beberapa proses berjalan secara paralel. Sistem pengiris waktu yang sama masih digunakan, untuk menangani kasus-kasus dimana ada lebih banyak proses yang aktif daripada core prosesor yang tersedia. Ini tidak luar biasa: sistem dasar, bahkan yang kebanyakan menganggur, hampir selalu memiliki puluhan proses yang berjalan.

en: Of course, the kernel allows running several independent instances of the same program. But each can only access its own time slices and memory. Their data thus remain independent.
id-ID: Tentu saja, kernel memungkinkan menjalankan beberapa instansi independen dari program yang sama. Tetapi masing-masing hanya dapat mengakses irisan waktu dan memorinya sendiri. Data mereka dengan demikian tetap independen.

en: Rights Management
id-ID: Manajemen Hak

en: Unix-like systems are also multi-user. They provide a rights management system that supports separate users and groups; it also allows control over actions based on permissions. The kernel manages data for each process, allowing it to control permissions. Most of the time, a process is identified by the user who started it. That process is only permitted to take those actions available to its owner. For instance, trying to open a file requires the kernel to check the process identity against access permissions (for more details on this particular example, see <xref linkend="sect.rights-management" />).
id-ID: Sistem mirip Unix juga multi-pengguna. Mereka menyediakan sistem manajemen hak yang mendukung pengguna dan kelompok terpisah; itu juga memungkinkan kontrol atas tindakan berdasarkan izin. Kernel mengelola data untuk setiap proses, memungkinkannya untuk mengontrol perizinan. Seringkali, suatu proses diidentifikasi oleh pengguna yang memulainya. Proses itu hanya diizinkan untuk mengambil tindakan yang tersedia bagi pemiliknya. Misalnya, mencoba membuka berkas memerlukan kernel untuk memeriksa identitas proses terhadap izin akses (untuk detail lebih lanjut tentang contoh khusus ini, lihat <xref linkend="sect.rights-management" />).

en: <primary>kernel space</primary>
id-ID: <primary>ruang kernel</primary>

en: “User space” refers to the runtime environment of normal (as opposed to kernel) processes. This does not necessarily mean these processes are actually started by users because a standard system normally has several “daemon” (or background) processes running before the user even opens a session. Daemon processes are also considered user-space processes.
id-ID: ”Ruang pengguna” mengacu pada lingkungan runtime proses normal (sebagai lawan dari kernel). Ini tidak selalu berarti proses-proses ini benar-benar dimulai oleh pengguna karena sistem standar biasanya memiliki beberapa proses ”daemon” (atau latar belakang) yang berjalan sebelum pengguna bahkan membuka sesi. Proses daemon juga dianggap sebagai proses ruang pengguna.

en: When the kernel gets past its initialization phase, it starts the very first process, <command>init</command>. Process #1 alone is very rarely useful by itself, and Unix-like systems run with many additional processes.
id-ID: Ketika kernel berhasil melewati tahap inisialisasi, ia memulai proses pertama, <command>init</command>. Proses #1 sendiri sangat jarang berguna sendirian, dan sistem mirip Unix berjalan dengan banyak proses tambahan.

en: First of all, a process can clone itself (this is known as a <emphasis>fork</emphasis>). The kernel allocates a new (but identical) process memory space, and another process to use it. At this time, the only difference between these two processes is their <emphasis>pid</emphasis>. The new process is usually called a child process, and the original process whose <emphasis>pid</emphasis> doesn't change, is called the parent process.
id-ID: Pertama-tama, proses dapat mengklon dirinya sendiri (dikenal sebagai sebuah <emphasis>fork</emphasis>). Kernel mengalokasikan ruang memori proses yang baru (tapi identik), dan proses lain yang menggunakannya. Saat ini, satu-satunya perbedaan antara dua proses ini adalah <emphasis>pid</emphasis> mereka. Proses baru biasanya disebut proses anak, dan proses asli yang <emphasis>pid</emphasis>-nya tidak berubah, disebut proses induk.

en: Sometimes, the child process continues to lead its own life independently from its parent, with its own data copied from the parent process. In many cases, though, this child process executes another program. With a few exceptions, its memory is simply replaced by that of the new program, and execution of this new program begins. This is the mechanism used by the init process (with process number 1) to start additional services and execute the whole startup sequence. At some point, one process among <command>init</command>'s offspring starts a graphical interface for users to log in to (the actual sequence of events is described in more details in <xref linkend="sect.system-boot" />).
id-ID: Kadang-kadang, proses anak terus menjalani hidupnya sendiri secara mandiri dari induknya, dengan data sendiri yang disalin dari proses induk. Dalam banyak kasus, proses anak ini menjalankan program lain. Dengan beberapa pengecualian, memorinya hanya digantikan oleh program baru, dan eksekusi program baru ini dimulai. Ini adalah mekanisme yang digunakan oleh proses init (dengan proses nomor 1) untuk memulai layanan tambahan dan menjalankan seluruh urutan startup. Pada titik tertentu, satu proses di antara anak-anak <command>init</command> memulai antarmuka grafis bagi pengguna untuk masuk (urutan kejadian yang sebenarnya dijelaskan lebih detail di <xref linkend="sect.system-boot" />).

en: When a process finishes the task for which it was started, it terminates. The kernel then recovers the memory assigned to this process, and stops giving it slices of running time. The parent process is told about its child process being terminated, which allows a process to wait for the completion of a task it delegated to a child process. This behavior is plainly visible in command-line interpreters (known as <emphasis>shells</emphasis>). When a command is typed into a shell, the prompt only comes back when the execution of the command is over. Most shells allow for running the command in the background, it is a simple matter of adding an <userinput>&amp;</userinput> to the end of the command. The prompt is displayed again right away, which can lead to problems if the command needs to display data of its own.
id-ID: Ketika sebuah proses menyelesaikan tugas yang dimulai, itu berakhir. Kernel kemudian memulihkan memori yang ditugaskan untuk proses ini, dan berhenti memberikannya irisan waktu berjalan. Proses induk diberitahu tentang proses anaknya yang dihentikan, yang memungkinkan proses untuk menunggu penyelesaian tugas yang didelegasikan kepada proses anak. Perilaku ini terlihat jelas dalam penerjemah baris perintah (dikenal sebagai <emphasis>shells</emphasis>). Ketika sebuah perintah diketik ke dalam shell, prompt hanya akan kembali ketika eksekusi perintah selesai. Kebanyakan shell memungkinkan untuk menjalankan perintah di latar belakang, itu sekedar menambahkan <userinput>&amp;</userinput> ke ujung perintah. Prompt ditampilkan lagi segera, yang dapat menyebabkan masalah jika perintah perlu menampilkan data sendiri.

en: Daemons
id-ID: Daemon

en: A “daemon” is a process started automatically by the boot sequence. It keeps running (in the background) to perform maintenance tasks or provide services to other processes. This “background task” is actually arbitrary, and does not match anything particular from the system's point of view. They are simply processes, quite similar to other processes, which run in turn when their time slice comes. The distinction is only in the human language: a process that runs with no interaction with a user (in particular, without any graphical interface) is said to be running “in the background” or “as a daemon”.
id-ID: A ”daemon” adalah proses yang dimulai secara otomatis oleh urutan boot. Itu terus berjalan (di latar belakang) untuk melakukan tugas-tugas pemeliharaan atau memberikan layanan ke proses lain. ”Tugas latar belakang” ini sebenarnya sebarang, dan tidak cocok dengan apa pun dari sudut pandang sistem. Mereka hanyalah proses, sangat mirip dengan proses lain, yang berjalan pada gilirannya ketika irisan waktu mereka datang. Perbedaannya hanya dalam bahasa manusia: sebuah proses yang berjalan tanpa interaksi dengan pengguna (khususnya, tanpa antarmuka grafis) dikatakan berjalan ”di latar belakang” atau ”sebagai daemon”.

en: <emphasis>VOCABULARY</emphasis> Daemon, demon, a derogatory term?
id-ID: <emphasis>KOSA KATA</emphasis> Daemon, demon, istilah yang merendahkan?

en: Although <emphasis>daemon</emphasis> term shares its Greek etymology with <emphasis>demon</emphasis>, the former does not imply diabolical evil, instead, it should be understood as a kind of helper spirit. This distinction is subtle enough in English; it is even worse in other languages where the same word is used for both meanings.
id-ID: Meskipun istilah <emphasis>daemon</emphasis> memiliki etimologi Yunani yang sama dengan <emphasis>demon</emphasis> (setan), yang pertama tidak menyiratkan setan jahat, sebaliknya, harus dipahami sebagai semacam roh penolong. Perbedaan ini cukup halus dalam bahasa Inggris; hal ini bahkan lebih buruk dalam bahasa lain yang mana kata yang sama digunakan untuk kedua makna.

en: Several such daemons are described in detail in <xref linkend="unix-services" />.
id-ID: Beberapa daemon tersebut dijelaskan secara rinci dalam <xref linkend="unix-services" />.

en: An isolated process, whether a daemon or an interactive application, is rarely useful on its own, which is why there are several methods allowing separate processes to communicate together, either to exchange data or to control one another. The generic term referring to this is <emphasis>inter-process communication</emphasis>, or IPC for short.
id-ID: Suatu proses yang terisolasi, apakah itu daemon atau aplikasi interaktif, jarang berguna saat berdiri sendiri, itulah sebabnya ada beberapa metode yang memungkinkan proses terpisah untuk saling berkomunikasi, baik untuk bertukar data atau mengendalikan satu sama lain. Istilah umum yang mengacu pada ini adalah <emphasis>inter-process communication</emphasis>, atau disingkat IPC.

en: The simplest IPC system is to use files. The process that wishes to send data writes it into a file (with a name known in advance), while the recipient only has to open the file and read its contents.
id-ID: Sistem IPC yang paling sederhana adalah menggunakan berkas. Proses yang ingin mengirim data menulis ke berkas (dengan nama diketahui sebelumnya), sementara renerima hanya harus membuka berkas dan mebaca isinya.

en: In the case where you do not wish to store data on disk, you can use a <emphasis>pipe</emphasis>, which is simply an object with two ends; bytes written in one end are readable at the other. If the ends are controlled by separate processes, this leads to a simple and convenient inter-process communication channel. Pipes can be classified into two categories: named pipes, and anonymous pipes. A named pipe is represented by an entry on the filesystem (although the transmitted data is not stored there), so both processes can open it independently if the location of the named pipe is known beforehand. In cases where the communicating processes are related (for instance, a parent and its child process), the parent process can also create an anonymous pipe before forking, and the child inherits it. Both processes will then be able to exchange data through the pipe without needing the filesystem.
id-ID: Dalam kasus dimana Anda tidak ingin menyimpan data pada disk, Anda dapat menggunakan <emphasis>pipe</emphasis>, yang hanya merupakan objek dengan dua ujung; byte yang ditulis dalam satu ujung dapat dibaca di ujung yang lain. Jika ujungnya dikendalikan oleh proses terpisah, ini mengarah ke saluran komunikasi antar-proses yang sederhana dan nyaman. Pipa dapat diklasifikasikan menjadi dua kategori: pipa bernama, dan pipa anonim. Sebuah pipa bernama diwakili oleh sebuah entri pada sistem berkas (meskipun data yang ditransmisikan tidak disimpan di sana), sehingga kedua proses dapat membukanya secara independen jika lokasi dari pipa bernama diketahui sebelumnya. Dalam kasus dimana proses-proses yang berkomunikasi saling terkait (misalnya, induk dan proses anaknya), proses induk juga dapat membuat pipa anonim sebelum fork, dan anak mewarisi itu. Kedua proses kemudian akan dapat bertukar data melalui pipa tanpa perlu sistem berkas.

en: <emphasis>IN PRACTICE</emphasis> A concrete example
id-ID: <emphasis>DALAM PRAKTEK</emphasis> Contoh konkret

en: Let's describe in some detail what happens when a complex command (a <emphasis>pipeline</emphasis>) is run from a shell. We assume we have a <command>bash</command> process (the standard user shell on Debian), with <emphasis>pid</emphasis> 4374; into this shell, we type the command: <command>ls | sort</command> .
id-ID: Mari kita menjelaskan secara rinci apa yang terjadi ketika suatu perintah kompleks (suatu <emphasis>pipa</emphasis>) dijalankan dari shell. Kita berasumsi kita memiliki proses <command>bash</command> (shell pengguna standar pada Debian), dengan <emphasis>pid</emphasis> 4374; ke shell ini, kita ketik perintah: <command>ls | sort</command> .

en: The shell first interprets the command typed in. In our case, it understands there are two programs (<command>ls</command> and <command>sort</command>), with a data stream flowing from one to the other (denoted by the <userinput>|</userinput> character, known as <emphasis>pipe</emphasis>). <command>bash</command> first creates an unnamed pipe (which initially exists only within the <command>bash</command> process itself).
id-ID: Shell pertama menafsirkan perintah yang diketikkan. Dalam kasus kita, ia mengerti ada dua program (<command>ls</command> dan <command>sort</command>), dengan data yang mengalir dari satu ke yang lain (dilambangkan oleh karakter <userinput>|</userinput>, dikenal sebagai <emphasis>pipa</emphasis>). <command>bash</command> pertama menciptakan pipa tanpa nama (yang awalnya ada hanya dalam proses <command>bash</command> itu sendiri).

en: Then the shell clones itself; this leads to a new <command>bash</command> process, with <emphasis>pid</emphasis> #4521 (<emphasis>pids</emphasis> are abstract numbers, and generally have no particular meaning). Process #4521 inherits the pipe, which means it is able to write in its “input” side; <command>bash</command> redirects its standard output stream to this pipe's input. Then it executes (and replaces itself with) the <command>ls</command> program, which lists the contents of the current directory. Since <command>ls</command> writes on its standard output, and this output has previously been redirected, the results are effectively sent into the pipe.
id-ID: Kemudian shell meng-klon dirinya sendiri; ini mengantar ke sebuah proses <command>bash</command> baru, dengan <emphasis>pid</emphasis> #4521 (<emphasis>pid</emphasis> adalah bilangan abstrak, dan umumnya tidak punya arti khusus). Proses #4521 mewarisi pipa, yang berarti itu dapat menulis ke sisi “masukan”; <command>bash</command> mengalihkan stream keluaran standarnya ke masukan pipa ini. Kemudian itu menjalankan (dan menggantikan dirinya sendiri dengan) program <command>ls</command>, yang menampilkan daftar isi dari direktori saat ini. Karena <command>ls</command> menulis ke keluaran standarnya, dan keluaran ini sebelumnya telah dialihkan, hasilnya secara efektif dikirim ke dalam pipa.

en: A similar operation happens for the second command: <command>bash</command> clones itself again, leading to a new <command>bash</command> process with pid #4522. Since it is also a child process of #4374, it also inherits the pipe; <command>bash</command> then connects its standard input to the pipe output, then executes (and replaces itself with) the <command>sort</command> command, which sorts its input and displays the results.
id-ID: Sebuah operasi serupa yang terjadi untuk perintah ke dua: <command>bash</command> meng-klon dirinya sendiri lagi, mengarah ke proses <command>bash</command> baru dengan pid #4522. Karena itu juga proses anak dari #4374, itu juga mewarisi pipa; <command>bash</command> kemudian menghubungkan masukan standar ke keluaran pipa, lalu mengeksekusi (dan menggantikan dirinya sendiri dengan) perintah <command>sort</command>, yang mengurutkan masukan dan menampilkan hasilnya.

en: All the pieces of the puzzle are now set up: <command>ls</command> reads the current directory and writes the list of files into the pipe; <command>sort</command> reads this list, sorts it alphabetically, and displays the results. Processes numbers #4521 and #4522 then terminate, and #4374 (which was waiting for them during the operation), resumes control and displays the prompt to allow the user to type in a new command.
id-ID: Semua potongan teka-teki sekarang siap: <command>ls</command> membaca direktori saat ini dan menulis daftar berkas ke dalam pipa; <command>sort</command> membaca daftar ini, mengurutkan berdasarkan abjad, dan menampilkan hasilnya. Proses nomor #4521 dan #4522 kemudian berakhir, dan #4374 (yang menunggu mereka selama operasi), melanjutkan kendali dan menampilkan sapaan yang memungkinkan pengguna untuk mengetik perintah baru.

en: Not all inter-process communications are used to move data around, though. In many situations, the only information that needs to be transmitted are control messages such as “pause execution” or “resume execution”. Unix (and Linux) provides a mechanism known as <emphasis>signals</emphasis>, through which a process can simply send a specific signal (chosen from a predefined list of signals) to another process. The only requirement is to know the <emphasis>pid</emphasis> of the target.
id-ID: Tidak semua komunikasi antar-proses digunakan untuk memindahkan data. Dalam banyak situasi, satu-satunya informasi yang perlu ditransmisikan adalah pesan kontrol seperti “jeda eksekusi” atau “melanjutkan eksekusi”. Unix (dan Linux) menyediakan mekanisme yang dikenal sebagai <emphasis>sinyal</emphasis>, dimana suatu proses dapat sekedar mengirim sinyal tertentu (dipilih dari daftar sinyal yang telah ditentukan) ke proses lain. Satu-satunya persyaratan adalah mengetahui <emphasis>pid</emphasis> dari target.

en: For more complex communications, there are also mechanisms allowing a process to open access, or share, part of its allocated memory to other processes. Memory now shared between them can be used to move data between the processes.
id-ID: Untuk komunikasi yang lebih kompleks, ada juga mekanisme yang memungkinkan proses untuk membuka akses, atau berbagi, bagian dari memori yang dialokasikan untuk proses lain. Memori yang sekarang dipakai bersama di antara mereka dapat digunakan untuk memindahkan data antar proses.

en: Finally, network connections can also help processes communicate; these processes can even be running on different computers, possibly thousands of kilometers apart.
id-ID: Akhirnya, koneksi jaringan juga dapat membantu proses-proses berkomunikasi; proses-proses ini bahkan dapat berjalan di komputer yang berbeda, mungkin terpisah ribuan kilometer.

en: It is quite standard for a typical Unix-like system to make use of all these mechanisms to various degrees.
id-ID: Sudah biasa bagi sistem mirip Unix untuk, sedikit banyak, menggunakan semua mekanisme ini.

en: Libraries
id-ID: Pustaka

en: <primary>library (of functions)</primary>
id-ID: <primary>perpustakaan (fungsi)</primary>

en: Function libraries play a crucial role in a Unix-like operating system. They are not proper programs, since they cannot be executed on their own, but collections of code fragments that can be used by standard programs. Among the common libraries, you can find:
id-ID: Pustaka fungsi memainkan peran penting dalam sistem operasi mirip Unix. Mereka bukan program yang utuh, karena mereka tidak dapat dieksekusi sendiri, tetapi merupakan koleksi fragmen kode yang dapat digunakan oleh program standar. Di antara pustaka umum, Anda dapat menemukan:

en: the standard C library (<emphasis>glibc</emphasis>), which contains basic functions such as ones to open files or network connections, and others facilitating interactions with the kernel;
id-ID: pustaka C standar (<emphasis>glibc</emphasis>), yang berisi fungsi-fungsi dasar seperti untuk membuka berkas atau koneksi jaringan, dan yang lain memfasilitasi interaksi dengan kernel;

en: graphical toolkits, such as Gtk+ and Qt, allowing many programs to reuse the graphical objects they provide;
id-ID: toolkit grafis, seperti Gtk+ dan Qt, memungkinkan banyak program untuk menggunakan kembali objek grafis yang mereka sediakan;

en: the <emphasis>libpng</emphasis> library, which allows loading, interpreting and saving images in the PNG format.
id-ID: pustaka <emphasis>libpng</emphasis>, yang memungkinkan memuat, menafsirkan, dan menyimpan gambar dalam format PNG.

en: Thanks to those libraries, applications can reuse existing code. Application development is simplified since many applications can reuse the same functions. With libraries often developed by different persons, the global development of the system is closer to Unix's historical philosophy.
id-ID: Berkat pustaka tersebut, aplikasi dapat menggunakan kembali kode yang ada. Pengembangan aplikasi disederhanakan karena banyak aplikasi dapat menggunakan kembali fungsi yang sama. Dengan pustaka yang sering dikembangkan oleh orang yang berbeda, perkembangan global dari sistem lebih dekat dengan filosofi sejarah Unix.

en: <emphasis>CULTURE</emphasis> The Unix Way: one thing at a time
id-ID: <emphasis>BUDAYA</emphasis> Cara Unix: satu hal pada suatu waktu

en: One of the fundamental concepts that underlies the Unix family of operating systems is that each tool should only do one thing, and do it well; applications can then reuse these tools to build more advanced logic on top. This philosophy can be seen in many incarnations. Shell scripts may be the best example: they assemble complex sequences of very simple tools (such as <command>grep</command>, <command>wc</command>, <command>sort</command>, <command>uniq</command> and so on). Another implementation of this philosophy can be seen in code libraries: the <emphasis>libpng</emphasis> library allows reading and writing PNG images, with different options and in different ways, but it does only that; no question of including functions that display or edit images.
id-ID: Satu dari konsep fundamental yang mendasari keluarga sistem operasi Unix adalah bahwa setiap alat mesti hanya melakukan satu hal, dan melakukannya dengan baik; aplikasi kemudian dapat memakai lagi alat-alat ini untuk membangun lebih banyak logika tingkat lanjut di atasnya. Filosofi ini dapat dilihat dalam banyak inkarnasi. Skrip shell mungkin adalah contoh terbaik: mereka merangkai urutan yang kompleks dari alat-alat yang sangat sederhana (seperti misalnya <command>grep</command>, <command>wc</command>, <command>sort</command>, <command>uniq</command>, dan seterusnya). Implementasi lain dari filosofi ini dapat dilihat dalam pustaka kode: pustaka <emphasis>libpng</emphasis> memungkinkan membaca dan menulis citra-citra PNG, dengan opsi-opsi lain dan dalam cara-cara yang berbeda, tapi hanya melakukan itu; tidak ada pertanyaan untuk memasukkan fungsi-fungsi yang menampilkan atau menyunting citra.

en: Moreover, these libraries are often referred to as “shared libraries”, since the kernel is able to only load them into memory once, even if several processes use the same library at the same time. This allows saving memory, when compared with the opposite (hypothetical) situation where the code for a library would be loaded as many times as there are processes using it.
id-ID: Selain itu, pustaka ini sering dirujuk sebagai “pustaka bersama”, karena kernel bisa hanya memuat mereka ke dalam memori sekali, bahkan jika beberapa proses menggunakan pustaka yang sama pada waktu yang sama. Hal ini memungkinkan penghematan memori, bila dibandingkan dengan situasi (hipotetis) sebaliknya dimana kode untuk pustaka akan dimuat sebanyak proses yang menggunakannya.
