Merge remote-tracking branch 'upstream/master'

* upstream/master:
  Add section on eunit in erlang doc
  Add clarification on bind / match with = op in erlang. Fixes #1139
  Removed random "r"
  Add to contributors
  Misc. typos and formatting
  More explanation on virtual destructors
  Clarify character literals
  Fixing typo in julia-es.html.markdown
  [xml/id] Translated JSON to Indonesian (json-id)
  [xml/id] Translated XML to Indonesian (xml-id)
  Aligned the comment block
  [javascript]  Fix for issue 1248
  Fixed some grammatical issues/typos
  Typos fixed in julia-es.html.markdown
  [c++/pt-br] Fix translate on editing object as parameters
  Update c++.html.markdown
  Add lang: to header of Python3 cs-cz file.
  All class constants can be accessed statically
  Add `kbd` tag
  Fixed the description of attributes and elements.

13 files changed, 301 insertions, 59 deletions

diff --git a/c++.html.markdown b/c++.html.markdown
index 26dfe111..4acc1b9d 100644
--- a/c++.html.markdown
+++ b/c++.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
     - ["Matt Kline", "https://github.com/mrkline"]
     - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
 lang: en
 ---
 
@@ -53,11 +54,11 @@ int main(int argc, char** argv)
 
 // However, C++ varies in some of the following ways:
 
-// In C++, character literals are one byte.
-sizeof('c') == 1
+// In C++, character literals are chars
+sizeof('c') == sizeof(char) == 1
 
-// In C, character literals are the same size as ints.
-sizeof('c') == sizeof(10)
+// In C, character literals are ints
+sizeof('c') == sizeof(int)
 
 
 // C++ has strict prototyping
