Merge pull request #1 from adambard/master

update

13 files changed, 3509 insertions, 0 deletions

diff --git a/id-id/asciidoc-id.html.markdown b/id-id/asciidoc-id.html.markdown
new file mode 100644
index 00000000..ceb56b92
--- /dev/null
+++ b/id-id/asciidoc-id.html.markdown
@@ -0,0 +1,121 @@
+---
+language: asciidoc
+contributors:
+    - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+translators:
+    - ["Rizky Luthfianto", "http://github.com/rilut"]
+filename: asciidoc-id.md
+lang: id-id
+---
+
+AsciiDoc adalah bahasa markup yang mirip dengan Markdown dan dapat digunakan untuk apa saja, untuk menulis buku maupun blog. Dibuat pada tahun 2002 oleh Stuart Rackham, bahasa ini sederhana tetapi memungkinkan sejumlah besar kustomisasi.
+
+Kepala Dokumen
+
+Kepala Dokumen adalah opsional dan tidak dapat berisi baris kosong. Harus diimbangi konten, setidaknya satu baris kosong.
+
+Hanya Judul 
+
+```
+= Judul Dokumen
+
+Kalimat pertama dokumen.
+```
+
+Judul dan Penulis
+
+```
+= Judul Dokumen
+Pertama terakhir <first.last@learnxinyminutes.com>
+
+Awal dokumen ini.
+```
+
+Banyak Penulis
+
+```
+= Judul Dokumen
+John Doe <john@go.com>; Jane Doe <jane@yo.com>; Black Beard <beardy@pirate.com>
+
+Memulai dokumen dengan banyak penulis.
+```
+
+Garis Revisi (membutuhkan garis penulis)
+
+```
+= Judul Dokumen V1
+Manusia Kentang <keripik@renyah.com>
+v1.0, 2016/01/13
+
+Artikel tentang keripik ini akan menjadi menyenangkan.
+```
+
+Paragraf
+
+```
+Anda tidak perlu sesuatu yang istimewa untuk paragraf.
+
+Tambahkan baris kosong antara paragraf untuk memisahkan mereka.
+
+Untuk membuat baris kosong, tambahkan: +
+dan Anda akan mendapat satu baris kosong!
+```
+
+Memformat Teks
+
+```
+_underscore menciptakan miring_
+*Tanda bintang untuk tebal*
+*_Gabungkan biar makin asyik_*
+`Penggunaan tanda petik untuk menandakan monospace`
+`*Monospace tebal*`
+```
+
+Judul bagian
+
+```
+= Level 0 (hanya dapat digunakan dalam header dokumen)
+
+== Level 1 <h2>
+
+=== Level 2 <h3>
+
+==== Level 3 <h4>
+
+===== Level 4 <h5>
+
+```
+
+Daftar
+
+Untuk membuat daftar bullet, gunakan tanda bintang.
+
+```
+* foo
+* bar
+* baz
+```
+
+Untuk membuat daftar bernomor, gunakan titik.
+
+```
+. Item 1
+. item 2
+. Item 3
+```
+
+Anda bisa membuat daftar bersarang dengan menambahkan tanda bintang atau titik tambahan hingga lima kali.
+
+```
+* Foo 1
+** Foo 2
+*** Foo 3
+**** Foo 4
+***** Foo 5
+
+. foo 1
+.. Foo 2
+... Foo 3
+.... Foo 4
+..... Foo 5
+```
diff --git a/id-id/bf-id.html.markdown b/id-id/bf-id.html.markdown
new file mode 100644
index 00000000..9901290b
--- /dev/null
+++ b/id-id/bf-id.html.markdown
@@ -0,0 +1,86 @@
+---
+language: "Brainfuck"
+filename: brainfuck-id.bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Muhammad Rifqi Fatchurrahman", "http://muhrifqii.github.io/"]
+lang: id-id
+---
+
+Brainfuck (tidak dalam huruf kapital kecuali pada awal kalimat) adalah sebuah
+bahasa pemrograman Turing-complete yang sangat minim yang hanya memiliki 8 perintah.
+
+Anda bisa mencoba brainfuck pada browser dengan menggunakan [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```bf
+Karakter apapun selain "><+-.,[]" (tanda kutip tidak termasuk) diabaikan.
+
+Brainfuck direpresentasikan dengan sebuah array yang memiliki 30,000 cell yang
+diinisialisasi dengan nol dan pointer data yang menunjuk ke current cell.
+
+Terdapat delapan perintah:
++ : Menaikkan nilai pada current cell sebesar satu.
+- : Menurunkan nilai pada current cell sebesar satu.
+> : Menggeser pointer data ke cell selanjutnya (cell sebelah kanan).
+< : Menggeser pointer data ke cell sebelumnya (cell sebelah kiri).
+. : Mencetak nilai ASCII pada current cell (misal 65 = 'A').
+, : Membaca sebuah karakter masukan tunggal ke dalam current cell.
+[ : Jika nilai pada current cell bernilai nol, lewati hingga mencapai ] yang sesuai.
+    Jika tidak, pindah ke instruksi berikutnya.
+] : Jika nilai pada current cell bernilai nol, pindah ke instruksi berikutnya.
+    Jika tidak, mundur pada instruksi hingga mencapai [ yang sesuai.
+
+[ dan ] membentuk sebuah rekursi while. Tentu saja mereka harus seimbang.
+
+Mari kita lihat beberapa program brainfuck dasar.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Program ini mencetak huruf 'A'. Mula-mula, cell #1 dinaikkan ke 6.
+Cell #1 akan digunakan untuk rekursi. Lalu, masuk ke rekursi ([) dan pindah
+ke cell #2. Cell #2 dinaikkan 10 kali, mundur ke cell #1, dan menurunkan
+cell #1. Rekursi ini berlangsung 6 kali (melakukan 6 penurunan nilai untuk 
+cell #1 hingga mencapai 0, di titik mana dia melewati hingga mencapai ] dan
+terus berlanjut).
+
+Pada titik ini, kita berada pada cell #1, yang memiliki nilai 0, sedangkan cell #2
+memiliki sebuah nilai 60. Kita berpindah ke cell #2, menaikkan nilai 5 kali, memunculkan 
+nilai 65, lalu cetak nilai pada cell #2. 65 adalah 'A' pada ASCII, jadi 'A' 
+dicetak ke terminal.
+
+, [ > + < - ] > .
+
+Program ini membaca sebuah karakter dari masukan user dan menyalin karakternya ke
+cell #1. Setelah itu rekursi dimulai. Geser ke cell #2, menaikkan nilai pada cell #2,
+mundur ke cell #1, dan menurunkan nilai pada cell #1. Hal ini berlanjut sampai cell #1
+bernilai 0, dan cell #2 menyimpan nilai lama dari cell #1. Karena kita berada di cell #1
+saat ujung rekursi, geser ke cell #2, lalu cetak nilai dalam bentuk ASCII.
+
+Perlu diingat bahwa spasi itu murni untuk memudahkan membaca. Anda bisa 
+menuliskannya dengan mudah seperti:
+
+,[>+<-]>.
+
+Coba dan cari tahu apa yang program ini lakukan:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Program ini menerima dua buah angka sebagai input, lalu mengalikannya.
+
+Intinya adalah membaca dua masukan. Lalu mulai pada rekursi terluar yang
+kondisinya pada cell #1. Lalu pindah ke cell #2, dan mulai rekursi terdalam
+yang kondisinya ada pada cell #2, menaikkan nilai pada cell #3. Namun,
+ada suatu masalah: Pada akhir dari rekursi terdalam, cell #2 bernilai nol.
+Pada kasus tersebut, rekursi terdalam tidak dapat bekerja lagi mulai setelah ini.
+Untuk menyelesaikan masalah tersebut, kita juga menaikkan cell #4, dan menyalin
+ulang cell #4 ke cell #2. Maka cell #3 adalah hasilnya.
+```
+
+Dan itulah brainfuck. Tidak terlalu sulit kan? Hanya untuk iseng-iseng, anda 
+bisa menuliskan porgram brainfuck anda sendiri, atau anda bisa menuliskan interpreter 
+brainfuck pada bahasa lain. Interpreternya tidak begitu sulit untuk diimplementasikan, 
+tapi jika anda seorang masokis, cobalah menulis sebuah interpreter brainfuck... dalam 
+brainfuck.
+
diff --git a/id-id/coffeescript-id.html.markdown b/id-id/coffeescript-id.html.markdown
new file mode 100644
index 00000000..7fa40bb6
--- /dev/null
+++ b/id-id/coffeescript-id.html.markdown
@@ -0,0 +1,106 @@
+---
+language: coffeescript
+contributors:
+  - ["Tenor Biel", "http://github.com/L8D"]
+  - ["Xavier Yao", "http://github.com/xavieryao"]
+filename: coffeescript-id.coffee
+translators:
+  - ["Rizky Luthfianto", "http://github.com/rilut"]
+lang: id-id
+---
+
+CoffeeScript adalah bahasa sederhana yang diterjemahkan saat kompilasi ke dalam JavaScript,
+dan bukan diterjemahkan pada saat *runtime*.  
+CoffeeScript mencoba agar kode JavaScript yang dihasilkan tetap mudah dibaca
+dan kompatibel dengan semua *runtime* JavaScript.
+
+Lihat juga [website CoffeeScript](http://coffeescript.org/) yang memiliki tutorial lengkap tentang CoffeeScript.
+
+```CoffeeScript
+# CoffeeScript adalah bahasa hipster.
+# Mengikuti tren bahasa modern lainnya.
+# Sehingga, seperti Ruby dan Python, untuk komentar digunakan tanda pagar.
+
+###
+Ini adalah contoh blok komentar, yang nanti diterjemahkan langsung ke '/ *' dan '* /'
+pada kode JavaScript yang dihasilkan.
+
+Anda diharapkan sedikit memahami semantik JavaScript sebelum melanjutkan tutorial ini.
+###
+
+# Pengisian nilai variabel:
+angka = 42 #=> var angka = 42;
+kebalikan = true #=> var kebalikan = true;
+
+# Kondisi:
+angka = -42 if kebalikan #=> if(kebalikan) { angka = -42; }
+
+# Fungsi:
+kuadrat = (x) -> x * x #=> var kuadrat = function(x) { return x * x; }
+
+isi = (wadah, cairan = "kopi") ->
+  "Mengisi #{wadah} dengan #{cairan}..."
+#=>var isi;
+#
+#isi = function(wadah, cairan) {
+#  if (cairan == null) {
+#    cairan = "kopi";
+#  }
+#  return "Mengisi " + wadah + " dengan " + cairan + "...";
+#};
+
+# Rentang:
+list = [1..5] # => var list = [1, 2, 3, 4, 5];
+
+# Objek:
+fungsi_matematika =
+  akar:   Math.sqrt
+  kuadrat: kuadrat
+  kubik:   (x) -> x * kuadrat x
+#=> var fungsi_matematika = {
+#    "akar": Math.sqrt,
+#    "kuadrat": kuadrat,
+#    "kubik": function(x) { return x * kuadrat(x); }
+#   };
+
+# *Splat*:
+balapan = (pemenang, pelari...) ->
+  print pemenang, pelari
+#=>balapan = function() {
+#    var pelari, pemenang;
+#    pemenang = arguments[0], pelari = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+#    return print(pemenang, pelari);
+#  };
+
+# Cek keberadaan:
+alert "Elvis ada!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Elvis ada!"); }
+
+# Komprehensi *array*:
+kubik_kubik = (fungsi_matematika.kubik angka for angka in list)
+#=>kubik_kubik = (function() {
+#     var _i, _len, _hasil;
+#     _hasil = [];
+#     for (_i = 0, _len = list.length; _i < _len; _i++) {
+#         angka = list[_i];
+#         _hasil.push(fungsi_matematika.kubik(angka));
+#     }
+#     return _hasil;
+#})();
+
+sayur_sayuran = ['brokoli', 'bayam', 'kemangi']
+makan sayuran for sayuran in sayur_sayuran when sayuran isnt 'kemangi'
+#=>sayur_sayuran = ['brokoli', 'bayam', 'kemangi'];
+#
+#for (_k = 0, _len2 = sayur_sayuran.length; _k < _len2; _k++) {
+#  sayuran = sayur_sayuran[_k];
+#  if (sayuran !== 'kemangi') {
+#    makan(sayuran);
+#  }
+#}
+```
+
+## Referensi Tambahan
+
+- [Smooth CoffeeScript (EN)] (http://autotelicum.github.io/Smooth-CoffeeScript/)
+- [CoffeeScript Ristretto (EN)] (https://leanpub.com/coffeescript-ristretto/read)
diff --git a/id-id/hq9+-id.html.markdown b/id-id/hq9+-id.html.markdown
new file mode 100644
index 00000000..46abcf42
--- /dev/null
+++ b/id-id/hq9+-id.html.markdown
@@ -0,0 +1,45 @@
+---
+language: HQ9+
+filename: hq9+-id.html
+contributors:
+    - ["Alexey Nazaroff", "https://github.com/rogaven"]
+translators:
+  - ["Haydar Ali Ismail", "http://github.com/haydarai"]
+lang: id-id
+---
+
+HQ9+ adalah bahasa pemrograman gurauan yang dibuat oleh Cliff Biffle. Bahasa
+ini hanya memiliki empat perintah dan tidak memenuhi Turing-complete.
+
+```
+Hanya ada 4 perintah, masing-masing direpresentasikan oleh karakter berikut
+H: mencetak "Hello, world!"
+Q: mencetak kode sumber dari program ini (Quine)
+9: mencetak lirik dari lagu "99 Bottles of Beer"
++: menambah nilai satu ke akumulator (nilai dari akumulator tidak dapat
+	diakses)
+Karakter lain akan dihiraukan.
+
+Ok. Mari kita menulis beberapa program:
+  HQ9
+
+Hasil:
+  Hello world!
+  HQ9
+
+HQ9+ sangat sederhana, tetapi membuat anda bisa melakukan hal yang sangat sulit
+dilakukan di bahasa lain. Sebagai contoh, berikut sebuah program yang
+menciptakan tiga salinan dirinya sendiri ke layar:
+  QQQ
+
+Ini menghasilakn:
+  QQQ
+  QQQ
+  QQQ
+```
+
+Dan itu semuanya. Ada banyak interpreters untuk HQ9+. Kamu bisa menemukannya di
+bawah
+
++ [Salah satu interpreter online](https://almnet.de/esolang/hq9plus.php)
++ [Website resmi HQ9+](http://cliffle.com/esoterica/hq9plus.html)
diff --git a/id-id/java-id.html.markdown b/id-id/java-id.html.markdown
new file mode 100644
index 00000000..a5455952
--- /dev/null
+++ b/id-id/java-id.html.markdown
@@ -0,0 +1,801 @@
+---
+language: java
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Jakukyo Friel", "http://weakish.github.io"]
+    - ["Madison Dickson", "http://github.com/mix3d"]
+    - ["Simon Morgan", "http://sjm.io/"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
+    - ["Rachel Stiyer", "https://github.com/rstiyer"]
+filename: LearnJava-id.java
+translators:
+  - ["Ahmad Zafrullah", "https://github.com/23Pstars"]
+lang: id-id
+---
+
+Java adalah bahasa pemrograman yang memiliki tujuan umum dan berorientasi kelas dan objek.
+[Baca lebih lanjut.](http://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Komentar satu baris diawali dengan // (dua garis miring)
+/*
+Ini adalah contoh komentar banyak-baris.
+*/
+/**
+Ini adalah contoh komentar JavaDoc. Digunakan untuk mendeskripsikan sebuah kelas,
+atau beberapa sifat dari kelas tersebut.
+*/
+
+// Menyertakan kelas ArrayList dalam paket java.util
+import java.util.ArrayList;
+// Menyertakan semua kelas yang ada dalam paket java.security
+import java.security.*;
+
+// Setiap dokumen .java sebuah kelas publik dengan nama yang sama dengan nama kelas.
+public class BelajarJava {
+
+    // Untuk menjalankan program java, program harus memiliki sebuah method utama (main) sebagai awalan.
+    public static void main (String[] args) {
+
+        // System.out.println() digunakan untuk menampilkan satu baris teks.
+        System.out.println("Halo Dunia!");
+        System.out.println(
+            "Integer: " + 10 +
+            " Double: " + 3.14 +
+            " Boolean: " + true);
+
+        // System.out.print() hanya menampilkan teks tanpa baris baru.
+        System.out.print("Halo ");
+        System.out.print("Dunia");
+
+        // System.out.printf() memudahkan dalam mengatur format penampilan.
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
+
+        ///////////////////////////////////////
+        // Variabel
+        ///////////////////////////////////////
+
+        /*
+        *  Deklarasi Variabel
+        */
+        // Deklarasi variabel menggunakan format <tipe> <nama>
+        int nilai;
+        // Deklarasi banyak variabel menggunakan format yang sama <tipe> <nama1>, <tipe> <nama2>, <tipe> <nama3>
+        int nilai1, nilai2, nilai3;
+
+        /*
+        *  Inisialisasi Variabel
+        */
+
+        // Inisialisasi sebuah variabel menggunakan <tipe> <nama> = <nilai>
+        int nilai = 1;
+        // Inisialisasi banyak variabel menggunakan format yang sama <tipe> <nama1>, <nama2>, <nama3> = <nilai>
+        int nilai1, nilai2, nilai3;
+        nilai1 = nilai2 = nilai3 = 1;
+
+        /*
+        *  Tipe Variabel
+        */
+        // Byte - 8 bit signed untuk bilangan bulat komplemen 2
+        // (-128 <= byte <= 127)
+        byte nilaiByte = 100;
+
+        // Short - 8 bit signed untuk bilangan bulat komplemen 2
+        // (-32,768 <= short <= 32,767)
+        short nilaiShort = 10000;
+
+        // Integer - 32 bit signed untuk bilangan bulat komplemen 2
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int nilaiInt = 1;
+
+        // Long - 64 bit signed untuk bilangan bulat komplemen 2
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long nilaiLong = 100000L;
+        // Karakter "L" pada akhir nilai menyatakan tipe Long;
+        // selainnya akan dianggap sebagai nilai bilangan bulat.
+
+        // Catatan: Java tidak memiliki tipe unsigned.
+
+        // Float - Presisi-satu 32-bit standar IEEE 754 untuk Floating Point
+        // 2^-149 <= float <= (2-2^-23) * 2^127
+        float nilaiFloat = 234.5f;
+        // Karakter "f" atau "F" pada akhir nilai menyatakan tipe Float;
+        // selainnya akan dianggap sebagai nilai double.
+
+        // Double - Presisi-dua 64-bit standar IEEE 754 untuk Floating Point
+        // 2^-1074 <= x <= (2-2^-52) * 2^1023
+        double nilaiDouble = 123.4;
+
+        // Boolean - true & false
+        boolean nilaiBoolean = true;
+        boolean nilaiBoolean = false;
+
+        // Char - Sebuah karakter Unicode 16-bit
+        char nilaiChar = 'A';
+
+        // Variabel "final" tidak dapat di-set kembali nilainya pada objek lain,
+        final int WAKTU_SAYA_BEKERJA_TIAP_MINGGU = 9001;
+        // tapi dapat dilakukan inisialisasi diwaktu yang lain.
+        final double E;
+        E = 2.71828;
+
+
+        // BigInteger - Bilangan bulat yang memiliki presisi dinamis
+        //
+        // BigInteger adalah tipe data yang memungkinkan pembuat program untuk memanipulasi
+        // bilangan bulat lebih panjang dari 64-bit. Bilangan bulat tersebut tersimpan dalam
+        // bentuk kumpulan byte (array) dan dimanipulasi menggunakan fungsi yang sudah tersedia
+        // pada BigInteger
+        //
+        // BigInteger dapat diinisialisasi menggunakan kumpulan byte atau teks.
+        
+        BigInteger nilaiBigInteger = new BigInteger(kumpulanByte);
+
+
+        // BigDecimal - Bilangan signed desimal yang memiliki presisi dinamis
+        //
+        // Tipe BigDecimal memiliki dua bagian: sebuah bilangan bulat dengan nilai presisi
+        // dinamis tanpa skala dan sebuah bilangan bulat skala 32-bit.
+
+        // BigDecimal memungkinkan pembuat program untuk memegang kontrol penuh
+        // terhadap batas desimal. BigDecimal baik digunakan untuk nilai tukar mata uang
+        // dimana sangat mementingkan presisi nilai desimal.
+        //
+        // BigDecimal dapat diinisialisasi dengan int, long, double, String,
+        // atau dengan melakukan inisialisasi nilai tanpa skala (BigInteger) 
+        // dan nilai dengan skala (int). 
+
+        BigDecimal nilaiBigDecimal = new BigDecimal(nilaiBigInteger, nilaiInt);
+        
+        // Perlu diperhatikan konstruktor yang digunakan apakah float atau double
+        // karena dapat mengakibatkan ketidak-akurasian float/double yang akan digunakan
+        // dalam BigDecimal. Sebaiknya gunakan nilai String pada konstruktor
+        // jika membutuhkan nilai pasti.
+        
+        BigDecimal sepuluhSen = new BigDecimal("0.1");
+
+
+        // Strings
+        String nilaiString1 = "Ini adalah contoh String!";
+
+        // Karakter \n berfungsi untuk membuat baris baru 
+        String nilaiString2 = "Menampilkan baris baru?\nTidak masalah!";
+        // Karakter \t berfungsi untuk membuat tab antar karakter
+        String nilaiString3 = "Ingin menambahkan sebuah tab?\tTidak masalah!";
+        System.out.println(nilaiString1);
+        System.out.println(nilaiString2);
+        System.out.println(nilaiString3);
+
+        // Larik (array)
+        // Ukuran array harus ditentukan ketika instansiasi
+        // Format berikut adalah beberapa cara deklarasi array
+        // <tipe data>[] <nama variabel> = new <tipe data>[<ukuran array>];
+        // <tipe data> <nama variabel>[] = new <tipe data>[<ukuran array>];
+        int[] barisAngka = new int[10];
+        String[] barisString = new String[1];
+        boolean barisBoolean[] = new boolean[100];
+
+        // Cara lain untuk mendeklarasikan dan menginisialisasi sebuah array
+        int[] y = {9000, 1000, 1337};
+        String nama[] = {"Andi", "Budi", "Agus"};
+        boolean bools[] = new boolean[] {true, false, false};
+
+        // Indeks sebuah array - Mengakses sebuah elemen
+        System.out.println("barisAngka @ 0: " + barisAngka[0]);
+
+        // Array menggunakan indeks 0 yang tetap.
+        barisAngka[1] = 1;
+        System.out.println("barisAngka @ 1: " + barisAngka[1]); // => 1
+
+        // Lainnya yang perlu diketahui
+        // ArrayLists - Sama seperti array biasa, namum penggunaannya sudah ditentukan,
+        //              dan ukurannya dapat berubah-ubah.
+        // LinkedLists - Implementasi dari doubly-linked list. Semua operasi yang digunakan
+        //               hampir sama dengan operasi yang dimiliki oleh sebuah doubly-linked list.
+        // Maps - Sebuah kumpulan objek yang menyatakan hubungan antara kunci dan nilai. Map merupakan
+        //        sebuah interface sehingga tidak dapat diinstansiasi. Jenis kunci dan nilai yang digunakan
+        //        pada Map harus spesifik pada saat instansiasi ketika diimplementasikan pada sebuah kelas.
+        //        Setiap kunci hanya memiliki sebuah nilai, dan hanya muncul sekali.
+        // HashMaps - Kelas ini menggunakan tabel-hash untuk mengimplementasikan interface Map.
+        //            Hal ini memungkinkan waktu eksekusi ketika melakukan operasi dasar (mengakses
+        //            dan menambahkan elemen) menjadi konstan, meskipun memiliki banyak set data.
+
+        ///////////////////////////////////////
+        // Operator
+        ///////////////////////////////////////
+        System.out.println("\n->Operator");
+
+        int i1 = 1, i2 = 2; // Cara singkat untuk deklarasi banyak nilai
+
+        // Kemudahan dalam artimatika
+        System.out.println("1+2 = " + (i1 + i2)); // => 3
+        System.out.println("2-1 = " + (i2 - i1)); // => 1
+        System.out.println("2*1 = " + (i2 * i1)); // => 2
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int menghasilkan int juga)
+        System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
+
+        // Modulus
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Operator Perbandingan
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // Operator Boolean
+        System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+        System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+        System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
+        // Operator Bitwise
+        /*
+        ~      Unary bitwise complement
+        <<     Signed left shift
+        >>     Signed/Arithmetic right shift
+        >>>    Unsigned/Logical right shift
+        &      Bitwise AND
+        ^      Bitwise exclusive OR
+        |      Bitwise inclusive OR
+        */
+
+        // Peningkatan
+        int i = 0;
+        System.out.println("\n->Pengurangan/Peningkatan");
+        // Operator ++ dan -- masing-masing melakukan peningkatan dan penurunan 1 nilai.
+        // Jika diletakkan sebelum variabel, maka akan di tambah/kurang 1 sebelum dilakukan perintah lainnya;
+        // jika setelah variabel, maka akan ditambah/kurang 1 setelah dilakukan perintah lainnya;
+        System.out.println(i++); // i = 1, prints 0 (peningkatan setelahnya)
+        System.out.println(++i); // i = 2, prints 2 (peningkatan sebelumnya)
+        System.out.println(i--); // i = 1, prints 2 (pengurangan setelahnya)
+        System.out.println(--i); // i = 0, prints 0 (pengurangan sebelumnya)
+
+        ///////////////////////////////////////
+        // Struktur Kontrol
+        ///////////////////////////////////////
+        System.out.println("\n->Struktur Kontrol");
+
+        // Perintah "if" hampir sama dengan bahasa C
+        int j = 10;
+        if (j == 10) {
+            System.out.println("Saya ditampilkan");
+        } else if (j > 10) {
+            System.out.println("Saya tidak ditampilkan");
+        } else {
+            System.out.println("Saya juga tidak ditampilkan");
+        }
+
+        // Perulangan "while"
+        int fooWhile = 0;
+        while(fooWhile < 100) {
+            System.out.println(fooWhile);
+            // Tingkatkan penghitung
+            // 100 kali iterasi, fooWhile 0,1,3,...,99
+            fooWhile++;
+        }
+        System.out.println("Nilai fooWhile: " + fooWhile);
+
+        // Perulangan "do...while"
+        int fooDoWhile = 0;
+        do {
+            System.out.println(fooDoWhile);
+            // Tingkatkan penghitung
+            // 99 kali iterasi, fooDoWhile 0->99
+            fooDoWhile++;
+        } while(fooDoWhile < 100);
+        System.out.println("Nilai fooDoWhile: " + fooDoWhile);
+
+        // Perulangan "for"
+        // Struktur perulangan "for" => for(<awal_pernyataan>; <kondisi>; <langkah/tahapan>)
+        for (int fooFor = 0; fooFor < 10; fooFor++) {
+            System.out.println(fooFor);
+            // 10 kali iterasi, foofor 0-9
+        }
+        System.out.println("Nilai fooFor: " + fooFor);
+        
+        // Perulangan "for" bertingkat dengan label "exit"
+        outer:
+        for (int i = 0; i < 10; i++) {
+          for (int j = 0; j < 10; j++) {
+            if (i == 5 && j ==5) {
+              break outer;
+              // Menghentikan semua perulangan, tidak hanya perulangan bagian dalam saja 
+            }
+          }
+        }
+        
+        // Perulangan "for each"
+        // Perulangan "for" juga dapat melakukan iterasi terhadap larik (array) dari objek
+        // yang mana mengimplementasikan interface Ieterable.
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        // Struktur perulangan "for each" => for (<objek> : <iterable>)
+        // dibaca: setiap elemen dalam iterable
+        // catatan: tipe objek harus sama dengan tipe iterable
+
+        for (int bar : fooList) {
+            System.out.println(bar);
+            // Melakukan interasi sebanyak 9 kali dan menampilkan 1-9 tiap baris
+        }
+
+        // "switch case"
+        // "switch" dapat digunakan pada byte, short, char, dan tipe data bilangan bulat (int).
+        // "switch" juga dapat digunakan pada tipe "enum" (dijelaskan nanti), kelas String,
+        // dan beberapa kelas khusus yang mengandung tipe data primitif:
+        // Character, Byte, Short, dan Integer.
+        int bulan = 3;
+        String bulanString;
+        switch (bulan) {
+            case 1: bulanString = "Januari";
+                    break;
+            case 2: bulanString = "Februari";
+                    break;
+            case 3: bulanString = "Maret";
+                    break;
+            default: bulanString = "Bulan lainnya";
+                     break;
+        }
+        System.out.println("Hasil switch case: " + bulanString);
+        
+        // Mulai dari Java 7 keatas, "switch" memiliki format:
+        String jawabanSaya = "mungkin";
+        switch(jawabanSaya) {
+            case "ya":
+                System.out.println("Anda menjawab ya.");
+                break;
+            case "tidak":
+                System.out.println("Anda menjawab tidak.");
+                break;
+            case "mungkin":
+                System.out.println("Anda menjawab mungkin.");
+                break;
+            default:
+                System.out.println("Anda menjawab " + jawabanSaya);
+                break;
+        }
+
+        // Pengkondisian dengan cara singkat
+        // Karakter '?' dapat digunakan untuk penilaian atau logika secara cepat antara dua pernyataan.
+        // Dibaca "Jika (pernyataan) adalah benar, gunakan <nilai pertama>, sisanya gunakan <nilai kedua>
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println(bar); // Menampilkan A, karena pernyataannya benar
+
+
+        ////////////////////////////////////////
+        // Konversi Data dan Tipe Data (Typecasting)
+        ////////////////////////////////////////
+
+        // Konversi Data
+
+        // Konversi String ke Integer
+        Integer.parseInt("123");    // menghasilkan nilai versi Integer dari "123"
+
+        // Konversi Integer ke String
+        Integer.toString(123);      // menghasilkan nilai versi String dari 123
+
+        // Untuk konversi lainnya silakan coba kelas berikut:
+        // Double
+        // Long
+        // String
+
+        // Typecasting
+        // Objek dalam Java juga dapat dikonversi, banyak penjelasan dan aturan
+        // dengan beberapa konsep sederhana. Silakan cek di alamat berikut:
+        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+        ///////////////////////////////////////
+        // Kelas dan Fungsi
+        ///////////////////////////////////////
+
+        System.out.println("\n->Kelas & Fungsi");
+
+        // (penjelasan mengenai kelas "Sepeda" ada dibawah)
+
+        // Gunakan "new" untuk melakukan instansiasi pada kelas
+        Sepeda laju = new Sepeda();
+
+        // Memanggil method objek
+        laju.tambahKecepatan(3); // Dapat juga digunakan "setter" dan "getter" method
+        laju.setIrama(100);
+
+        // Method "toString()" menghasilkan representasi string dari objek.
+        System.out.println("informasi jalur: " + laju.toString());
+
+        // Dua Pasang Inisialisasi
+        // Bahasa Java tidak memiliki sintaks untuk membuat koleksi dari "static" sekaligus
+        // dengan mudah, kecuali dengan cara berikut:
+
+        private static final Set<String> NEGARA = new HashSet<String>();
+        static {
+           validCodes.add("INDONESIA");
+           validCodes.add("MALAYSIA");
+           validCodes.add("SINGAPURA");
+        }
+
+        // Terdapat cara yang baik untuk menulis skrip dengan mudah,
+        // dengan menggunakan Dua-Kurung Kurawal Inisialisasi (Double Brace Initialization)
+
+        private static final Set<String> NEGARA = new HashSet<String>() {{
+            add("INDONESIA");
+            add("MALAYSIA");
+            add("SINGAPURA");
+        }}
+
+        // Kurung kurawal yang pertama membuat sebuah AnonymousInnerClas
+        // dan kurung kurawal yang kedua mendeklarasikan instance dari blok
+        // inisialisasi. Blok ini kemudian dipanggil ketika InnerClass dibentuk.
+        // Cara ini tidak hanya berfungsi pada koleksi data, juga dapat digunakan
+        // pada semua kelas bukan-"final".
+
+    } // Akhir dari method utama
+} // Akhir dari kelas BelajarJava
+
+
+// Kelas bukan-"public" lainnya dapat dimasukkan kedalam satu dokumen .java,
+// namun tidak dianjurkan, sebaiknya memisahkan menjadi beberapa dokumen terpisah.
+
+// Sintaks pendeklarasian kelas:
+//<public/private/protected> class <nama kelas> {
+//    // isi data, konstruktor, dan fungsi.
+//    // dalam Java, fungsi biasa disebut juga "method"
+// }
+
+class Sepeda {
+
+    // Variabel dari kelas Sepeda
+    public int irama;       // Public: dapat diakses dari manapun
+    private int kecepatan;  // Private: hanya dapat diakses dari dalam kelas
+    protected int rodaGigi;     // Protected: dapat diakses dari dalam kelas dan turunan kelas
+    String nama;            // Default: hanya dapat diakses kelas yang berada dalam paket yang sama
+
+    static String namaKelas;    // Variabel "static"
+
+    // Blok Static
+    // Java tidak memiliki implementasi untuk konstruktor "static", namun
+    // memiliki blok status yang dapat digunakan untuk inisialisasi variabel
+    // dalam kelas (variabel "static").
+    // Blok ini akan dipanggil secara otomatis ketika kelas dijalankan.
+    static {
+        namaKelas = "Sepeda";
+    }
+
+    // Konstruktor adalah salah satu cara untuk membuat kelas
+    // Ini adalah bagian konstruktor
+    public Sepeda() {
+        // Dapat juga dipanggil konstruktor lainnya:
+        // this(1, 50, 5, "Bontrager");
+        rodaGigi = 1;
+        irama = 50;
+        kecepatan = 5;
+        nama = "Bontrager";
+    }
+
+    // Ini adalah bagian konstruktor yang menggunakan argumen (parameter)
+    public Sepeda(int iramaAwal, int kecepatanAwal, int rodaGigiAwal,
+        String nama) {
+        this.rodaGigi = rodaGigiAwal;
+        this.irama = iramaAwal;
+        this.kecepatan = kecepatanAwal;
+        this.nama = nama;
+    }
+
+    // Sintaks untuk method:
+    // <public/private/protected> <tipe kembalian> <nama fungsi>(<args>)
+
+    // Kelas Java terkadang mengimplementasikan "getters" dan "setters" untuk data.
+
+    // Sintaks untuk deklarasi method:
+    // <public/private/protected> <tipe kembalian> <nama fungsi>(<args>)
+    public int getIrama() {
+        return irama;
+    }
+
+    // Tipe "void" tidak memiliki kembalian (return) nilai
+    public void setIrama(int nilaiBaru) {
+        irama = nilaiBaru;
+    }
+
+    public void setRodaGigi(int nilaiBaru) {
+        rodaGigi = nilaiBaru;
+    }
+
+    public void tambahKecepatan(int nilaiTambahan) {
+        kecepatan += nilaiTambahan;
+    }
+
+    public void kurangiKecepatan(int nilaiPengurangan) {
+        kecepatan -= nilaiPengurangan;
+    }
+
+    public void setNama(String namaBaru) {
+        nama = namaBaru;
+    }
+
+    public String getNama() {
+        return nama;
+    }
+
+    // Method untuk menampilkan nilai dari tiap atribut yang dimiliki objek Sepeda.
+    @Override // Diturunkan dari kelas "Object" (Pustaka Java).
+    public String toString() {
+        return "roda gigi: " + rodaGigi + " irama: " + irama + " kecepatan: " + kecepatan +
+            " nama: " + nama;
+    }
+} // akhir dari kelas Sepeda
+
+// PennyFarthing adalah kelas turunan dari Sepeda
+class PennyFarthing extends Sepeda {
+    // (Penny Farthings adalah sepeda dengan roda depan yang besar,
+    // dan tidak memiliki roda gigi.)
+    // (Penny Farthings are those bicycles with the big front wheel.
+    // They have no gears.)
+
+    public PennyFarthing(int startCadence, int startSpeed) {
+        // Call the parent constructor with super
+        super(startCadence, startSpeed, 0, "PennyFarthing");
+    }
+
+    // You should mark a method you're overriding with an @annotation.
+    // To learn more about what annotations are and their purpose check this
+    // out: http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setRodaGigi(int rodaGigi) {
+        roda rodaGigi = 0;
+    }
+}
+
+// Interfaces
+// Sintaks untuk deklarasi Interface
+// <level akses> interface <nama interface> extends <interface induk> {
+//     // Konstan
+//     // Deklarasi method
+// }
+
+// Contoh - Makanan:
+public interface dapatDimakan {
+    public void makan();    // Setiap kelas yang menggunakan interface "dapatDimakan",
+                            // harus mengimplementasikan method "makan".
+}
+
+public interface dapatDicerna {
+    public void cerna();
+}
+
+
+// Membuat kelas dengan mengimplementasikan dua interface dalam satu waktu.
+public class Buah implements dapatDimakan, dapatDicerna {
+  
+    @Override
+    public void makan() {
+        // ...
+    }
+
+    @Override
+    public void cerna() {
+        // ...
+    }
+}
+
+// Dalam Java, kelas hanya dapat diturunkan sekali, tapi dapat mengimplementasikan
+// banyak interface. Contoh:
+public class ContohKelas extends ContohKelasInduk implements InterfaceSatu,
+    InterfaceDua {
+
+    @Override
+    public void MethodInterfaceSatu() {
+    }
+
+    @Override
+    public void MethodInterfaceDua() {
+    }
+
+}
+
+// Kelas Abstrak (Abstract)
+// Sintaks untuk deklarasi kelas abstrak
+// Abstract Class declaration syntax
+// <level akses> abstract <nama kelas abstrak> extends <induk kelas abstrak> {
+//     // Konstan dan variabel
+//     // Deklarasi method
+
+// Menjadikan kelas sebagai abstrak adalah memungkinkan kelas berisi method abstrak
+// yang harus didefinisikan pada kelas turunannya. Mirip dengan Interface, kelas abstrak
+// tidak dapat dilakukan instansiasi, namun harus diturunkan pada kelas lain dan method abstrak
+// harus didefinisikan. Perbedaannya dengan Interface ialah kelas abstrak dapat berisi method
+// kongkrit dan method abstrak. Pada Interface method tidak dapat memiliki isi, artinya hanya
+// method statis, dan variabel langsung ditentukan menjadi final, tidak seperti kelas abstrak.
+// Kelas abstrak juga dapat memiliki method "main".
+
+public abstract class Hewan
+{
+    public abstract void bersuara();
+
+    // Method biasa dapat memiliki isi
+    public void makan()
+    {
+        System.out.println("Saya adalah hewan dan Saya makan.");
+        // Catatan: Kita dapat mengakses variabel private yang ada disini.
+        umur = 30;
+    }
+
+    // Tidak perlu dilakukan inisialisasi, berbeda dengan Interface
+    // sebuah variabel adalah final dan harus dilakukan inisialisasi. 
+    protected int umur;
+
+    public void tampilkanUmur()
+    {
+        System.out.println(umur);  
+    }
+
+    // Kelas abstrak dapat memiliki fungsi utama (main).
+    public static void main(String[] args)
+    {
+        System.out.println("Saya adalah kelas abstrak!");
+    }
+}
+
+class Kucing extends Hewan
+{
+    // Catatan: kelas ini harus melakukan override method abstrak
+    // yang ada pada kelas abstrak (induk).
+    @Override
+    public void bersuara()
+    {
+        System.out.println("Moe");
+        // umur = 30;	==> ERROR!	umur merupakan variabel private pada abstrak Hewan
+    }
+
+    // CATATAN: Akan muncul error jika menggunakan 
+    // keterangan @Override pada method utama (main),
+    // Java tidak mengizinkan hal tersebut.
+    // Kejadian ini sering disebut sebagai METHOD HIDING.
+    // Pertanyaan-jawaban yang menarik dapat dilihat: http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Kucing moe = new Kucing();
+        noe.bersuara();
+        moe.makan();
+        moe.tampilkanUmur();
+    }
+}
+
+// Kelas Final
+
+// Sintaks untuk deklarasi kelas Final
+// <level akses> final <nama kelas final> {
+//     // Konstann dan variabel
+//     // Deklarasi method
+// }
+
+// Kelas Final merupakan kelas yang tidak dapat diturunkan sehingga menjadikan
+// method tersebut turunan method terakhir. Disisi lain, kelas final merupakan
+// lawan dari kelas abstrak karena kelas abstrak dapat diturunkan lagi, sedangkan
+// kelas final tidak dapat diturunkan lagi.
+public final class Serigala extends Hewan
+{
+    // Catatan: method abstrak harus di-override pada kelas abstrak.
+    @Override
+    public void bersuara()
+    {
+        System.out.println("Auuww");
+    }
+}
+
+// Method Final
+public abstract class Mamalia()
+{
+    // Sintaks untuk method final:
+    // <level akses> final <tipe kembalian> <nama fungsi>(<args>)
+
+    // Method final, seperti kelas final tidak dapat di-override oleh kelas turunan,
+    // sehingga menjadikannya implementasi terakhir dari method.
+    public final boolean apakahBerdarahDingin()
+    {
+        return true;
+    }
+}
+
+
+// Tipe Enum
+//
+// Tipe Enum merupakan tipe data spesial yang memungkinkan sebuah nilai dijadikan
+// konstan awal (predefined). Variabel setidaknya harus memiliki nilai yang sama
+// dengan salah satu dari enum-enum yang telah ditentukan. Karena nilainya merupakan
+// konstan, untuk itu penamaannya menggunakan huruf kapital (uppercase). Dalam Java,
+// Enum didefinisikan dengan kata kunci "enum". Contohnya nama-nama hari dalam semunggu:
+
+public enum Hari {
+    SENIN, SELASA, RABU, KAMIS,
+    JUMAT, SABTU, MUNGGU 
+}
+
+// Cara menggunakan Enum:
+public class CobaEnum {
+    
+    // Variabel Enum
+    Hari hari;
+    
+    // Konstruktor
+    public CobaEnum(Hari hari) {
+        this.hari = hari;
+    }
+    
+    public void tampilkanKeterangan() {
+        switch (day) {
+            case SENIN:
+                System.out.println("Senin adalah hari yang menyebalkan.");
+                break;
+                    
+            case JUMAT:
+                System.out.println("Jumat adalah hari yang singkat.");
+                break;
+                         
+            case SABTU: 
+            case MINGGU:
+                System.out.println("Akhir pekan adalah hari yang menyenangkan.");
+                break;
+                        
+            default:
+                System.out.println("Hari kerja yang biasa saja.");
+                break;
+        }
+    }
+    
+    public static void main(String[] args) {
+        CobaEnum hariPertama = new CobaEnum(Hari.SENIN);
+        hariPertama.tampilkanKeterangan();      // Senin adalah hari yang menyebalkan.
+        CobaEnum hariKetiga = new CobaEnum(Hari.RABU);
+        hariPertama.tampilkanKeterangan();      // Hari kerja yang biasa saja.
+    }
+}
+
+// Tipe enum memiliki banyak kegunaan selain yang dicontohkan diatas.
+// Tipe enum dapat memiliki isi seperti method dan variabel.
+// Penjelasan lebih detail di https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
+```
+
+## Referensi Lainnya
+
+Link-link berikut hanya menyediakan pemahaman lebih lanjut mengenai topik diatas. 
+Tip, trik, dan contoh lainnya dapat melakukan pencarian melalui Google atau mesin pencari yang lain. 
+
+**Panduan resmi Oracle**
+
+* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+
+* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+**Tutorial dan Praktik Online**
+
+* [Learneroo.com - Learn Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+
+**Buku**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
diff --git a/id-id/json-id.html.markdown b/id-id/json-id.html.markdown
new file mode 100644
index 00000000..325e0ae2
--- /dev/null
+++ b/id-id/json-id.html.markdown
@@ -0,0 +1,77 @@
+---
+language: json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+filename: learnjson-id.json
+translators:
+  - ["Rizky Luthfianto", "https://github.com/rilut"]
+  - ["Ahmad Zafrullah", "https://github.com/23Pstars"]
+lang: id-id
+---
+
+JSON adalah format pertukaran data yang sangat sederhana. Sebagaimana dikutip dari [json.org](http://json.org), JSON mudah untuk dibaca atau ditulis oleh manusia, dan mudah diuraikan dan diproses oleh mesin.
+
+Sebuah format JSON setidaknya memiliki:
+* Sebuah pasangan nama atau nilai dinyatakan dengan karakter (`{ }`). Dibeberapa bahasa pemrograman, karakter ini sering digunakan sebagai object, record, struct, dictionary, hash table, keyed list, atau associative array.
+* Daftar nilai dinyatakan dengan karakter (`[ ]`). Dibeberapa bahasa pemrograman, karakter ini sering digunakan sebagai array, vector, list, atau sequence.
+
+Format JSON murni tidak memiliki komentar, namun beberapa pengurai (parser) dapat mengenali komentar seperti yang digunakan oleh bahasa C (`//`, `/**/`). Beberapa pengurai lainnya juga memiliki toleransi terhadap akhiran sisa koma (seperti koma yang terdapat pada akhir elemen dari larik atau properti terakhir dari objek), tapi koma tersebut memang seharusnya diabaikan untuk dukungan yang lebih baik.
+
+Dalam tutorial ini, semuanya menggunakan format JSON murni.
+
+Tipe data yang didukung oleh JSON:
+
+* Teks: `"halo"`, `"\"tanda petik.\""`, `"\u0abe"`, `"baris baru.\n"`
+* Angka: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
+* Objek: `{ "kunci": "nilai" }`
+* Larik: `["nilai"]`
+* Lainnya: `true`, `false`, `null`
+
+```json
+{
+  "kunci": "nilai",
+  
+  "kunci": "harus selalu diapit tanda kutip",
+  "angka": 0,
+  "strings": "Halø, dunia. Semua karaktor unicode diperbolehkan, terumasuk \"escaping\".",
+  "punya tipe data boolean?": true,
+  "nilai kosong": null,
+
+  "angka besar": 1.2e+100,
+
+  "obyek": {
+    "komentar": "Most of your structure will come from objects.",
+
+    "array": [0, 1, 2, 3, "Array bisa berisi apapun.", 5],
+
+    "obyek lainnya": {
+      "komentar": "Obyek-obyek JSON dapat dibuat bersarang, sangat berguna."
+    }
+  },
+
+  "iseng-iseng": [
+    {
+      "sumber potassium": ["pisang"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+  
+  "gaya alternatif": {
+    "komentar": "lihat ini!"
+  , "posisi tanda koma": "tak masalah. selama sebelum nilai berikutnya, valid-valid saja"
+  , "komentar lainnya": "betapa asyiknya"
+  },
+
+  "singkat": "Dan Anda selesai! Sekarang Anda tahu apa saja yang disediakan oleh JSON."
+}
+```
+
+## Referensi lebih labjut
+
+* [JSON.org](http://json.org/json-id.html) semua keindahan JSON dijelaskan dalam bentuk alur-grafis (bahasa indonesia).
diff --git a/id-id/markdown.html.markdown b/id-id/markdown.html.markdown
new file mode 100644
index 00000000..06ad1092
--- /dev/null
+++ b/id-id/markdown.html.markdown
@@ -0,0 +1,264 @@
+---
+language: markdown
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+    - ["Tasya Aditya Rukmana", "http://github.com/tadityar"]
+lang: id-id
+filename: markdown-id.md
+---
+
+Markdown dibuat oleh John Gruber pada tahun 2004. Tujuannya untuk menjadi syntax yang mudah dibaca dan ditulis yang dapat berubah menjadi HTML (dan sekarang berbagai format lainnya) dengan mudah.
+
+Beri masukan sebanyak-banyaknya! / Jangan sungkan untuk melakukan fork dan pull request!
+
+
+```markdown
+<!-- Markdown adalah superset dari HTML, jadi setiap berkas HTML adalah markdown yang
+valid, ini berarti kita dapat menggunakan elemen HTML dalam markdown, seperti elemen
+komentar, dan ia tidak akan terpengaruh parser markdown. Namun, jika Anda membuat
+elemen HTML di berkas markdown Anda, Anda tidak dapat menggunakan syntax markdown
+di dalam konten elemen tersebut. -->
+
+<!-- Markdown juga bervariasi dalam implementasinya dari berbagai parser. Panduan ini
+akan mencoba untuk mengklarifikasikan kapan suatu fitur universal atau spesifik
+terhadap parser tertentu -->
+
+<!-- Header -->
+<!-- Anda dapat membuat elemen HTML <h1> sampai <h6> dengan mudah dengan mendahului
+teks yang diinginkan untuk elemen tersebut oleh sejumlah tanda pagar (#) -->
+# Ini adalah <h1>
+## Ini adalah <h2>
+### Ini adalah <h3>
+#### Ini adalah <h4>
+##### Ini adalah <h5>
+###### Ini adalah <h6>
+
+<!-- Markdown juga menyediakan dua cara alternatif untuk menandai h1 and h2 -->
+Ini adalah h1
+=============
+
+Ini adalah h2
+-------------
+
+<!-- Ragam teks simpel -->
+<!-- Teks dapat diubah menjadi miring atau tebal dengan mudah menggunakan markdown -->
+
+*Ini adalah teks miring.*
+_Dan juga teks ini._
+
+**Ini adalah teks tebal.**
+__Dan juga teks ini.__
+
+***Ini adalah teks dengan keduanya.***
+**_Dan juga ini!_**
+*__Dan ini!__*
+
+<!-- Di markdown ala Github, yang digunakan untuk me-render berkas markdown pada
+Github, kita juga punya coretan: -->
+
+~~Teks ini dirender dengan coretan.~~
+
+<!-- Paragraf adalah satu atau beberapa baris teks yang dipisahkan oleh satu atau
+beberapa baris kosong. -->
+
+Ini adalah paragraf. Saya mengetik dalam paragraf, bukankah ini menyenangkan?
+
+Sekarang saya ada di paragraf 2.
+Saya juga masih ada dalam paragraf 2!
+
+
+Saya ada di paragraf 3!
+
+<!-- Jika Anda ingin memasukkan tag HTML <br />, Anda dapat mengakhiri sebuah
+paragraf dengan dua atau lebih spasi lalu memulai paragraf yang baru. -->
+
+Aku diakhiri dua spasi (soroti aku untuk melihatnya).
+
+Ada sebuah <br /> diatasku!
+
+<!-- Kutipan mudah dibuat dengan karakter >. -->
+
+> Ini adalah kutipan. Anda dapat
+> membungkusnya secara manual dan meletakkan `>` sebelum tiap baris atau Anda dapat membuat baris yang sangat panjang dan membuatnya membungkus secara otomatis.
+> Tidak ada masalah selama ia diawali dengan `>`.
+
+> Anda juga dapat menggunakan lebih dari satu level
+>> indentasi!
+> Sangat rapi bukan?
+
+<!-- Daftar -->
+<!-- Daftar tak beraturan dapat dibuat dengan bintang, plus, atau strip -->
+
+* Item
+* Item
+* Item lainnya
+
+atau
+
++ Item
++ Item
++ Satu lagi item
+
+or
+
+- Item
+- Item
+- Item terakhir
+
+<!-- List beraturan dibuat dengan angka diikuti titik -->
+
+1. Item satu
+2. Item dua
+3. Item tiga
+
+<!-- Anda tidak diharuskan melabeli item dengan benar dan markdown akan tetap
+me-render angka sesuai urutan, namun mungkin hal ini kurang baik -->
+
+1. Item satu
+1. Item dua
+1. Item tida
+<!-- (Ini dirender sama seperti contoh di atas) -->
+
+<!-- Anda juga dapat menggunakan sublist -->
+
+1. Item satu
+2. Item dua
+3. Item tiga
+    * Sub-item
+    * Sub-item
+4. Item empat
+
+<!-- Bahkan ada daftar tugas. Ini membuat kotak centang HTML. -->
+
+Kotak di bawah tanpa 'x' adalah kotak centang HTML yang belum diisi.
+- [ ] Tugas pertama selesai.
+- [ ] Tugas kedua yang harus diselesaikan
+Kotak centang HTML berikut telah diisi.
+- [x] Tugas ini telah diselesaikan
+
+<!-- Blok kode -->
+<!-- Anda dapat menandai blok kode (yang menggunakan elemen <code>) dengan mengindentasi
+sebuah garis dengan empat spasi atau tab -->
+
+    Ini adalah kode
+    Dan ini juga
+
+<!-- Anda juga dapat me-re-tab (atau menambahkan empat spasi tambahan) untuk indentasi
+di dalam kode Anda -->
+
+    array_ku.each do |item|
+        puts item
+    end
+
+<!-- Sebaris kode dapat dibuat dengan karakter backtick ` -->
+
+John bahkan tidak tahu apa fungsi dari `go_to()` !
+
+<!-- Di Markdown ala Github, Anda dapat menggunakan syntax spesial untuk kode -->
+
+\`\`\`ruby <!-- kecuali hapus backlash tersebut ketika melakukannya, hanya ```ruby ! -->
+def foobar
+    puts "Halo Dunia!"
+end
+\`\`\` <!-- Disini juga, tidak ada backslashes, hanya ``` -->
+
+<!-- Teks di atas tidak membutuhkan indentasi, plus Github akan menggunakan syntax
+highlighting dari bahasa yang digunakan setelah ``` -->
+
+<!-- Horizontal rule (<hr />) -->
+<!-- Horizontal rules ditambahkan dengan mudah oleh beberapa bintang atau strip,
+dengan atau tanpa spasi. -->
+
+***
+---
+- - -
+****************
+
+<!-- Tautan -->
+<!-- Salah satu hal terbaik dari markdown adalah mudahnya membuat tautan. Letakkan
+teks yang akan di tampilkan di dalam kurung siku [] diikuti oleh url-nya dalam kurung () -->
+
+[Klik aku!](http://test.com/)
+
+<!-- Anda juga dapat menambahkan judul link dengan tanda kutip di dalam kurung -->
+
+[Klik aku!](http://test.com/ "Link to Test.com")
+
+<!-- Path relatif juga bisa. -->
+
+[Pergi ke musik](/music/).
+
+<!-- Markdown juga mendukung tautan gara referal -->
+
+[Klik link ini][link1] untuk info lebih banyak!
+[Juga cek link ini][foobar] jika Anda mau.
+
+[link1]: http://test.com/ "Keren!"
+[foobar]: http://foobar.biz/ "OK!"
+
+<!-- Judulnya juga bisa dalam kutip satu atau kurung, atau dihilangkan sepenuhnya.
+Referensinya juga bisa di mana saja di dokumen anda dan IF referensinya bisa jadi
+apa saja selama ia unik. -->
+
+<!-- Ada juga "penamaan implisit" yang membuat Anda dapat menggunakan teks tautan sebagai id -->
+
+[Ini][] adalah tautan.
+
+[ini]: http://thisisalink.com/
+
+<!-- Tapi ia tidak lazim digunakan. -->
+
+<!-- Gambar -->
+<!-- Gambar digunakan sama seperti tautan namun dengan tanda seru di depannya! -->
+
+![Ini adalah atribut alt dari gambar saya](http://imgur.com/myimage.jpg "Judul opsional")
+
+<!-- Dan gaya referensi juga bekerja seperti yang diharapkan -->
+
+![Ini adalah atribut alt.][myimage]
+
+[myimage]: relative/urls/cool/image.jpg "jika Anda membutuhkan judul, disini"
+
+<!-- Lain-lain -->
+<!-- Tautan otomatis -->
+
+<http://testwebsite.com/> sama dengan
+[http://testwebsite.com/](http://testwebsite.com/)
+
+<!-- Tautan otomatis untuk email -->
+
+<foo@bar.com>
+
+<!-- Melewati karakter -->
+
+Saya ingin mengetik *teks ini dikelilingi tanda bintang* tapi saya tidak mau teksnya menjadi
+miring, jadi saya melakukan: \*teks ini dikelilingi tanda bintang\*.
+
+<!-- Tombol keyboard -->
+<!-- Pada Markdown ala Github, Anda dapat menggunakan tag <kbd> untuk merepresentasikan tombol
+keyboard -->
+
+Komputer Anda hang? Coba kirim sebuah
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+
+<!-- Tabel -->
+<!-- Tabel hanya tersedia pada Markdown ala Github dan sedikit merepotkan, namun jika Anda
+sangat menginginkannya: -->
+
+| Kol1         | Kol2     | Kol3          |
+| :----------- | :------: | ------------: |
+| Rata-kiri    | Tengah   | Rata-Kanan    |
+| blah         | blah     | blah          |
+
+<!-- atau, untuk hasil yang sama -->
+
+Kol 1 | Kol2 | Kol3
+:-- | :-: | --:
+Ugh ini sangat jelek | buat ia | berhenti
+
+<!-- Selesai! -->
+
+```
+
+Untuk info lebih lanjut, cek post syntax resmi John Gruber [di sini](http://daringfireball.net/projects/markdown/syntax) dan contekan hebat Adam Pritchard's [di sini](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/id-id/php-id.html.markdown b/id-id/php-id.html.markdown
new file mode 100644
index 00000000..34d6e5f5
--- /dev/null
+++ b/id-id/php-id.html.markdown
@@ -0,0 +1,848 @@
+---
+language: PHP
+contributors:
+    - ["Malcolm Fell", "http://emarref.net/"]
+    - ["Trismegiste", "https://github.com/Trismegiste"]
+filename: learnphp-id.php
+translators:
+  - ["Ahmad Zafrullah", "https://github.com/23Pstars"]
+lang: id-id
+---
+
+Dokumen ini menjelaskan tentang PHP5 keatas.
+
+```php
+<?php // Skrip PHP harus diawali dengan tag <?php
+
+// Jika dokumen PHP hanya mengandung kode PHP, sebaiknya tidak menggunakan
+// tag penutup PHP untuk menghindari ketidaksengajaan tampilnya sesuatu.
+
+// Dua garis miring diawal digunakan untuk komentar satu baris.
+
+/*
+     Membatasi teks dalam garis miring-bintang dan bintang-garis miring
+     membuat komentar untuk banyak-baris sekaligus.
+*/
+
+// Gunakan "echo" or "print" untuk menampilkan sesuatu
+print('Halo '); // Menampilkan "Halo " tanpa baris baru
+
+// () boleh tidak digunakan dalam menggunakan "print" dan "echo"
+echo "Dunia\n"; // Menampilkan "Dunia" dengan baris baru
+// (semua perintah harus diakhiri dengan titik koma)
+
+// Apapun yang berada diluar tag <?php akan ditampilkan secara otomatis
+?>
+Halo Dunia, lagi!
+<?php
+
+
+/************************************
+ * Tipe Data & Variabel
+ */
+
+// Variabel diawali dengan simnbol $.
+// Nama variabel yang benar diawali dengan huruf atau garis-bawah,
+// diikuti dengan beberapa huruf, angka, dan garis-bawah lainnya.
+
+// Nilai Boolean adalah case-insensitive
+$boolean = true;  // atau TRUE atau True
+$boolean = false; // atau FALSE atau False
+
+// Nilai Integer
+$int1 = 12;   // => 12
+$int2 = -12;  // => -12
+$int3 = 012;  // => 10 (awalan 0 menandakan bilangan Oktal)
+$int4 = 0x0F; // => 15 (awalan 0x menandakan bilangan Heksadesimal)
+// Bilangan Biner Integer tersedia mulai dari PHP 5.4.0.
+$int5 = 0b11111111; // 255 (awalan 0b menandakan bilangan Biner)
+
+// Nilai Floats (dikenal juga sebagai Doubles)
+$float = 1.234;
+$float = 1.2e3;
+$float = 7E-10;
+
+// Menghapus variable
+unset($int1);
+
+// Aritmatika
+$jumlah         = 1 + 1; // 2
+$selisih        = 2 - 1; // 1
+$perkalian      = 2 * 2; // 4
+$pembagian      = 2 / 1; // 2
+
+// Aritmatika singkat
+$angka = 0;
+$angka += 1;        // Menjumlahkan $angka dengan 1
+echo $angka++;      // Menampilkan 1 (dijumlahkan dengan 1 setelah ditampilkan)
+echo ++$angka;      // Menampilkan 3 (dijumlahkan dengan 1 sebelum ditampilkan)
+$angka /= $float;   // Membagi dan menyimpan hasil pembagian pada $angka;
+
+// String biasanya diawali dan ditutup dengan petik satu.
+$sgl_quotes = '$String'; // => '$String'
+
+// Hindari menggunakan petik dua kecuali menyertakan variabel lain
+$dbl_quotes = "Ini adalah $sgl_quotes."; // => 'Ini adalah $String.'
+
+// Karakter khusus hanya berlaku pada petik dua
+$berfungsi          = "Ini mengandung \t karakter tab.";
+$tidak_berfungsi    = 'Ini hanya mengandung garis miring dan huruf t: \t';
+
+// Batasi variabel dengan kurung kurawal jika diperlukan
+$uang = "Saya memiliki $${angka} di Bank.";
+
+// Sejak PHP 5.3, nowdocs dapat digunakan untuk tak-terinterpolasi banyak-baris
+$nowdoc = <<<'END'
+Banyak baris
+string
+END;
+
+// Heredocs akan melakukan interpolasi
+$heredoc = <<<END
+Banyak baris
+$sgl_quotes
+END;
+
+// Menyambung string dapat dilakukan menggunakan .
+echo 'String ini ' . 'tersambung';
+
+// String dapat dijadikan parameter pada "echo"
+echo 'Banyak', 'Parameter', 'String';  // Menampilkan 'BanyakParameterString'
+
+
+/********************************
+ * Konstan
+ */
+
+// Sebuah konstan didifinisikan menggunakan fungsi define()
+// dan tidak bisa diganti/rubah selama program berjalan!
+
+// Nama konstan yang benar diawali dengan huruf dan garis-bawah,
+// diikuti dengan beberapa huruf, angka, atau garis-bawah.
+define("FOO", "sesuatu");
+
+// Mengakses konstan memungkinkan untuk dapat dipanggil tanpa menggunakan simbol $
+echo FOO; // Menampilkan 'sesuatu'
+echo 'Keluaran ini adalah ' . FOO;  // Menampilkan 'Keluaran ini adalah sesuatu'
+
+
+
+/********************************
+ * Larik (Array)
+ */
+
+// Semua larik dalam PHP bersifat asosiatif (saling berhubungan).
+
+// Berfungsi pada semua versi PHP
+$asosiatif = array('Satu' => 1, 'Dua' => 2, 'Tiga' => 3);
+
+// Pada PHP 5.4 diperkenalkan cara penulisan (sintaks) baru
+$asosiatif = ['Satu' => 1, 'Dua' => 2, 'Tiga' => 3];
+
+echo $asosiatif['Satu']; // menampilkan 1
+
+// Daftar literal secara tidak langsung ditentukan oleh kunci integer
+$larik = ['Satu', 'Dua', 'Tiga'];
+echo $larik[0]; // => "Satu"
+
+// Menambahkan sebuah elemen pada akhir larik
+$larik[] = 'Empat';
+// atau
+array_push($larik, 'Lima');
+
+// Menghapus elemen dari larik
+unset($larik[3]);
+
+/********************************
+ * Keluaran
+ */
+
+echo('Halo Dunia!');
+// Menampilkan Halo Dunia! ke "stdout".
+// "stdout" adalah sebuah halaman web ketika dijalankan dalam peramban (browser).
+
+print('Halo Dunia!'); // Sama seperti "echo"
+
+// "echo" dan "print" merupakan bahasa konstruksi, jadi tanda kurung dapat dihilangkan
+echo 'Halo Dunia!';
+print 'Halo Dunia!';
+
+$paragraf = 'paragraf';
+
+echo 100;           // Menampilkan variabel skalar secara langsung
+echo $paragraf;     // atau sebuat variabel
+
+// Jika PHP tag-singkat telah dikonfigurasi, atau versi PHP yang digunakan
+// adalah 5.4.0 keatas, dapat digunakan sintaks "echo" singkat
+
+?>
+<p><?= $paragraf ?></p>
+<?php
+
+$x = 1;
+$y = 2;
+$x = $y; // $x sekarang berisi nilai yang sama dengan $y
+$z = &$y;
+// $z sekarang berisi referensi ke $y. Mengubah nilai dari $z
+// akan mengubah nilai dari $y juga, begitupun sebaliknya.
+// $x tetap tidak berubah sebagaimana nilai asli dari $y
+
+echo $x; // => 2
+echo $z; // => 2
+$y = 0;
+echo $x; // => 2
+echo $z; // => 0
+
+// Menampilkan tipe dan nilai dari variabel ke "stdout"
+var_dump($z); // prints int(0)
+
+// Menampilkan variabel ke "stdout" dalam format yang mudah dibaca
+print_r($larik); // menampilkan: Array ( [0] => Satu [1] => Dua [2] => Tiga )
+
+/********************************
+ * Logika
+ */
+$a = 0;
+$b = '0';
+$c = '1';
+$d = '1';
+
+// menegaskan lemparan sebuah peringatan jika pernyataan tidak benar
+
+// Perbandingan berikut akan selalu benar, meskipun memiliki tipe yang berbeda.
+assert($a == $b); // kesamaan
+assert($c != $a); // ketidak-samaan
+assert($c <> $a); // versi lain dari ketidak-samaan
+assert($a < $c);
+assert($c > $b);
+assert($a <= $b);
+assert($c >= $d);
+
+// Dibawah ini hanya akan bernilai benar jika nilainya memiliki tipe yang sama.
+assert($c === $d);
+assert($a !== $d);
+assert(1 === '1');
+assert(1 !== '1');
+
+// Operator 'Spaceship' (sejak PHP 7)
+// Mengembalikan 0 jika nilai pada kedua sisi adalah sama
+// Mengembalikan 1 jika nilai pada sisi kiri lebih besar
+// Mengembalikan -1 jika nilai pada sisi kanan lebih besar
+
+$a = 100;
+$b = 1000;
+
+echo $a <=> $a; // 0 karena keduanya sama
+echo $a <=> $b; // -1 karena $a < $b
+echo $b <=> $a; // 1 karena $b > $a
+
+// Variabel dapat dikonversi menjadi tipe lain, sesuai penggunaannya.
+
+$integer = 1;
+echo $integer + $integer; // => 2
+
+$string = '1';
+echo $string + $string; // => 2 (string dipaksa menjadi integer)
+
+$string = 'satu';
+echo $string + $string; // => 0
+// Menghasilkan 0 karena operator (+) tidak dapat memaksa string 'satu' menjadi sebuah integer
+
+// Perubahan tipe dapat dimanfaatkan untuk diperlakukan sebagai tipe lainnya
+
+$boolean = (boolean) 1; // => true
+
+$nol = 0;
+$boolean = (boolean) $nol; // => false
+
+// Terdapat juga fungsi khusus untuk melakukan perubahan terhadap beberapa tipe
+$integer = 5;
+$string = strval($integer);
+
+$var = null; // Nilai Null
+
+
+/********************************
+ * Struktur Kontrol
+ */
+
+if (true) {
+    print 'Saya tampil';
+}
+
+if (false) {
+    print 'Saya tidak tampil';
+} else {
+    print 'Saya tampil';
+}
+
+if (false) {
+    print 'Tidak tampil';
+} elseif(true) {
+    print 'Tampil';
+}
+
+// operator ternary
+print (false ? 'Tidak tampil' : 'Tampil');
+
+// cara pintas operator ternary mulai dirilis sejak PHP 5.3
+// persamaan dari "$x ? $x : 'Kerjakan'"
+$x = false;
+print($x ?: 'Kerjakan');
+
+// operator null coalesce sejak PHP 7
+$a = null;
+$b = 'Ditampilkan';
+echo $a ?? 'a belum di-set'; // menampilkan 'a belum di-set'
+echo $b ?? 'b belum di-set'; // menampilkan 'Ditampilkan'
+
+
+$x = 0;
+if ($x === '0') {
+    print 'Tidak ditampilkan';
+} elseif($x == '1') {
+    print 'Tidak ditampilkan';
+} else {
+    print 'Tampil';
+}
+
+
+// Alternatif sintaks untuk kebutuhan templat:
+?>
+
+<?php if ($x): ?>
+Ini ditampilkan jika pengujian benar.
+<?php else: ?>
+Selain tersebut ini yang akan ditampilkan.
+<?php endif; ?>
+
+<?php
+
+// Gunakan "switch" untuk menghemat logika.
+switch ($x) {
+    case '0':
+        print 'Switch mendukung tipe paksaan';
+        break; // Kata kunci "break" harus disertakan, jika tidak
+               // maka logika tersebut akan berlanjut ke bagian "dua" dan "tiga"
+    case 'dua':
+    case 'tiga':
+        // Lakukan sesuatu jika $x bernilai "dua" atau "tiga"
+        break;
+    default:
+        // Aksi cadangan
+}
+
+// "while", "do...while" dan perulangan "for"
+$i = 0;
+while ($i < 5) {
+    echo $i++;
+}; // Menampilkan "01234"
+
+echo "\n";
+
+$i = 0;
+do {
+    echo $i++;
+} while ($i < 5); // Menampilkan "01234"
+
+echo "\n";
+
+for ($x = 0; $x < 10; $x++) {
+    echo $x;
+} // Menampilkan "0123456789"
+
+echo "\n";
+
+$roda = ['sepeda' => 2, 'mobil' => 4];
+
+// Perulangan "foreach" dapat melakukan iterasi pada larik (array) 
+foreach ($roda as $jumlah_roda) {
+    echo $jumlah_roda;
+} // Menampilkan "24"
+
+echo "\n";
+
+// Iterasi dapat dilakukan terhadap "key" (kunci) dan "value" (nilai)
+foreach ($roda as $mesin => $jumlah_roda) {
+    echo "$mesin memiliki $jumlah_roda buah roda";
+}
+
+echo "\n";
+
+$i = 0;
+while ($i < 5) {
+    if ($i === 3) {
+        break; // Menghentikan proses perulangan
+    }
+    echo $i++;
+} // Menampilkan "012"
+
+for ($i = 0; $i < 5; $i++) {
+    if ($i === 3) {
+        continue; // Melewati tahapan iterasi saat ini
+    }
+    echo $i;
+} // Menampilkan "0124"
+
+
+/********************************
+ * Fungsi
+ */
+
+// Fungsi didefinisikan dengan "function":
+function fungsi_saya () {
+    return 'Halo';
+}
+
+echo fungsi_saya(); // => "Halo"
+
+// Nama fungsi yang baik dan benar diawali dengan sebuah huruf atau garis-bawah, diikuti oleh
+// beberapa huruf, angka, atau garis-bawah.
+
+function jumlah ($x, $y = 1) { // $y merupakan opsional, jika tidak ditentukan akan bernilai 1
+    $hasil = $x + $y;
+    return $hasil;
+}
+
+echo jumlah(4); // => 5
+echo jumlah(4, 2); // => 6
+
+// $hasil tidak dapat diakses dari luar fungsi
+// print $hasil; // Akan menghasilkan sebuah "warning".
+
+// Sejak PHP 5.3 fungsi dapat dideklarasikan menjadi tanpa-nama (anonymous);
+$inc = function ($x) {
+    return $x + 1;
+};
+
+echo $inc(2); // => 3
+
+function foo ($x, $y, $z) {
+    echo "$x - $y - $z";
+}
+
+// Fungsi dapat mengembalikan fungsi juga
+function bar ($x, $y) {
+    // Gunakan "use" untuk mengakses variabel diluar fungsi
+    return function ($z) use ($x, $y) {
+        foo($x, $y, $z);
+    };
+}
+
+$bar = bar('A', 'B');
+$bar('C'); // Menampilkan "A - B - C"
+
+// Fungsi uang memiliki nama dapat dipanggil berdasarkan string
+$nama_fungsi = 'jumlah';
+echo $nama_fungsi(1, 2); // => 3
+// Bermanfaat untuk menentukan fungsi mana yang akan dipanggil secara dinamis.
+// Atau, dapat juga menggunakan fungsi call_user_func(callable $callback [, $parameter [, ... ]]);
+
+// Akses semua parameter yang dikirim ke sebuah fungsi
+function parameter() {
+    $jumlah_param = func_num_args();
+    if( $jumlah_param > 0 ) {
+        echo func_get_arg(0) . ' | ';
+    }
+    $daftar_param = func_get_args();
+    foreach( $daftar_param as $kunci => $param ) {
+        echo $kunci . ' - ' . $param . ' | ';
+    }
+}
+
+parameter('Halo', 'Dunia'); // Halo | 0 - Halo | 1 - Dunia |
+
+// Sejak PHP 5.6, mendapatkan jumlah variabel yang ada pada parameter 
+function variabel($kata, ...$daftar) {
+	echo $kata . " || ";
+	foreach ($daftar as $item) {
+		echo $item . ' | ';
+	}
+}
+
+variable("Pemisah", "Halo", "Dunia") // Pemisah || Halo | Dunia | 
+
+/********************************
+ * Penyertaan ("include")
+ */
+
+<?php
+// Skrip PHP yang berada dalam dokumen "include" juga harus dibuka dengan tag PHP.
+
+include 'dokumen-saya.php';
+// Kode yang ada dalam dokumen-saya.php sekarang dapat diakses dari cakupan saat ini.
+// Jika dokumen tidak dapat disertakan (include, seperti dokumen tidak ditemukan), maka pesan peringatan akan muncul.
+
+include_once 'dokumen-saya.php';
+// Jika dokumen-saya telah disertakan (include) oleh perintah sebelumnya, maka
+// dokumen tersebut tidak akan disertakan lagi. Ini bertujuan untuk menghindari kesalahan 
+// yang diakibatkan oleh deklarasi ganda.
+
+require 'dokumen-saya.php';
+require_once 'dokumen-saya.php';
+// Memiliki fungsi yang sama dengan "include", namun jika dokumen tidak ditemukan 
+// atau tidak dapat disertakan maka akan menghasilkan pesan kesalahan fatal.
+
+// Isi dari dokumen-saya.php:
+<?php
+
+return 'Apapun yang kamu suka.';
+// akhir dari dokumen
+
+// "include" dan "require" dapat mengembalikan sebuah nilai.
+$nilai = include 'dokumen-saya.php';
+
+// Dokumen akan disertakan berdasarkan lokasi direktori dokumen (file path) yang diberikan, jika tidak didefinisikan
+// maka akan digunakan konfigurasi dari "include_path". Jika dokumen tidak ditemukan dalam "include_path",
+// fungsi include akan melakukan pengecekan pada direktori yang sama dengan dokumen yang menggunakan fungsi include tersebut,
+// jika tidak ditemukan juga maka pesan gagal akan dimunculkan.
+/* */
+
+/********************************
+ * Kelas (class)
+ */
+
+// Kelas didefinisikan dengan kata "class"
+
+class KelasSaya
+{
+    const NILAI_KONSTAN = 'nilai'; // Sebuah konstan
+
+    static $nilaiStatis = 'statis';
+
+    // Variabel statis dan hak jenis aksesnya
+    public static $variabelStatisPublik = 'nilaiStatisPublik';
+    // Hanya dapat diakses dalam kelas
+    private static $variabelStatisPrivat = 'nilaiStatisPrivat';
+    // Dapat diakses dalam kelas dan kelas turunan
+    protected static $variabelStatisTerlindungi = 'nilaiStatisTerlindungi';
+
+    // Properti harus mendeklarasikan hak aksesnya
+    public $properti    = 'publik';
+    public $PropertiInstansi;
+    protected $variabel = 'terlindungi'; // Dapat diakses dari kelas itu sendiri dan kelas turunannya
+    private $variabel   = 'tersembunyi';   // Hanya dapat diakses dari kelas itu sendiri
+
+    // Membuat konstruktor dengan perintah __construct
+    public function __construct($PropertiInstansi) {
+        // Akses variabel instansi menggunakan perintah $this
+        $this->PropertiInstansi = $PropertiInstansi;
+    }
+
+    // Method dideklarasikan sebagai fungsi didalam kelas
+    public function methodSaya()
+    {
+        print 'KelasSaya';
+    }
+
+    // Perintah "final" membuat sebuah fungsi tidak dapat di-override oleh kelas turunannya
+    final function tidakDapatDiOverride()
+    {
+    }
+
+/*
+ * Deklarasi properti atau method pada kelas sebagai statis membuat properti atau method tersebut
+ * dapat diakses tanpa melakukan instansiasi kelas. Properti statis tidak dapat diakses melalui
+ * objek kelas yang hasil instansiasi, sedangkan method statis bisa.
+ */
+
+    public static function methodStatisSaya()
+    {
+        print 'Saya adalah statis';
+    }
+}
+
+// Konstan pada kelas dapat diakses secara statis
+echo KelasSaya::NILAI_KONSTAN;      // Menampilkan 'nilai'
+
+echo KelasSaya::$nilaiStatis;       // Menampilkan 'statis'
+KelasSaya::methodStatisSaya();      // Menampilkan 'Saya adalah statis'
+
+// Instansi kelas menggunakan perintah "new"
+$kelas_saya = new KelasSaya('Sebuah properti instansiasi');
+// Tanda kurung adalah opsional jika tidak ingin menggunakan argumen.
+
+// Akses anggota kelas menggunakan ->
+echo $kelas_saya->properti;             // => "publik"
+echo $kelas_saya->propertiInstansi;     // => "Sebuah properti instansi"
+$kelas_saya->methodSaya();              // => "KelasSaya"
+
+// Menurunkan kelas menggunakan kata kunci "extends"
+class KelasSayaLainnya extends KelasSaya
+{
+    function tampilkanPropertiTerlindungi()
+    {
+        echo $this->properti;
+    }
+
+    // "override" terhadap sebuah method
+    function methodSaya()
+    {
+        parent::methodSaya();
+        print ' > KelasSayaLainnya';
+    }
+}
+
+$kelas_saya_lainnya = new KelasSayaLainnya('Instansiasi properti');
+$kelas_saya_lainnya->tampilkanPropertiTerlindung();     // => Menampilkan "terlindungi"
+$kelas_saya_lainnya->methodSaya();                      // Menampilkan "KelasSaya > KelasSayaLainnya"
+
+final class SayaTidakBisaDiturunkan
+{
+}
+
+// Gunakan method ajaib (magic method) untuk membuat fungsi "getters" dan "setters"
+class PetaKelasSaya
+{
+    private $properti;
+
+    public function __get($key)
+    {
+        return $this->$key;
+    }
+
+    public function __set($key, $value)
+    {
+        $this->$key = $value;
+    }
+}
+
+$x = new PetaKelasSaya();
+echo $x->properti;          // akan memanggil method __get()
+$x->properti = 'Sesuatu';   // akan memanggil method __set();
+
+// Kelas dapat dijadikan abstrak (menggunakan kata kunci "abstract"), atau
+// meng-implementasikan interfaces (menggunakan kata kunci "implements").
+// Sebuah interface dideklarasikan dengan perintah "interface".
+
+interface InterfaceSatu
+{
+    public function kerjakanSesuatu();
+}
+
+interface InterfaceDua
+{
+    public function kerjakanYangLain();
+}
+
+// interface dapat diturunkan
+interface InterfaceTiga extends InterfaceDua
+{
+    public function kerjakanYangBerbeda();
+}
+
+abstract class KelasAbstrakSaya implements InterfaceSatu
+{
+    public $x = 'kerjakanSesuatu';
+}
+
+class KelasKongkritSaya extends KelasAbstrakSaya implements InterfaceTwo
+{
+    public function kerjakanSesuatu()
+    {
+        echo $x;
+    }
+
+    public function kerjakanYangLain()
+    {
+        echo 'kerjakanYangLain';
+    }
+}
+
+// Kelas dapat diimplementasikan pada banyak interface
+class KelasLainnya implements InterfaceSatu, InterfaceDua
+{
+    public function kerjakanSesuatu()
+    {
+        echo 'kerjakanSesuatu';
+    }
+
+    public function kerjakanYangLain()
+    {
+        echo 'kerjakanYangLain';
+    }
+}
+
+
+/********************************
+ * Sifat (Traits)
+ */
+
+// Traits mulai tersedia sejak PHP 5.4.0 dan dideklarasikan menggunakan kata kunci "trait"
+
+trait TraitSaya
+{
+    public function methodTraitSaya()
+    {
+        print 'Saya menggunakan Trait';
+    }
+}
+
+class KelasTraitSaya
+{
+    use TraitSaya;
+}
+
+$kls = new KelasTraitSaya();
+$kls->methodTraitSaya();    // menampilkan "Saya menggunakan Trait"
+
+
+/********************************
+ * Namespaces
+ */
+
+// Bagian ini telah dibatasi, karena deklarasi "namespace"
+// karena harus ditempatkan diawal dokumen.
+
+<?php
+
+// Secara default, kelas tersedia sebagai namespace umum, dan dapat
+// secara khusus dipanggil dengan garis-miring terbalik (backslash).
+
+$kls = new \KelasSaya();
+
+
+// Menentukan namespace untuk sebuah dokumen
+namespace Saya\Namespace;
+
+class KelasSaya
+{
+}
+
+// (dari dokumen lainnya)
+$kls = new Saya\Namespace\KelasSaya;
+
+// Atau dari dalam namespace lainnya.
+namespace Saya\Lainnya\Namespace;
+
+use Saya\Namespace\KelasSaya;
+
+$kls = new KelasSaya();
+
+// Namespace dapat menggunakan alias
+
+namespace Saya\Lainnya\Namespace;
+
+use Saya\Namespace as SuatuKelasLainnya;
+
+$kls = new SuatuKelasLainnya\KelasSaya();
+
+
+/**********************
+* Late Static Binding
+*
+*/
+
+class KelasInduk {
+    public static function siapa() {
+        echo "Ini adalah " . __CLASS__ . "\n";
+    }
+    public static function coba() {
+        // kata kunci "self" merujuk pada method yang berada dalam satu kelas
+        self::who();
+        // kata kunci "static" merujuk pada method yang berada di kelas dimana method itu dijalankan
+        static::who();
+    }
+}
+
+KelasInduk::coba();
+/*
+Ini adalah KelasInduk
+Ini adalah KelasInduk
+*/
+
+class KelasAnak extends KelasInduk {
+    public static function siapa() {
+        echo "Tapi ini adalah " . __CLASS__ . "\n";
+    }
+}
+
+KelasAnak::tes();
+/*
+Ini adalah KelasInduk
+Tapi ini adalah KelasAnak
+*/
+
+/**********************
+*  Magic constants
+*  
+*/
+
+// Mendapatkan nama dari suatu kelas. Harus dideklarasikan didalam kelas tersebut.
+echo "Nama kelas ini adalah " . __CLASS__;
+
+// Mendapatkan alamat lengkap direktori
+echo "Alamat direktori ini adalah " . __DIR__;
+
+    // Beberapa yang banyak digunakan
+    require __DIR__ . '/vendor/autoload.php';
+
+// Mendapatkan alamat lengkap dokumen
+echo "Alamat dokumen ini adalah " . __FILE__;
+
+// Mendapatkan nama fungsi
+echo "Nama fungsi ini adalah " . __FUNCTION__;
+
+// Mendapatkan nomor baris perintah
+echo "Nomor baris perintah ini adalah " . __LINE__;
+
+// Mendapatkan nama method. Hanya mengembalikan sebuah nilai jika berada didalam trait atau deklarasi objek.
+echo "Nama method ini adalah " . __METHOD__;
+
+// Mendapatkan nama namespace 
+echo "Namespace saat ini adalah " . __NAMESPACE__;
+
+// Mendapatkan nama dari trait. Hanya mengembalikan sebuah nilai jika berada didalam trait atau deklarasi objek.
+echo "Namespace saat ini adalah " . __TRAIT__;
+
+/**********************
+*  Penanganan Kesalahan (Error)
+*  
+*/
+
+// Penanganan error sederhana menggunakan "try...catch"
+
+try {
+    // Kerjakan sesuatu
+} catch (Exception $e) {
+    // Penanganan exception
+}
+
+// Menggunakan "try...catch" blok pada namespace
+
+try {
+    // Kerjakan sesuatu
+} catch (\Exception $e) {
+    // Penanganan exception
+}
+
+// Exception khusus
+
+class ExceptionSaya extends Exception {}
+
+try {
+
+    $kondisi = true;
+
+    if ($kondisi) {
+        throw new ExceptionSaya('Terjadi sesuatu');
+    }
+
+} catch (ExceptionSaya $e) {
+    // Penanganan untuk exception khusus
+}
+
+```
+
+## Informasi lainnya
+
+Kunjungi [Dokumentasi resmi PHP](http://www.php.net/manual/) untuk referensi dan masukan komunitas.
+
+Jika anda tertarik untuk belajar lebih dalam, kunjungi 
+[PHP The Right Way](http://www.phptherightway.com/).
+
+Jika anda terbiasa dengan manajemen paket, kunjungi
+[Composer](http://getcomposer.org/).
+
+Untuk standar umum, kunjungi PHP Framework Interoperability Group's
+[PSR standards](https://github.com/php-fig/fig-standards).
diff --git a/id-id/pyqt-id.html.markdown b/id-id/pyqt-id.html.markdown
new file mode 100644
index 00000000..c4833d06
--- /dev/null
+++ b/id-id/pyqt-id.html.markdown
@@ -0,0 +1,83 @@
+---
+category: tool
+tool: PyQt
+language: Python
+filename: learnqt-id.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["Rizky Luthfianto", "http://github.com/rilut"]
+lang: id-id
+---
+
+**Qt** adalah framework terkenal untuk pengembangan perangkat lunak *cross-platform* yang dapat dijalankan pada berbagai platform perangkat lunak dan perangkat keras dengan sedikit atau tanpa perubahan dalam kode, dengan tetap memiliki kekuatan dan kecepatan aplikasi *native*. **Qt** ditulis dalam bahasa C++.
+
+
+Tulisan ini diadaptasi dari **Intro Qt untuk C++** oleh [Aleksey Kholovchuk](https://github.com/vortexxx192). Kode-kode yang tertulis di sini akan menghasilkan fungsionalitas yang sama. Bedanya, versi ini dibangun menggunakan **PyQt**!
+
+```Python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+# Buat objek aplikasi
+    app = QtGui.QApplication(sys.argv)
+# Buat sebuah widget, sebagai tempat di mana label kita akan ditempatkan
+    w = QtGui.QWidget()
+# Tambahkan label untuk widget
+    b = QtGui.QLabel(w)
+# Set teks untuk label
+    b.setText("Halo, Dunia!")
+# Set parameter penempatan dan ukuran
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+# Set judul pada jendela
+    w.setWindowTitle("PyQt")
+# Tampilkan segalanya
+    w.show()
+# Jalankan apa yang telah kita atur. Setelah semua selesai kita atur.
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+```
+
+Untuk menunjukkan beberapa fitur yang lebih canggih di **PyQt**, kita akan membangun elemen tambahan.
+Di sini, kita akan membuat Kotak Popup Dialog, yang berguna untuk meminta pengguna untuk mengkonfirmasi keputusan atau untuk menampilkan informasi.
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Buat tombol b dan tempelkan pada widget w
+    b = QPushButton(w)
+    b.setText("Tekan aku!")
+    b.move(50, 50)
+    # Perintahkan tombol b untuk memanggil fungsi ini ketika diklik
+    # Perhatikan bahwa kita tidak menggunakan simbol "()" pada pemanggilan fungsi kali ini
+    b.clicked.connect(ShowDialog)
+    w.setWindowTitle("Dialog PyQt")
+    w.show()
+    sys.exit(app.exec_())
+
+# Fungsi ini akan membuat jendela dialog dengan tombol
+# yang menunggu untuk diklik untuk keluar dari program
+def ShowDialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # Modalitas ini memberitahu popup untuk memblokir induk saat ini aktif
+    d.setWindowModality(Qt.ApplicationModal)
+    # Pada klik, kita ingin seluruh proses untuk berhenti
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
diff --git a/id-id/rst-id.html.markdown b/id-id/rst-id.html.markdown
new file mode 100644
index 00000000..06d80089
--- /dev/null
+++ b/id-id/rst-id.html.markdown
@@ -0,0 +1,122 @@
+---
+language: restructured text (RST)
+filename: rst-id.html
+contributors:
+    - ["DamienVGN", "https://github.com/martin-damien"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+translators:
+    - ["Haydar Ali Ismail", "https://github.com/haydarai"]
+lang: id-id
+---
+
+RST adalah sebual format file yang dibuat oleh komunitas Python untuk menulis
+dokumentasi (dan menjadi bagian dari Docutils).
+
+File-file RST adalah sebuah file-file teks simpel dengan sintaks yang ringan
+(dibandingkan dengan HTML).
+
+
+## Pemasangan
+
+Untuk menggunakan RST, anda harus memasang [Python](http://www.python.org) dan
+paket `docutils` terlebih dahulu.
+
+`docutils` bisa dipasang menggunakan command berikut:
+
+```bash
+$ easy_install docutils
+```
+
+Jika sistem anda sudah mempunyai `pip`, anda bisa menggunakannya juga:
+
+```bash
+$ pip install docutils
+```
+
+
+## Sintaks file
+
+Sebuah contoh sederhana dari sintaks file:
+
+```
+.. Baris yang dimulai dengan dua titik adalah perintah spesial. Tetapi jika
+perintah tidak ditemukan, maka baris tersebut akan dianggap sebagai komentar
+
+===============================================================================
+Judul utama ditulis menggunakan rentetan tanda sama dengan di atas dan bawahnya
+===============================================================================
+
+Ingat bahwa jumlah tanda sama dengan harus sama panjangnya dengan total
+karakter judul
+
+Judul juga digarisbawahi dengan tanda sama dengan juga
+======================================================
+
+Sub-judul dengan menggunakan dash
+---------------------------------
+
+Dan sub-sub-judul dengan menggunakan tilde
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Anda bisa menulis teks dalam *italik* atau *tebal*, anda bisa "menandai" teks
+sebagai kode dengan menggunakan backquote ganda ``: ``print()``.
+
+Membuat daftar semudah seperti dalam Markdown:
+
+- Barang pertama
+- Barang kedua
+    - Sub barang
+
+atau
+
+* Barang pertama
+* Barang kedua
+    * Sub barang
+
+Tabel sangat mudah untuk ditulis:
+
+=========== ========
+Negara      Ibu Kota
+=========== ========
+Prancis     Paris
+Jepang      Tokyo
+=========== ========
+
+Tabel yang lebih kompleks bisa dibuat dengan mudah (kolom tergabung atau/dan
+baris) tetapi saya menyarankan anda untuk membaca dokumentasi lengkap tentang
+ini :)
+
+Ada berbagai macam cara untuk membuat tautan:
+
+- Dengan menambahkan garis bawah setelah sebuah huruf : Github_ dan dengan
+menambahkan URL target setelah teks (cara ini mempunyai kelebihan dengan tidak
+memasukkan URL yang tidak penting ke dalam teks yang bisa dibaca).
+- Dengan mengetik URL lengkap yang dapat dipahami : https://github.com (akan
+otomatis diubah menjadi sebuah link)
+- Dengan membuat link seperti di Markdown: `Github <https://github.com/>`_ .
+
+.. _Github https://github.com/
+
+```
+
+
+## Bagaimana Cara Menggunakannya
+
+RST hadir dengan docutils di mana anda mempunyai `rst2html`, sebagai contoh:
+
+```bash
+$ rst2html fileku.rst hasil.html
+```
+
+*Catatan : Di beberapa sistem, perintah tersebut bisa menjadi rst2html.py*
+
+Tetapi ada beberapa aplikasi kompleks yang menggunakan format RST:
+
+- [Pelican](http://blog.getpelican.com/), Generator web statik
+- [Sphinx](http://sphinx-doc.org/), Generator dokumnetasi
+- dan masih banyak lainnya
+
+
+## Bacaan
+
+- [Referensi singkat resmi](http://docutils.sourceforge.net/docs/user/rst/quickref.html)
diff --git a/id-id/ruby-id.html.markdown b/id-id/ruby-id.html.markdown
new file mode 100644
index 00000000..28135da1
--- /dev/null
+++ b/id-id/ruby-id.html.markdown
@@ -0,0 +1,622 @@
+---
+language: ruby
+filename: learnruby-id.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
+  - ["Jake Faris", "https://github.com/farisj"]
+translators:
+  - ["Ukaza Perdana", "https://github.com/ukazap"]
+lang: id-id
+---
+
+```ruby
+# Ini adalah sebuah komentar
+
+=begin
+Ini adalah komentar multibaris
+Tak seorang pun menggunakannya
+Kamu juga tidak perlu
+=end
+
+# Pertama-tama dan yang terpenting: Semuanya adalah objek.
+
+# Angka adalah objek
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Beberapa aritmetika dasar
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+5 % 3 #=> 2
+
+# Operator-operator bitwise
+3 & 5 #=> 1
+3 | 5 #=> 7
+3 ^ 5 #=> 6
+
+# Aritmetika tidak lain adalah pemanis sintaks (syntactic sugar)
+# untuk memanggil sebuah metode pada suatu objek
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Nilai-nilai khusus adalah objek
+nil # setara dengan "null" di bahasa-bahasa lain
+true # kebenaran
+false # ketidakbenaran
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Kesamaan
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Ketidaksamaan
+1 != 1 #=> false
+2 != 1 #=> true
+
+# selain false itu sendiri, nil adalah nilai lain yang "salah"
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Perbandingan lain
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Operator pembanding yang dikombinasikan ("spaceship operator")
+1 <=> 10 #=> -1
+10 <=> 1 #=> 1
+1 <=> 1 #=> 0
+
+# Operator-operator logika
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# Terdapat versi-versi operator logika yang berbeda dengan lebih sedikit awalan.
+# Mereka digunakan sebagai kendali alur untuk merangkai beberapa pernyataan
+# hingga salah satunya mengembalikan (return) nilai true atau false.
+
+# `lakukan_suatu_lainnya` hanya dipanggil jika `lakukan_sesuatu` berhasil.
+lakukan_sesuatu() and lakukan_suatu_lainnya()
+# `catat_error` hanya dipanggil jika `lakukan_sesuatu` gagal.
+lakukan_sesuatu() or catat_error()
+
+
+# String adalah objek
+
+'Aku adalah string'.class #=> String
+"Aku juga adalah string".class #=> String
+
+wadah = 'menggunakan string interpolation'
+"Aku bisa #{wadah} ketika memakai tanda kutip ganda"
+#=> "Aku bisa menggunakan string interpolation ketika memakai tanda kutip ganda"
+
+# Gunakan tanda kutip tunggal daripada tanda kutip ganda jika memungkinkan
+# String bertanda kutip ganda melakukan kalkulasi tambahan di dalam
+
+# Kombinasikan string, tapi tidak dengan angka
+'halo ' + 'dunia'  #=> "halo dunia"
+'halo ' + 3 #=> TypeError: can't convert Fixnum into String
+'halo ' + 3.to_s #=> "halo 3"
+
+# Kombinasikan string dengan operator
+'halo ' * 3 #=> "halo halo halo "
+
+# Membubuhkan ke string
+'halo' << ' dunia' #=> "halo dunia"
+
+# cetak ke output dan buat baris baru (newline) di akhir
+puts "Aku mencetak!"
+#=> Aku mencetak!
+#=> nil
+
+# cetak ke output tanpa baris baru
+print "Aku mencetak!"
+#=> Aku mencetak! => nil
+
+# Variabel
+x = 25 #=> 25
+x #=> 25
+
+# Catat bahwa pemberian nilai mengembalikan nilai yang diberikan
+# Artinya kamu bisa melakukan pemberian nilai secara jamak:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Berdasarkan adat, gunakan gaya snake_case untuk menulis nama variabel
+snake_case = true
+
+# Gunakan nama variabel yang deskriptif
+path_to_project_root = '/good/name/'
+path = '/bad/name/'
+
+# Simbol (adalah objek)
+# Simbol adalah konstanta yang dapat didaur ulang yang tidak dapat diubah
+# (immutable), secara internal diwakili oleh nilai integer. Seringkali 
+# digunakan sebagai pengganti string untuk menyampaikan nilai yang mengandung
+# makna spesifik secara efisien.
+
+:menunggu.class #=> Symbol
+
+status = :menunggu
+
+status == :menunggu #=> true
+
+status == 'menunggu' #=> false
+
+status == :diterima #=> false
+
+# Array
+
+# Ini adalah sebuah array
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Array bisa menampung item dengan beragam tipe
+
+[1, 'halo', false] #=> [1, "halo", false]
+
+# Array bisa di-indeks-kan
+# Dari depan
+array[0] #=> 1
+array.first #=> 1
+array[12] #=> nil
+
+# Sama dengan aritmetika, pengaksesan [var]
+# hanyalah pemanis sintaks
+# untuk memanggil metode [] pada suatu objek
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# Dari belakang
+array[-1] #=> 5
+array.last #=> 5
+
+# Dengan indeks awal dan panjang (jumlah item)
+array[2, 3] #=> [3, 4, 5]
+
+# Membalik sebuah Array
+a=[1,2,3]
+a.reverse! #=> [3,2,1]
+
+# Atau menggunakan jangkauan (range)
+array[1..3] #=> [2, 3, 4]
+
+# Tambahkan ke array seperti ini
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+# Atau seperti ini
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Periksa apakah suatu item ada dalam sebuah array
+array.include?(1) #=> true
+
+# Hash adalah kamus utama Ruby berupa pasangan kunci/nilai (key/value pair).
+# Hash ditandai dengan kurung kurawal:
+hash = { 'warna' => 'hijau', 'angka' => 5 }
+
+hash.keys #=> ['warna', 'angka']
+
+# Nilai dalam Hash bisa diperoleh menggunakan kunci:
+hash['warna'] #=> 'hijau'
+hash['angka'] #=> 5
+
+# Meminta hash untuk kunci yang tidak ada akan mengembalikan nil:
+hash['tidak ada di sini'] #=> nil
+
+# Sejak Ruby 1.9, ada sintaks khusus ketika menggunakan simbol sebagai kunci:
+
+hash_baru = { defcon: 3, action: true }
+
+hash_baru.keys #=> [:defcon, :action]
+
+# Periksa ada/atau tidaknya kunci dan nilai dalam hash
+hash_baru.key?(:defcon) #=> true
+hash_baru.value?(3) #=> true
+
+# Tip: Baik array maupun hash adalah Enumerable
+# Mereka berbagi banyak metode yang berguna diantaranya each, map, count, dll.
+
+# Struktur-struktur kendali
+
+if true
+  'pernyataan if'
+elsif false
+  'else if, opsional'
+else
+  'else, opsional juga'
+end
+
+for penghitung in 1..5
+  puts "iterasi #{penghitung}"
+end
+#=> iterasi 1
+#=> iterasi 2
+#=> iterasi 3
+#=> iterasi 4
+#=> iterasi 5
+
+# NAMUN, tidak ada orang yang menggunakan pengulangan for.
+# Sebagai ganti, gunakan metode "each" dan memberinya sebuah blok (block).
+# Blok adalah serangkaian kode yang bisa dimasukkan ke metode seperti "each".
+# Ia serupa dengan lambda, fungsi anonim atau closure di bahasa lainnya.
+#
+# Metode "each" dari range menjalankan blok untuk setiap elemen dari range.
+# Bloknya diberikan penghitung sebagai parameter.
+# Memanggil metode "each" dengan blok terlihat seperti ini:
+
+(1..5).each do |penghitung|
+  puts "iterasi #{penghitung}"
+end
+#=> iterasi 1
+#=> iterasi 2
+#=> iterasi 3
+#=> iterasi 4
+#=> iterasi 5
+
+# Kamu juga bisa mengurung blok dalam kurung kurawal:
+(1..5).each { |penghitung| puts "iterasi #{penghitung}" }
+
+# Isi dari struktur-struktur data juga bisa di-iterasi menggunakan each.
+array.each do |elemen|
+  puts "#{elemen} adalah bagian dari array"
+end
+hash.each do |kunci, nilai|
+  puts "#{kunci} adalah #{nilai}"
+end
+
+# Jika kamu masih membutuhkan indeks, bisa menggunakan "each_with_index"
+# dan definisikan variabel indeks
+array.each_with_index do |elemen, indeks|
+  puts "#{elemen} adalah nomor #{indeks} dalam array"
+end
+
+penghitung = 1
+while penghitung <= 5 do
+  puts "iterasi #{penghitung}"
+  penghitung += 1
+end
+#=> iterasi 1
+#=> iterasi 2
+#=> iterasi 3
+#=> iterasi 4
+#=> iterasi 5
+
+# Ada kumpulan fungsi pengulangan lainnya yang berguna di Ruby,
+# contohnya "map", "reduce", "inject", daftarnya sangat panjang. Map,
+# misalnya, mengambil array yang di-iterasi-nya, melakukan sesuatu pada
+# setiap elemen sesuai definisi pada blok, dan mengembalikan array baru.
+array = [1,2,3,4,5]
+berganda = array.map do |elemen|
+  elemen * 2
+end
+puts berganda
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
+nilai = 'B'
+
+case nilai
+when 'A'
+  puts 'Pertahankan, nak'
+when 'B'
+  puts 'Semoga lebih beruntung di lain waktu'
+when 'C'
+  puts 'Kamu bisa lebih baik'
+when 'D'
+  puts 'Susah payah'
+when 'F'
+  puts 'Kamu gagal!'
+else
+  puts 'Sistem penilaian lainnya, heh?'
+end
+#=> "Semoga lebih beruntung di lain waktu"
+
+# case juga bisa menggunakan range
+nilai = 82
+case nilai
+when 90..100
+  puts 'Hore!'
+when 80...90
+  puts 'Cukup bagus'
+else
+  puts 'Kamu gagal!'
+end
+#=> "Cukup bagus"
+
+# penanganan kesalahan (exception handling):
+begin
+  # kode di sini yang mungkin membangkitkan exception
+  raise NoMemoryError, 'Kamu kehabisan memori.'
+rescue NoMemoryError => variabel_exception
+  puts 'NoMemoryError dibangkitkan', variabel_exception
+rescue RuntimeError => variabel_exception_lainnya
+  puts 'RuntimeError dibangkitkan sekarang'
+else
+  puts 'Ini dijalankan bila tidak ada exceptions sama sekali'
+ensure
+  puts 'Kode ini akan berjalan bagaimanapun juga'
+end
+
+# Fungsi (atau metode)
+
+def gandakan(x)
+  x * 2
+end
+
+# Fungsi dan semua blok secara tersirat mengembalikan nilai pernyataan terakhir
+gandakan(2) #=> 4
+
+# Tanda kurung bersifat optional, boleh ditiadakan jika tidak ambigu
+gandakan 3 #=> 6
+
+gandakan gandakan 3 #=> 12
+
+def jumlah(x, y)
+  x + y
+end
+
+# Argumen-argumen dari metode dipisahkan dengan koma
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# Semua metode secara tersirat mempunyai parameter blok opsional
+# yang bisa dipanggil dengan kata kunci 'yield'
+
+def kurung
+  puts '{'
+  yield
+  puts '}'
+end
+
+kurung { puts 'halo dunia' }
+
+# {
+# halo dunia
+# }
+
+
+# Kamu bisa memasukkan blok ke sebuah fungsi
+# "&" adalah penanda blok yang masuk
+def tamu_tamu(&blok)
+  blok.call 'beberapa_argumen'
+end
+
+# Kamu bisa memasukkan daftar argumen yang akan dikonversi menjadi array
+# Itulah gunanya operator splat ("*")
+def tamu_tamu(*array)
+  array.each { |tamu| puts tamu }
+end
+
+# Bila metode mengembalikan array, bisa memberi nilai dengan destrukturisasi
+# (destructuring assignment):
+def makanan
+    ['tempe penyet', 'sayur asam', 'nasi goreng']
+end
+sarapan, makan_siang, makan_malam = makanan
+sarapan #=> 'tempe penyet'
+makan_malam #=> 'nasi goreng'
+
+# Menurut adat, nama metode yang mengembalikan boolean diakhiri tanda tanya
+5.even? # false
+5.odd? # true
+
+# Dan jika suatu metode berakhiran tanda seru, ia melakukan sesuatu yang merusak
+# seperti mengubah penerimanya. Banyak metode mempunyai versi ! untuk melakukan
+# perubahan dan versi non-! untuk sekedar mengembalikan perubahannya
+nama_perusahaan = "Putra Sejahtera"
+nama_perusahaan.upcase #=> "PUTRA SEJAHTERA"
+nama_perusahaan #=> "Putra Sejahtera"
+nama_perusahaan.upcase! # kali ini kita benar-benar mengubah nama_perusahaan!
+nama_perusahaan #=> "PUTRA SEJAHTERA"
+
+
+# Definisikan kelas menggunakan kata kunci class
+class Manusia
+
+  # Variabel kelas. Ini dibagi oleh semua instans (instance) dari kelas ini.
+  @@spesies = 'H. sapiens'
+
+  # Inisialisasi dasar
+  def initialize(nama, usia = 0)
+    # Berikan argumen ke variabel instans "nama" dalam instans ini
+    @nama = nama
+    # Jika tidak diberi usia, nilai default dalam daftar argumen digunakan.
+    @usia = usia
+  end
+
+  # Metode setter dasar
+  def nama=(nama)
+    @nama = nama
+  end
+
+  # Metode getter dasar
+  def nama
+    @nama
+  end
+
+  # Fungsi di atas bisa disingkat dengan metode attr_accessor sebagai berikut
+  attr_accessor :nama
+
+  # Metode getter/setter juga bisa dibuat secara terpisah seperti ini
+  attr_reader :nama
+  attr_writer :nama
+
+  # Metode kelas menggunakan self untuk membedakannya dari metode instans.
+  # Ia hanya bisa dipanggil pada kelas, bukan pada instans-nya.
+  def self.katakan(pesan)
+    puts pesan
+  end
+
+  def spesies
+    @@spesies
+  end
+end
+
+
+# Membuat instans kelas
+jim = Manusia.new('Jim Halpert')
+
+dwight = Manusia.new('Dwight K. Schrute')
+
+# Mari panggil beberapa metode
+jim.spesies #=> "H. sapiens"
+jim.nama #=> "Jim Halpert"
+jim.nama = "Jim Halpert II" #=> "Jim Halpert II"
+jim.nama #=> "Jim Halpert II"
+dwight.spesies #=> "H. sapiens"
+dwight.nama #=> "Dwight K. Schrute"
+
+# Panggil metode kelas
+Manusia.katakan('Hai') #=> "Hai"
+
+# Lingkup variabel didefinisikan berdasarkan bagaimana kita memberikannya nama
+# Variabel yang berawalan $ memiliki lingkup global
+$var = "Aku adalah variabel global"
+defined? $var #=> "global-variable"
+
+# Variabel yang berawalan @ memiliki lingkup instans
+@var = "Aku adalah variabel instans"
+defined? @var #=> "instance-variable"
+
+# Variabel yang berawalan @@ memiliki lingkup kelas
+@@var = "Aku adalah variabel kelas"
+defined? @@var #=> "class variable"
+
+# Variabel yang berawalan huruf kapital adalah konstanta
+Var = "Aku adalah konstanta"
+defined? Var #=> "constant"
+
+# Kelas juga adalah objek sehingga kelas bisa memiliki variabel instans.
+# Variabel kelas dibagi diantara kelas dan semua pewarisnya.
+
+# kelas dasar
+class Manusia
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(nilai)
+    @@foo = nilai
+  end
+end
+
+# kelas turunan
+class Buruh < Manusia
+end
+
+Manusia.foo # 0
+Buruh.foo # 0
+
+Manusia.foo = 2 # 2
+Buruh.foo # 2
+
+# Variabel instans milik kelas tidak dibagikan dengan pewaris kelas tersebut.
+
+class Manusia
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(nilai)
+    @bar = nilai
+  end
+end
+
+class Dokter < Manusia
+end
+
+Manusia.bar # 0
+Dokter.bar # nil
+
+module ContohModul
+  def foo
+    'foo'
+  end
+end
+
+# Include modul mengikat metode-metodenya pada instans-instans kelas
+# Extend modul mengikat metode-metodenya pada kelas
+
+class Orang
+  include ContohModul
+end
+
+class Buku
+  extend ContohModul
+end
+
+Orang.foo     # => NoMethodError: undefined method `foo' for Orang:Class
+Orang.new.foo # => 'foo'
+Buku.foo       # => 'foo'
+Buku.new.foo   # => NoMethodError: undefined method `foo'
+
+# Callbacks dijalankan ketika meng-include dan meng-extend sebuah modul
+
+module ContohUrusan
+  def self.included(base)
+    base.extend(MetodeKelas)
+    base.send(:include, MetodeInstans)
+  end
+
+  module MetodeKelas
+    def bar
+      'bar'
+    end
+  end
+
+  module MetodeInstans
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Sesuatu
+  include ContohUrusan
+end
+
+Sesuatu.bar     # => 'bar'
+Sesuatu.qux     # => NoMethodError: undefined method `qux'
+Sesuatu.new.bar # => NoMethodError: undefined method `bar'
+Sesuatu.new.qux # => 'qux'
+```
+
+## Sumber tambahan
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Varian dari referensi ini dengan tantangan dalam browser.
+- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Belajar Ruby melalui serangkaian tutorial interaktif.
+- [Dokumentasi resmi](http://www.ruby-doc.org/core-2.1.1/)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Edisi lama yang [gratis](http://ruby-doc.com/docs/ProgrammingRuby/) tersedia online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Panduan penulisan kode Ruby oleh komunitas.
+- [Try Ruby](http://tryruby.org) - Pelajari dasar bahasa pemrograman Ruby, secara interaktif di browser.
diff --git a/id-id/smallbasic-id.html.markdown b/id-id/smallbasic-id.html.markdown
new file mode 100644
index 00000000..d782c859
--- /dev/null
+++ b/id-id/smallbasic-id.html.markdown
@@ -0,0 +1,133 @@
+---
+language: SmallBASIC
+filename: learnsmallbasic-id.bas
+contributors:
+    - ["Chris Warren-Smith", "http://smallbasic.sourceforge.net"]
+translators:
+    - ["Rizky Luthfianto", "http://github.com/rilut"]
+lang: id-id
+---
+
+## Tentang
+
+SmallBASIC adalah *interpreter* bahasa BASIC yang mudah dan cepat dipelajari yang ideal untuk perhitungan sehari-hari, skrip dan prototipe. Fitur SmallBASIC termasuk trigonometri, matriks dan fungsi aljabar, yang dibangun di IDE, *library* string yang canggih, sistem, suara, dan perintah grafis bersama dengan sintaks pemrograman terstruktur.
+
+## Pengembangan
+
+SmallBASIC pada awalnya dikembangkan oleh Nicholas Christopoulos pada akhir tahun 1999 untuk Palm Pilot. pengembangan proyek telah dilanjutkan oleh Chris Warren-Smith sejak sekitar tahun 2005.
+
+Versi SmallBASIC telah dibuat untuk sejumlah perangkat genggam termasuk Franklin eBookman dan Nokia 770. Juga berbagai versi desktop yang telah dirilis berdasarkan berbagai GUI. Platform yang didukung saat ini adalah Linux dan Windows berbasis SDL2 dan Android berbasis NDK. Sebuah versi baris perintah pada desktop juga tersedia, meskipun tidak biasanya dirilis dalam bentuk biner.
+
+Sekitar tahun 2008, sebuah perusahaan merilis lingkungan pemrograman BASIC dengan nama yang mirip. SmallBASIC tidak berhubungan dengan itu.
+
+```
+REM ini adalah komentar
+'dan ini juga komentar
+
+REM mencetak kalimat
+print "halo"
+? "Tanda ? adalah singkatan dari PRINT"
+
+REM Struktur kontrol
+FOR index = 0 TO 10 STEP 2
+  ? "Ini adalah nomor baris"; indeks
+NEXT
+J=0
+REPEAT
+ J++
+UNTIL J=10
+WHILE J>0
+ J--
+WEND
+
+REM Pernyataan "Select case"
+Select Case "Cool"
+ Case "null", 1,2,3,4,5,6,7,8,"Cool","blah"
+ Case "Not cool"
+   PRINT "Epic fail"
+ Case Else
+   PRINT "Fail"
+End Select
+
+REM menangkap kesalahan dengan TRY / CATCH
+Try
+  fn = Freefile
+  Open filename For Input As #fn
+Catch err
+  Print "gagal membuka file"
+End Try
+
+REM Fungsi dan subrutin buatan pengguna
+func add2(x, y)
+  'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC
+  local k
+  k = "k akan lenyap ketika FUNC ini mengembalikan nilai"
+  add2 = x + y
+akhir
+Print add2(5,5)
+sub cetak_ini(ini)
+  print ini
+end
+cetak_ini "INI"
+
+REM Menampilkan garis dan piksel
+At 0,ymax/2+txth("Q")
+Color 1: ? "sin(x)":
+Color 8: ? "cos(x)":
+Color 12: ? "tan(x)"
+Line 0,ymax/2,xmax,ymax/2
+For i=0 to xmax
+  Pset i,ymax/2-sin(i*2*pi/ymax)*ymax/4 color 1
+  Pset i,ymax/2-cos(i*2*pi/ymax)*ymax/4 color 8
+  Pset i,ymax/2-tan(i*2*pi/ymax)*ymax/4 color 12
+Next
+showpage
+
+REM SmallBASIC cocok untuk bereksperimen dengan fraktal dan efek menarik lainnya
+Delay 3000
+Randomize
+ff = 440.03
+For j = 0 to 20
+  r = rnd * 1000 % 255
+  b = rnd * 1000 % 255
+  g = rnd * 1000 % 255
+  c = rgb(r,b,g)
+  ff += 9.444
+  for i=0 to 25000
+    f += ff
+    x = min(xmax, -x + cos(f*i))
+    y = min(ymax, -y + sin(f*i))
+    pset x, y color c
+    if (i%1000==0) then
+      showpage
+    fi
+  next
+Next j
+
+REM Untuk sejarawan komputer, SmallBASIC dapat menjalankan program
+REM dari buku dan majalah komputer lama, misalnya:
+10 LET A=9
+20 LET B=7
+30 PRINT A*B
+40 PRINT A/B
+
+REM SmallBASIC juga memiliki dukungan untuk beberapa konsep modern seperti JSON
+aa = array("{\"kucing\":{\"nama\":\"harry\"},\"peliharaan\":\"true\"}")
+If (ismap(aa) == false) Then
+  throw "bukan tipe data map"
+End If
+Print aa
+
+PAUSE
+
+```
+
+## Artikel
+
+* [Persiapan](http://smallbasic.sourceforge.net/?q=node/1573)
+* [Selamat Datang di SmallBASIC](http://smallbasic.sourceforge.net/?q=node/838)
+
+## GitHub
+
+* [Source code](https://github.com/smallbasic/SmallBASIC)
+* [Referensi snapshot](http://smallbasic.github.io/)
diff --git a/id-id/xml-id.html.markdown b/id-id/xml-id.html.markdown
new file mode 100644
index 00000000..fedba711
--- /dev/null
+++ b/id-id/xml-id.html.markdown
@@ -0,0 +1,201 @@
+---
+language: xml
+filename: learnxml-id.xml
+contributors:
+  - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+  - ["Rizky Luthfianto", "https://github.com/rilut"]
+  - ["Ahmad Zafrullah", "https://github.com/23Pstars"]
+lang: id-id
+---
+
+XML adalah bahasa markup yang dirancang untuk menyimpan dan mengirim data. XML mudah dibaca oleh manusia dan mesin.
+
+Tidak seperti HTML, XML tidak menentukan bagaimana menampilkan atau format data, hanya membawanya.
+
+Terdapat perbedaan antara **konten** dan **markup**. Singkatnya, konten dapat berupa apapun dan markup adalah sebagai penentu.
+ 
+## Definisi dan Pendahuluan
+ 
+Dokumen XML pada dasarnya disusun oleh *elemen* yang dapat memiliki *atribut* untuk menjelaskan elemen tersebut dan dapat memiliki beberapa konten tekstual atau beberapa elemen sebagai anak-nya. Setiap dokumen XML hendaknya memiliki satu elemen akar, yang menjadi induk dari semua elemen dalam dokumen XML.
+ 
+Pengurai XML dirancang menjadi sangat ketat, dan akan berhenti melakukan penguraian terhadap dokumen yang cacat. Oleh karena itu semua dokumen XML harus mengikuti [Aturan Sintaks XML](http://www.w3schools.com/xml/xml_syntax.asp).
+
+```xml
+<!-- Ini adalah komentar. Komentar harus memiliki dua tanda penghubung secara berurutan (-). -->
+<!-- Komentar dapat renggang
+  menjadi banyak baris -->
+
+<!-- Elemen -->
+<!-- Elemen merupakan komponen dasar dari XML. Ada dua tipe dari elemen, kosong: -->
+<elemen1 atribut="nilai" /> <!-- Elemen kosong tidak memiliki konten apapun -->
+<!-- dan tidak-kosong: -->
+<elemen2 atribut="nilai">Konten</elemen2>
+<!-- Nama elemen hanya dapat berupa huruf dan angka saja. -->
+
+<kosong /> <!-- Elemen yang terdiri dari tag elemen kosong… -->
+<!-- …tidak memiliki content apapun dan murni markup. -->
+
+<tidakkosong> <!-- Atau, elemen ini memiliki tag pembuka… -->
+  <!-- …suatu konten… -->
+</tidakkosong> <!-- dan sebuah tag penutup. -->
+
+<!-- Nama elemen merupakan *case sensitive*. -->
+<elemen />
+<!-- …tidak sama dengan elemen sebelumnya -->
+<eLEMEN />
+
+<!-- Atribut -->
+<!-- Sebuah atribut merupakan hubungan kunci-nilai yang terdapat pada elemen. -->
+<elemen atribut="nilai" lainnya="nilaiLainnya" banyakNilai="daftar nilai ber-spasi" />
+<!-- Sebuah atribut digunakan hanya sekali dalam sebuah elemen. Dan hanya memiliki satu nilai.
+  Salah satu solusi untuk mengatasi permasalahan tersebut adalah dengan menggunakan daftar nilai ber-spasi. -->
+
+<!-- Elemen bersarang -->
+<!-- Konten dari sebuah elemen dapat berupa elemen lainnya:: -->
+<ayah>
+  <anak>Teks</anak>
+  <oranglain />
+</ayah>
+<!-- Mengikuti standar tatanan pohon. Setiap elemen disebut *node*.
+  Induk yang berada satu tingkat diatasnya disebut *parent*, keturunan yang berada satu tingkat dibawahnya disebut *children*.
+  Elemen yang berada pada *parent* yang sama disebut Saudara (*siblings*). -->
+
+<!-- XML mempertahankan spasi. -->
+<anak>
+  Teks
+</anak>
+<!-- …tidak sama dengan -->
+<anak>Teks</anak>
+```
+ 
+
+## Dokumen XML
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- XML prolog, boleh tidak digunakan namun direkomendasikan untuk digunakan. -->
+<tokobuku>
+  <buku category="MEMASAK">
+    <judul lang="en">Everyday Italian</judul>
+    <pengarang>Giada De Laurentiis</pengarang>
+    <tahun>2005</tahun>
+    <harga>30.00</harga>
+  </buku>
+  <buku category="ANAK">
+    <judul lang="en">Harry Potter</judul>
+    <pengarang>J K. Rowling</pengarang>
+    <tahun>2005</tahun>
+    <harga>29.99</harga>
+  </buku>
+  <buku category="WEB">
+    <judul lang="en">Learning XML</judul>
+    <pengarang>Erik T. Ray</pengarang>
+    <tahun>2003</tahun>
+    <harga>39.95</harga>
+  </buku>
+</tokobuku>
+
+<!-- Di atas adalah contoh file XML biasa.
+   Dimulai dengan deklarasi, menginformasikan beberapa metadata (opsional).
+  
+   XML menggunakan struktur pohon. Di atas, simpul akar adalah 'tokobuku',
+   yang memiliki tiga node anak, para 'buku'. Node-node tersebut dapat memiliki
+   node-node anak, dan seterusnya ...
+  
+   Node dibuat menggunakan tag buka/tutup, dan node-node anak hanya
+   berada di antara tag buka dan tutup .-->
+
+
+<!-- XML membawa dua jenis data:
+   1 - Atribut -> Itu metadata tentang sebuah node.
+       Biasanya, parser XML menggunakan informasi ini untuk menyimpan data dengan
+       benar. Hal ini ditandai dengan muncul dengan format nama = "nilai" dalam pembukaan tag.
+   2 - Elemen -> Itu data yang murni.
+       Itulah yang parser akan mengambil dari file XML.
+       Elemen muncul antara tag membuka dan menutup.-->
+      
+  
+<!-- Di bawah ini, unsur dengan dua atribut-->
+<file type="gif" id="4293">komputer.gif</file>
+
+
+```
+
+## Dokumen yang well-formated & Validasi
+
+Sebuah dokumen XML disebut well-formated jika sintaksisnya benar.
+Namun, juga mungkin untuk mendefinisikan lebih banyak batasan dalam dokumen,
+menggunakan definisi dokumen, seperti DTD dan XML Schema.
+
+Sebuah dokumen XML yang mengikuti definisi dokumen disebut valid,
+jika sesuai dokumen itu.
+
+Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi.
+
+```xml
+
+<!-- Di bawah, Anda dapat melihat versi sederhana dari dokumen tokobuku,
+  dengan penambahan definisi DTD .-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catatan SYSTEM "tokobuku.dtd">
+<tokobuku>
+  <buku category="MEMASAK">
+    <judul >Everyday Italian</judul>
+    <harga>30.00</harga>
+  </buku>
+</tokobuku>
+
+<!-- This DTD could be something like:-->
+
+<!DOCTYPE catatan
+[
+<!ELEMENT tokobuku (buku+)>
+<!ELEMENT buku (judul,harga)>
+<!ATTLIST buku category CDATA "Sastra">
+<!ELEMENT judul (#PCDATA)>
+<!ELEMENT harga (#PCDATA)>
+]>
+
+
+<!-- DTD dimulai dengan deklarasi.
+  Berikut, node akar dinyatakan, membutuhkan 1 atau lebih anak node 'buku'.
+  Setiap 'buku' harus berisi tepat satu 'judul' dan 'harga' dan atribut
+  disebut 'kategori', dengan "Sastra" sebagai nilai default.
+  Node yang 'judul' dan 'harga' mengandung karakter data diurai .-->
+
+<!-- DTD dapat dideklarasikan di dalam file XML itu sendiri .-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE catatan
+[
+<!ELEMENT tokobuku (buku+)>
+<!ELEMENT buku (judul,harga)>
+<!ATTLIST buku category CDATA "Sastra">
+<!ELEMENT judul (#PCDATA)>
+<!ELEMENT harga (#PCDATA)>
+]>
+
+<tokobuku>
+  <buku category="MEMASAK">
+    <judul >Everyday Italian</judul>
+    <harga>30.00</harga>
+  </buku>
+</tokobuku>
+```
+## Kompatibilitas DTD dan Definisi Skema XML
+
+Dukungan untuk DTD dapat ditemukan dimana-mana karena sudah sangat lama. Namun sayangnya, fitur XML terkini seperti *namespaces* tidak didukung oleh DTD. XML Xchema Definitions (XSDs) bertujuan untuk mengganti DTD dalam mendefinisikan tatabahasa dokumen XML.
+
+## Sumber
+
+* [Validasi dokumen XML](http://www.xmlvalidation.com)
+
+## Bacaan lainnya
+
+* [XML Schema Definitions Tutorial](http://www.w3schools.com/schema/)
+* [DTD Tutorial](http://www.w3schools.com/xml/xml_dtd_intro.asp)
+* [XML Tutorial](http://www.w3schools.com/xml/default.asp)
+* [Using XPath queries to parse XML](http://www.w3schools.com/xml/xml_xpath.asp)