summaryrefslogtreecommitdiffhomepage
path: root/id-id
diff options
context:
space:
mode:
Diffstat (limited to 'id-id')
-rw-r--r--id-id/asciidoc-id.html.markdown125
-rw-r--r--id-id/coffeescript-id.html.markdown106
-rw-r--r--id-id/java-id.html.markdown801
-rw-r--r--id-id/json-id.html.markdown31
-rw-r--r--id-id/markdown.html.markdown264
-rw-r--r--id-id/pyqt-id.html.markdown83
-rw-r--r--id-id/ruby-id.html.markdown622
-rw-r--r--id-id/smallbasic-id.html.markdown133
8 files changed, 2158 insertions, 7 deletions
diff --git a/id-id/asciidoc-id.html.markdown b/id-id/asciidoc-id.html.markdown
new file mode 100644
index 00000000..8da8af38
--- /dev/null
+++ b/id-id/asciidoc-id.html.markdown
@@ -0,0 +1,125 @@
+---
+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>
+
+====== Level 5 <h6>
+
+======= Level 6 <h7>
+
+```
+
+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/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/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
index 52e61449..325e0ae2 100644
--- a/id-id/json-id.html.markdown
+++ b/id-id/json-id.html.markdown
@@ -1,19 +1,32 @@
---
language: json
-filename: learnjson.json
contributors:
- ["Anna Harren", "https://github.com/iirelu"]
- ["Marco Scannadinari", "https://github.com/marcoms"]
-translators
+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 simpel, kemungkinan besar,
-ini adalah "Learn X in Y Minutes" yang paling singkat.
+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.
-Murninya, JSON tidak mempunyai fitur komentar, tapi kebanyakan parser akan
-menerima komentar bergaya bahasa C (`//`, `/* */`). Namun, pada halaman ini,
-hanya dicontohkan JSON yang 100% valid.
+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
{
@@ -58,3 +71,7 @@ hanya dicontohkan JSON yang 100% valid.
"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/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/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/)