@@ -159,9 +160,9 @@ void foo()
 
 int main()
 {
-    // Includes all symbols from `namesapce Second` into the current scope. Note
-    // that simply `foo()` no longer works, since it is now ambiguous whether
-    // we're calling the `foo` in `namespace Second` or the top level.
+    // Includes all symbols from namespace Second into the current scope. Note
+    // that simply foo() no longer works, since it is now ambiguous whether
+    // we're calling the foo in namespace Second or the top level.
     using namespace Second;
 
     Second::foo(); // prints "This is Second::foo"
@@ -256,7 +257,7 @@ string tempObjectFun() { ... }
 string retVal = tempObjectFun();
 
 // What happens in the second line is actually:
-//   - a string object is returned from `tempObjectFun`
+//   - a string object is returned from tempObjectFun
 //   - a new string is constructed with the returned object as arugment to the
 //     constructor
 //   - the returned object is destroyed
@@ -268,15 +269,15 @@ string retVal = tempObjectFun();
 // code:
 foo(bar(tempObjectFun()))
 
-// assuming `foo` and `bar` exist, the object returned from `tempObjectFun` is
-// passed to `bar`, and it is destroyed before `foo` is called.
+// assuming foo and bar exist, the object returned from tempObjectFun is
+// passed to bar, and it is destroyed before foo is called.
 
 // Now back to references. The exception to the "at the end of the enclosing
 // expression" rule is if a temporary object is bound to a const reference, in
 // which case its life gets extended to the current scope:
 
 void constReferenceTempObjectFun() {
-  // `constRef` gets the temporary object, and it is valid until the end of this
+  // constRef gets the temporary object, and it is valid until the end of this
   // function.
   const string& constRef = tempObjectFun();
   ...
@@ -301,7 +302,7 @@ basic_string(basic_string&& other);
 // Idea being if we are constructing a new string from a temporary object (which
 // is going to be destroyed soon anyway), we can have a more efficient
 // constructor that "salvages" parts of that temporary string. You will see this
-// concept referred to as the move semantic.
+// concept referred to as "move semantics".
 
 //////////////////////////////////////////
 // Classes and object-oriented programming
@@ -349,7 +350,10 @@ public:
     // These are called when an object is deleted or falls out of scope.
     // This enables powerful paradigms such as RAII
     // (see below)
-    // Destructors must be virtual to allow classes to be derived from this one.
+    // The destructor should be virtual if a class is to be derived from;
+    // if it is not virtual, then the derived class' destructor will
+    // not be called if the object is destroyed through a base-class reference
+    // or pointer.
     virtual ~Dog();
 
 }; // A semicolon must follow the class definition.
@@ -492,9 +496,10 @@ int main () {
 /////////////////////
 
 // Templates in C++ are mostly used for generic programming, though they are
-// much more powerful than generics constructs in other languages. It also
-// supports explicit and partial specialization, functional-style type classes,
-// and also it's Turing-complete.
+// much more powerful than generic constructs in other languages. They also
+// support explicit and partial specialization and functional-style type
+// classes; in fact, they are a Turing-complete functional language embedded
+// in C++!
 
 // We start with the kind of generic programming you might be familiar with. To
 // define a class or function that takes a type parameter:
@@ -506,7 +511,7 @@ public:
 };
 
 // During compilation, the compiler actually generates copies of each template
-// with parameters substituted, and so the full definition of the class must be
+// with parameters substituted, so the full definition of the class must be
 // present at each invocation. This is why you will see template classes defined
 // entirely in header files.
 
@@ -520,13 +525,13 @@ intBox.insert(123);
 Box<Box<int> > boxOfBox;
 boxOfBox.insert(intBox);
 
-// Up until C++11, you must place a space between the two '>'s, otherwise '>>'
-// will be parsed as the right shift operator.
+// Until C++11, you had to place a space between the two '>'s, otherwise '>>'
+// would be parsed as the right shift operator.
 
 // You will sometimes see
 //   template<typename T>
-// instead. The 'class' keyword and 'typename' keyword are _mostly_
-// interchangeable in this case. For full explanation, see
+// instead. The 'class' keyword and 'typename' keywords are _mostly_
+// interchangeable in this case. For the full explanation, see
 //   http://en.wikipedia.org/wiki/Typename
 // (yes, that keyword has its own Wikipedia page).
 
@@ -582,12 +587,15 @@ try {
     // Do not allocate exceptions on the heap using _new_.
     throw std::runtime_error("A problem occurred");
 }
+
 // Catch exceptions by const reference if they are objects
 catch (const std::exception& ex)
 {
-  std::cout << ex.what();
+    std::cout << ex.what();
+}
+
 // Catches any exception not caught by previous _catch_ blocks
-} catch (...)
+catch (...)
 {
     std::cout << "Unknown exception caught";
     throw; // Re-throws the exception
@@ -597,8 +605,8 @@ catch (const std::exception& ex)
 // RAII
 ///////
 
-// RAII stands for Resource Allocation Is Initialization.
-// It is often considered the most powerful paradigm in C++,
+// RAII stands for "Resource Acquisition Is Initialization".
+// It is often considered the most powerful paradigm in C++
 // and is the simple concept that a constructor for an object
 // acquires that object's resources and the destructor releases them.
 
@@ -619,9 +627,9 @@ void doSomethingWithAFile(const char* filename)
 // Unfortunately, things are quickly complicated by error handling.
 // Suppose fopen can fail, and that doSomethingWithTheFile and
 // doSomethingElseWithIt return error codes if they fail.
-// (Exceptions are the preferred way of handling failure,
-//  but some programmers, especially those with a C background,
-//  disagree on the utility of exceptions).
+//  (Exceptions are the preferred way of handling failure,
+//   but some programmers, especially those with a C background,
+//   disagree on the utility of exceptions).
 // We now have to check each call for failure and close the file handle
 // if a problem occurred.
 bool doSomethingWithAFile(const char* filename)
@@ -735,21 +743,23 @@ class Foo {
   virtual void bar();
 };
 class FooSub : public Foo {
-  virtual void bar();  // overrides Foo::bar!
+  virtual void bar();  // Overrides Foo::bar!
 };
 
 
 // 0 == false == NULL (most of the time)!
 bool* pt = new bool;
-*pt = 0;  // Sets the value points by 'pt' to false.
+*pt = 0; // Sets the value points by 'pt' to false.
 pt = 0;  // Sets 'pt' to the null pointer. Both lines compile without warnings.
 
 // nullptr is supposed to fix some of that issue:
 int* pt2 = new int;
-*pt2 = nullptr;  // Doesn't compile
+*pt2 = nullptr; // Doesn't compile
 pt2 = nullptr;  // Sets pt2 to null.
 
-// But somehow 'bool' type is an exception (this is to make `if (ptr)` compile).
+// There is an exception made for bools.
+// This is to allow you to test for null pointers with if(!ptr),
+// but as a consequence you can assign nullptr to a bool directly!
 *pt = nullptr;  // This still compiles, even though '*pt' is a bool!
 
 
@@ -776,12 +786,12 @@ vector<Foo> v;
 for (int i = 0; i < 10; ++i)
   v.push_back(Foo());
 
-// Following line sets size of v to 0, but destructors don't get called,
+// Following line sets size of v to 0, but destructors don't get called
 // and resources aren't released!
 v.empty();
-v.push_back(Foo());  // New value is copied into the first Foo we inserted in the loop.
+v.push_back(Foo());  // New value is copied into the first Foo we inserted
 
-// Truly destroys all values in v. See section about temporary object for
+// Truly destroys all values in v. See section about temporary objects for
 // explanation of why this works.
 v.swap(vector<Foo>());
 
diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 1f380f36..11c8a654 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -8,6 +8,7 @@ contributors:
 translators:
     - ["Tomáš Bedřich", "http://tbedrich.cz"]
 filename: learnpython3.py
+lang: cs-cz
 ---
 
 Python byl vytvořen Guidem Van Rossum v raných 90. letech. Nyní je jedním z nejpopulárnějších jazyků.
diff --git a/css.html.markdown b/css.html.markdown
index 9e8664b3..7224d80a 100644
--- a/css.html.markdown
+++ b/css.html.markdown
@@ -7,19 +7,19 @@ contributors:
 filename: learncss.css
 ---
 
-In early days of web there was no visual elements, just pure text. But with the  
-further development of browser fully visual web pages also became common.   
+In the early days of the web there were no visual elements, just pure text. But with the  
+further development of browsers, fully visual web pages also became common.   
 CSS is the standard language that exists to keep the separation between   
 the content (HTML) and the look-and-feel of web pages.
 
 In short, what CSS does is to provide a syntax that enables you to target   
 different elements on an HTML page and assign different visual properties to them.
 
-Like any other language, CSS has many versions. Here we focus on CSS2.0   
-which is not the most recent but the most widely supported and compatible version.
+Like any other languages, CSS has many versions. Here we focus on CSS2.0,   
+which is not the most recent version, but is the most widely supported and compatible version.
 
-**NOTE:** Because the outcome of CSS is some visual effects, in order to 
-learn it, you need try all different things in a 
+**NOTE:** Because the outcome of CSS consists of visual effects, in order to 
+learn it, you need try everything in a 
 CSS playground like [dabblet](http://dabblet.com/).
 The main focus of this article is on the syntax and some general tips.
 
diff --git a/erlang.html.markdown b/erlang.html.markdown
index 8b67a76a..64330867 100644
--- a/erlang.html.markdown
+++ b/erlang.html.markdown
@@ -25,6 +25,7 @@ filename: learnerlang.erl
 %% 1. Variables and pattern matching.
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
+% In Erlang new variables are bound with an `=` statement.
 Num = 42.  % All variable names must start with an uppercase letter.
 
 % Erlang has single-assignment variables; if you try to assign a different
@@ -32,9 +33,11 @@ Num = 42.  % All variable names must start with an uppercase letter.
 Num = 43. % ** exception error: no match of right hand side value 43
 
 % In most languages, `=` denotes an assignment statement. In Erlang, however,
-% `=` denotes a pattern-matching operation. `Lhs = Rhs` really means this:
-% evaluate the right side (`Rhs`), and then match the result against the
-% pattern on the left side (`Lhs`).
+% `=` denotes a pattern-matching operation. When an empty variable is used on the
+% left hand side of the `=` operator to is bound (assigned), but when a bound
+% varaible is used on the left hand side the following behaviour is observed.
+% `Lhs = Rhs` really means this: evaluate the right side (`Rhs`), and then
+% match the result against the pattern on the left side (`Lhs`).
 Num = 7 * 6.
 
 % Floating-point number.
@@ -299,6 +302,39 @@ CalculateArea ! {circle, 2}. % 12.56000000000000049738
 % The shell is also a process; you can use `self` to get the current pid.
 self(). % <0.41.0>
 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 5. Testing with EUnit
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Unit tests can be written using EUnits's test generators and assert macros
+-module(fib).
+   -export([fib/1]).
+   -include_lib("eunit/include/eunit.hrl").
+
+   fib(0) -> 1;
+   fib(1) -> 1;
+   fib(N) when N > 1 -> fib(N-1) + fib(N-2).
+
+   fib_test_() ->
+       [?_assert(fib(0) =:= 1),
+	?_assert(fib(1) =:= 1),
+	?_assert(fib(2) =:= 2),
+	?_assert(fib(3) =:= 3),
+	?_assert(fib(4) =:= 5),
+	?_assert(fib(5) =:= 8),
+	?_assertException(error, function_clause, fib(-1)),
+	?_assert(fib(31) =:= 2178309)
+       ].
+
+% EUnit will automatically export to a test() fucntion to allo running the tests
+% in the erlang shell
+fib:test()
+
+% The popular erlang build tool Rebar is also compatible with EUnit
+% ```
+% rebar eunit
+% ```
+
 ```
 
 ## References
diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 95a16412..e4181609 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -45,7 +45,7 @@ Esto se basa en la versión `0.3.11`.
 # Los comentarios de una línea comienzan con una almohadilla (o signo de gato).
 
 #=
-  Los commentarios multilínea pueden escribirse
+  Los comentarios multilínea pueden escribirse
   usando '#=' antes de el texto  y '=#'
   después del texto. También se pueden anidar.
 =#
@@ -174,7 +174,7 @@ otraVariable_123! = 6    # => 6
     otra_variable
 
   * Los nombres de los tipos comienzan con una letra mayúscula y separación de
-    palabras se muestra con CamelCase en vez de guion bajo:
+    palabras se muestra con CamelCase en vez de guión bajo:
 
     OtroTipo
 
@@ -214,7 +214,7 @@ matrix = [1 2; 3 4]
      3  4
 =#
 
-# Añadir cosas a la final de un arreglo con push! y append!.
+# Añadir cosas al final de un arreglo con push! y append!.
 push!(a, 1)      # => [1]
 push!(a, 2)      # => [1,2]
 push!(a, 4)      # => [1,2,4]
@@ -237,7 +237,7 @@ a[end]    # => 6
 shift!(a)         # => 1 y a es ahora: [2,4,3,4,5,6]
 unshift!(a, 7)    # => [7,2,4,3,4,5,6]
 
-# Los nombres de funciónes que terminan en exclamaciones indican que modifican
+# Los nombres de funciones que terminan en exclamaciones indican que modifican
 # su o sus argumentos de entrada.
 arr = [5, 4, 6]    # => 3-element Array{Int64,1}: [5,4,6]
 sort(arr)          # => [4,5,6] y arr es todavía: [5,4,6]
@@ -710,7 +710,7 @@ end
 # Sólo define una función del mismo nombre que el tipo y llama al constructor
 # existente para obtener un valor del tipo correcto.
 
-# Este es un constructor externo porque es fuera de la definición del tipo.
+# Este es un constructor externo porque está fuera de la definición del tipo.
 Leon(rugido::String) = Leon("verde", rugido)
 
 type Pantera <: Gato    # Pantera también es un a subtipo de Gato
@@ -730,10 +730,10 @@ end
 ########################
 
 # En Julia, todas las funciones nombradas son funciones genéricas.
-# Esto significa que se construyen a partir de muchos métodosmás pequeños.
+# Esto significa que se construyen a partir de muchos métodos más pequeños.
 # Cada constructor de Leon es un método de la función genérica Leon.
 
-# Por ejemplo, vamos a hacer métodos para para Leon, Pantera, y Tigre de una
+# Por ejemplo, vamos a hacer métodos para Leon, Pantera, y Tigre de una
 # función genérica maullar:
 
 # acceso utilizando notación de puntos
diff --git a/id-id/json-id.html.markdown b/id-id/json-id.html.markdown
new file mode 100644
index 00000000..52e61449
--- /dev/null
+++ b/id-id/json-id.html.markdown
@@ -0,0 +1,60 @@
+---
+language: json
+filename: learnjson.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators
+  - ["Rizky Luthfianto", "https://github.com/rilut"]
+---
+
+JSON adalah format pertukaran data yang sangat simpel, kemungkinan besar,
+ini adalah "Learn X in Y Minutes" yang paling singkat.
+
+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.
+
+```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."
+}
+```
diff --git a/id-id/xml-id.html.markdown b/id-id/xml-id.html.markdown
new file mode 100644
index 00000000..8e8cdf4e
--- /dev/null
+++ b/id-id/xml-id.html.markdown
@@ -0,0 +1,129 @@
+---
+language: xml
+filename: learnxml.xml
+contributors:
+  - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+  - ["Rizky Luthfianto", "https://github.com/rilut"]
+---
+
+XML adalah bahasa markup yang dirancang untuk menyimpan dan mengirim data.
+
+Tidak seperti HTML, XML tidak menentukan bagaimana menampilkan atau format data, hanya membawanya.
+
+* Sintaks XML
+
+```xml
+<!-- Komentar di XML seperti ini -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<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>
+```
diff --git a/javascript.html.markdown b/javascript.html.markdown
index 588ea86d..ba2e8ce4 100644
--- a/javascript.html.markdown
+++ b/javascript.html.markdown
@@ -475,9 +475,6 @@ myNumber === myNumberObj; // = false
 if (0){
     // This code won't execute, because 0 is falsy.
 }
-if (Number(0)){
-    // This code *will* execute, because Number(0) is truthy.
-}
 
 // However, the wrapper objects and the regular builtins share a prototype, so
 // you can actually add functionality to a string, for instance.
diff --git a/markdown.html.markdown b/markdown.html.markdown
index 7541f904..6d19710f 100644
--- a/markdown.html.markdown
+++ b/markdown.html.markdown
@@ -232,6 +232,12 @@ can be anything so long as they are unique. -->
 I want to type *this text surrounded by asterisks* but I don't want it to be
 in italics, so I do this: \*this text surrounded by asterisks\*.
 
+<!-- Keyboard keys -->
+<!-- In Github Flavored Markdown, you can use a <kbd> tag to represent keyboard keys -->
+
+Your computer crashed? Try sending a
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+
 <!-- Tables -->
 <!-- Tables are only available in Github Flavored Markdown and are slightly
 cumbersome, but if you really want it: -->
diff --git a/php.html.markdown b/php.html.markdown
index 2d4565e0..3fcce264 100644
--- a/php.html.markdown
+++ b/php.html.markdown
@@ -487,7 +487,7 @@ class MyClass
  * Declaring class properties or methods as static makes them accessible without
  * needing an instantiation of the class. A property declared as static can not
  * be accessed with an instantiated class object (though a static method can).
-*/
+ */
 
     public static function myStaticMethod()
     {
@@ -495,7 +495,9 @@ class MyClass
     }
 }
 
+// Class constants can always be accessed statically 
 echo MyClass::MY_CONST;    // Outputs 'value';
+
 echo MyClass::$staticVar;  // Outputs 'static';
 MyClass::myStaticMethod(); // Outputs 'I am static';
 
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index 61625ebe..61e267f5 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -304,7 +304,7 @@ void Dog::Dog()
 }
 
 // Objetos (como strings) devem ser passados por referência
-// se você está modificando-os ou referência const se você não é.
+// se você pretende modificá-los, ou com const caso contrário.
 void Dog::setName(const std::string& dogsName)
 {
     name = dogsName;
diff --git a/python.html.markdown b/python.html.markdown
index 352f7349..5572e38e 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -198,7 +198,7 @@ li[::-1]   # => [3, 4, 2, 1]
 
 # Remove arbitrary elements from a list with "del"
 del li[2]   # li is now [1, 2, 3]
-r
+
 # You can add lists
 li + other_li   # => [1, 2, 3, 4, 5, 6]
 # Note: values for li and for other_li are not modified.
diff --git a/xml.html.markdown b/xml.html.markdown
index fce1a3a4..059ea132 100644
--- a/xml.html.markdown
+++ b/xml.html.markdown
@@ -49,10 +49,11 @@ Unlike HTML, XML does not specify how to display or to format data, just carry i
 <!-- XML carries two kind of data:
   1 - Attributes -> That's metadata about a node.
       Usually, the XML parser uses this information to store the data properly.
-      It is characterized by appearing in parenthesis within the opening tag
+      It is characterized by appearing with the format name="value" within the opening
+      tag.
   2 - Elements -> That's pure data.
       That's what the parser will retrieve from the XML file.
-      Elements appear between the open and close tags, without parenthesis. -->
+      Elements appear between the open and close tags. -->
       
   
 <!-- Below, an element with two attributes -->