Merge remote-tracking branch 'adambard/master' into adambard/master-cn

22 files changed, 9209 insertions, 0 deletions

diff --git a/ru-ru/bash-ru.html.markdown b/ru-ru/bash-ru.html.markdown
new file mode 100644
index 00000000..21377b6c
--- /dev/null
+++ b/ru-ru/bash-ru.html.markdown
@@ -0,0 +1,284 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+    - ["akirahirose", "https://twitter.com/akirahirose"]
+    - ["Anton Strömkvist", "http://lutic.org/"]
+    - ["Rahil Momin", "https://github.com/iamrahil"]
+    - ["Gregrory Kielian", "https://github.com/gskielian"]
+    - ["Etan Reisner", "https://github.com/deryni"]
+translators:
+    - ["Andrey Samsonov", "https://github.com/kryzhovnik"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+filename: LearnBash-ru.sh
+lang: ru-ru
+---
+
+Bash - это командная оболочка unix (unix shell), которая распространялась как оболочка для операционной системы GNU и используется в качестве оболочки по умолчанию для Linux и Mac OS X.
+Почти все нижеприведенные примеры могут быть частью shell-скриптов или исполнены напрямую в shell.
+
+[Подробнее.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# Первая строка скрипта - это shebang, который сообщает системе, как исполнять
+# этот скрипт: http://en.wikipedia.org/wiki/Shebang_(Unix)
+# Как вы уже поняли, комментарии начинаются с #. Shebang - тоже комментарий.
+
+# Простой пример hello world:
+echo Hello world!
+
+# Отдельные команды начинаются с новой строки или разделяются точкой с запятой:
+echo 'Это первая строка'; echo 'Это вторая строка'
+
+# Вот так объявляется переменная:
+VARIABLE="Просто строка"
+
+# но не так:
+VARIABLE = "Просто строка"
+# Bash решит, что VARIABLE - это команда, которую он должен исполнить,
+# и выдаст ошибку, потому что не сможет найти ее.
+
+# и не так:
+VARIABLE= 'Просто строка'
+# Тут Bash решит, что 'Просто строка' - это команда, которую он должен исполнить,
+# и выдаст ошибку, потому что не сможет найти такой команды
+# (здесь 'VARIABLE=' выглядит как присвоение значения переменной,
+# но только в контексте исполнения команды 'Просто строка').
+
+# Использование переменой:
+echo $VARIABLE
+echo "$VARIABLE"
+echo '$VARIABLE'
+# Когда вы используете переменную - присваиваете, экспортируете и т.д. -
+# пишите её имя без $. А для получения значения переменной используйте $.
+# Заметьте, что ' (одинарные кавычки) не раскрывают переменные в них.
+
+# Подстановка строк в переменные
+echo ${VARIABLE/Просто/A}
+# Это выражение заменит первую встреченную подстроку "Просто" на "A"
+
+# Взять подстроку из переменной
+LENGTH=7
+echo ${VARIABLE:0:LENGTH}
+# Это выражение вернет только первые 7 символов переменной VARIABLE
+
+# Значение по умолчанию
+echo ${FOO:-"DefaultValueIfFOOIsMissingOrEmpty"}
+# Это сработает при отсутствующем значении (FOO=) и пустой строке (FOO="");
+# ноль (FOO=0) вернет 0.
+# Заметьте, что в любом случае значение самой переменной FOO не изменится.
+
+# Встроенные переменные:
+# В bash есть полезные встроенные переменные, например
+echo "Последнее возвращенное значение: $?"
+echo "PID скрипта: $$"
+echo "Количество аргументов: $#"
+echo "Аргументы скрипта: $@"
+echo "Аргументы скрипта, распределённые по отдельным переменным: $1 $2..."
+
+# Чтение аргументов из устройста ввода:
+echo "Как Вас зовут?"
+read NAME # Обратите внимание, что нам не нужно определять новую переменную
+echo Привет, $NAME!
+
+# У нас есть обычная структура if:
+# наберите 'man test' для получения подробной информации о форматах условия
+if [ $NAME -ne $USER ]
+then
+    echo "Имя не совпадает с именем пользователя"
+else
+    echo "Имя совпадает с именем пользователя"
+fi
+
+# Также есть условное исполнение
+echo "Исполнится всегда" || echo "Исполнится, если первая команда завершится ошибкой"
+echo "Исполнится всегда" && echo "Исполнится, если первая команда выполнится удачно"
+
+# Можно использовать && и || в выражениях if, когда нужно несколько пар скобок:
+if [ $NAME == "Steve" ] && [ $AGE -eq 15 ]
+then
+    echo "Исполнится, если $NAME равно Steve И $AGE равно 15."
+fi
+
+if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ]
+then
+    echo "Исполнится, если $NAME равно Daniya ИЛИ Zach."
+fi
+
+# Выражения обозначаются таким форматом:
+echo $(( 10 + 5 ))
+
+# В отличие от других языков программирования, Bash - это командная оболочка,
+# а значит, работает в контексте текущей директории.
+# Вы можете просматривать файлы и директории в текущей директории командой ls:
+ls
+
+# У этой команды есть опции:
+ls -l # Показать каждый файл и директорию на отдельной строке
+
+# Результат предыдущей команды может быть направлен на вход следующей.
+# Команда grep фильтрует ввод по шаблону.
+# Так мы можем просмотреть только *.txt файлы в текущей директории:
+ls -l | grep "\.txt"
+
+# Вы можете перенаправить ввод и вывод команды (stdin, stdout и stderr).
+# Следующая команда означает: читать из stdin, пока не встретится ^EOF$, и
+# перезаписать hello.py следующим строками (до строки "EOF"):
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+    print(line, file=sys.stdout)
+EOF
+
+# Запуск hello.py с разными вариантами перенаправления потоков
+# стандартных ввода, вывода и ошибок:
+python hello.py < "input.in"
+python hello.py > "output.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
+# Поток ошибок перезапишет файл, если этот файл существует,
+# поэтому, если вы хотите дописывать файл, используйте ">>":
+python hello.py >> "output.out" 2>> "error.err"
+
+# Переписать output.txt, дописать error.err и сосчитать строки:
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+# Запустить команду и вывести ее файловый дескриптор (смотрите: man fd)
+echo <(echo "#helloworld")
+
+# Перезаписать output.txt строкой "#helloworld":
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out >/dev/null
+
+# Подчистить временные файлы с подробным выводом ('-i' - интерактивый режим)
+rm -v output.out error.err output-and-error.log
+
+# Команды могут быть подставлены в строку с помощью $( ):
+# следующие команды выводят число файлов и директорий в текущей директории.
+echo "Здесь $(ls | wc -l) элементов."
+
+# То же самое можно сделать с использованием обратных кавычек,
+# но они не могут быть вложенными, поэтому предпочтительно использовать $( ).
+echo "Здесь `ls | wc -l` элементов."
+
+# В Bash есть структура case, которая похожа на switch в Java и C++:
+case "$VARIABLE" in 
+    # Перечислите шаблоны для условий, которые хотите отловить
+    0) echo "Тут ноль.";;
+    1) echo "Тут один.";;
+    *) echo "Это не пустое значение.";;
+esac
+
+# Цикл for перебирает элементы переданные в аргументе:
+# Содержимое $VARIABLE будет напечатано три раза.
+for VARIABLE in {1..3}
+do
+    echo "$VARIABLE"
+done
+
+# Или с использованием "традиционного" синтаксиса цикла for:
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# Цикл for можно использовать для действий с файлами.
+# Запустим команду 'cat' для файлов file1 и file2
+for VARIABLE in file1 file2
+do
+    cat "$VARIABLE"
+done
+
+# ... или выводом из команд
+# Запустим cat для вывода из ls.
+for OUTPUT in $(ls)
+do
+    cat "$OUTPUT"
+done
+
+# Цикл while:
+while [ true ]
+do
+    echo "тело цикла здесь..."
+    break
+done
+
+# Вы можете определять функции
+# Определение:
+function foo ()
+{
+    echo "Аргументы работают также, как аргументы скрипта: $@"
+    echo "и: $1 $2..."
+    echo "Это функция"
+    return 0
+}
+
+# или просто
+bar ()
+{
+    echo "Другой способ определить функцию!"
+    return 0
+}
+
+# Вызов функции
+foo "Мое имя" $NAME
+
+# Есть много полезных команд, которые нужно знать:
+# напечатать последние 10 строк файла file.txt
+tail -n 10 file.txt
+# напечатать первые 10 строк файла file.txt
+head -n 10 file.txt
+# отсортировать строки file.txt
+sort file.txt
+# отобрать или наоборот пропустить повторяющиеся строки (с опцией -d отбирает)
+uniq -d file.txt
+# напечатать только первую колонку перед символом ','
+cut -d ',' -f 1 file.txt
+# заменить каждое 'okay' на 'great' в файле file.txt (regex поддерживается)
+sed -i 's/okay/great/g' file.txt
+# вывести в stdout все строки из file.txt, совпадающие с шаблоном regex;
+# этот пример выводит строки, которые начинаются на "foo" и оканчиваются "bar"
+grep "^foo.*bar$" file.txt
+# передайте опцию -c чтобы вывести число строк, в которых совпал шаблон
+grep -c "^foo.*bar$" file.txt
+# чтобы искать по строке, а не шаблону regex, используйте fgrep (или grep -F)
+fgrep "^foo.*bar$" file.txt 
+
+# Читайте встроенную документацию оболочки Bash командой 'help':
+help
+help help
+help for
+help return
+help source
+help .
+
+# Читайте Bash man-документацию
+apropos bash
+man 1 bash
+man bash
+
+# Читайте документацию info (? для помощи)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# Читайте bash info документацию:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/ru-ru/brainfuck-ru.html.markdown b/ru-ru/brainfuck-ru.html.markdown
new file mode 100644
index 00000000..fcee185f
--- /dev/null
+++ b/ru-ru/brainfuck-ru.html.markdown
@@ -0,0 +1,85 @@
+---
+language: brainfuck
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Dmitry Bessonov", "https://github.com/TheDmitry"]
+lang: ru-ru
+---
+
+Brainfuck (пишется маленькими буквами, кроме начала предложения) - это очень
+маленький Тьюринг-полный язык программирования лишь с 8 командами.
+
+Вы можете испытать brainfuck в вашем браузере с помощью [brainfuck-визуализатора](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Любой символ, кроме "><+-.,[]", игнорируется, за исключением кавычек.
+
+Brainfuck представлен массивом из 30000 ячеек, инициализированных нулями,
+и указателем с позицией в текущей ячейке.
+
+Всего восемь команд:
++ : Увеличивает значение на единицу в текущей ячейке.
+- : Уменьшает значение на единицу в текущей ячейке.
+> : Смещает указатель данных на следующую ячейку (ячейку справа).
+< : Смещает указатель данных на предыдущую ячейку (ячейку слева).
+. : Печатает ASCII символ из текущей ячейки (напр. 65 = 'A').
+, : Записывает один входной символ в текущую ячейку.
+[ : Если значение в текущей ячейке равно нулю, то пропустить все команды
+    до соответствующей ] . В противном случае, перейти к следующей инструкции.
+] : Если значение в текущей ячейке равно нулю, то перейти к следующей инструкции.
+    В противном случае, вернуться назад к соответствующей [ .
+
+[ и ] образуют цикл while. Естественно, они должны быть сбалансированы.
+
+Давайте рассмотрим некоторые базовые brainfuck-программы.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Эта программа выводит букву 'A'. Сначала программа увеличивает значение
+ячейки №1 до 6. Ячейка №1 будет использоваться циклом. Затем программа входит
+в цикл ([) и переходит к ячейке №2. Ячейка №2 увеличивается до 10, переходим
+назад к ячейке №1 и уменьшаем ячейку №1. Этот цикл проходит 6 раз (ячейка №1
+уменьшается до нуля, и с этого места пропускает инструкции до соответствующей ]
+и идет дальше).
+
+В этот момент мы находимся в ячейке №1, которая имеет значение 0, значение
+ячейки №2 пока 60. Мы переходим на ячейку №2, увеличиваем 5 раз, до значения 65,
+и затем выводим значение ячейки №2. Код 65 является символом 'A' в кодировке ASCII,
+так что 'A' выводится на терминал.
+
+
+, [ > + < - ] > .
+
+Данная программа считывает символ из пользовательского ввода и копирует символ
+в ячейку №1. Затем мы начинаем цикл. Переходим к ячейке №2, увеличиваем значение
+ячейки №2, идем назад к ячейке №1 и уменьшаем значение ячейки №1. Это продолжается
+до тех пор, пока ячейка №1 не равна 0, а ячейка №2 сохраняет старое значение
+ячейки №1. Мы завершаем цикл на ячейке №1, поэтому переходим в ячейку №2 и
+затем выводим символ ASCII.
+
+Также имейте в виду, что пробелы здесь исключительно для читабельности. Вы можете
+легко написать и так:
+
+,[>+<-]>.
+
+Попытайтесь разгадать, что следующая программа делает:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Программа принимает два числа на вход и умножает их.
+
+Суть в том, что программа сначала читает два ввода. Затем начинается внешний цикл,
+сохраняя ячейку №1. Затем программа перемещается в ячейку №2, и начинается
+внутренний цикл с сохранением ячейки №2, увеличивая ячейку №3. Однако появляется
+проблема: В конце внутреннего цикла ячейка №2 равна нулю. В этом случае,
+внутренний цикл не будет работать уже в следующий раз. Чтобы решить эту проблему,
+мы также увеличим ячейку №4, а затем копируем ячейку №4 в ячейку №2.
+Итак, ячейка №3 - результат.
+```
+
+Это и есть brainfuck. Не так уж сложно, правда? Забавы ради, вы можете написать
+свою собственную brainfuck-программу или интерпретатор на другом языке.
+Интерпретатор достаточно легко реализовать, но если вы мазохист, попробуйте
+написать brainfuck-интерпретатор... на языке brainfuck.
diff --git a/ru-ru/c-ru.html.markdown b/ru-ru/c-ru.html.markdown
new file mode 100644
index 00000000..5988b159
--- /dev/null
+++ b/ru-ru/c-ru.html.markdown
@@ -0,0 +1,483 @@
+---
+language: c
+filename: learnc-ru.c
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+    - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"]
+translators:
+    - ["Evlogy Sutormin", "http://evlogii.com"]
+lang: ru-ru
+---
+
+Что ж, Си всё ещё является лидером среди современных высокопроизводительных языков.
+
+Для большинствоа программистов, Си – это самый низкоуровневый язык на котором они когда-либо писали,
+но этот язык даёт больше, чем просто повышение производительности.
+Держите это руководство в памяти и вы сможете использовать Си максимально эффективно.
+
+```c
+// Однострочный комментарий начинается с // - доступен только после С99.
+
+/*
+Многострочный комментарий выглядит так. Работает начиная с С89.
+*/
+
+// Импорт файлов происходит с помощью **#include**
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+// Файлы <в угловых скобочках> будут подключаться из стандартной библиотеки.
+// Свои файлы необходимо подключать с помощью "двойных кавычек".
+#include "my_header.h"
+
+// Объявление функций должно происходить в .h файлах или вверху .c файла.
+void function_1();
+void function_2();
+
+// Точка входа в программу – это функция main.
+int main() {
+    // для форматированного вывода в консоль используется printf
+    // %d – означает, что будем выводить целое число, \n переводит указатель вывода
+    // на новую строчку
+    printf("%d\n", 0); // => напечатает "0"
+    // Каждый оператор заканчивается точкой с запятой.
+
+    ///////////////////////////////////////
+    // Типы
+    ///////////////////////////////////////
+
+    // int обычно имеет длину 4 байта
+    int x_int = 0;
+
+    // short обычно имеет длину 2 байта
+    short x_short = 0;
+
+    // char гарантированно имеет длину 1 байта
+    char x_char = 0;
+    char y_char = 'y'; // Символьные литералы заключаются в кавычки ''
+
+    // long как правило занимает от 4 до 8 байт
+    // long long занимает как минимум 64 бита
+    long x_long = 0;
+    long long x_long_long = 0; 
+
+    // float это 32-битное число с плавающей точкой
+    float x_float = 0.0;
+
+    // double это 64-битное число с плавающей точкой
+    double x_double = 0.0;
+
+    // Целые типы могут быть беззнаковыми.
+    unsigned short ux_short;
+    unsigned int ux_int;
+    unsigned long long ux_long_long;
+
+    // sizeof(T) возвращает размер переменной типа Т в байтах.
+    // sizeof(obj) возвращает размер объекта obj в байтах.
+    printf("%zu\n", sizeof(int)); // => 4 (на большинстве машин int занимает 4 байта)
+
+    // Если аргуметом sizeof будет выражение, то этот аргумент вычисляется
+    // ещё во время компиляции кода (кроме динамических массивов).
+    int a = 1;
+    // size_t это беззнаковый целый тип который использует как минимум 2 байта
+    // для записи размера объекта
+    size_t size = sizeof(a++); // a++ не выполнится
+    printf("sizeof(a++) = %zu, где a = %d\n", size, a);
+    // выведет строку "sizeof(a++) = 4, где a = 1" (на 32-битной архитектуре)
+
+    // Можно задать размер массива при объявлении.
+    char my_char_array[20]; // Этот массив занимает 1 * 20 = 20 байт
+    int my_int_array[20]; // Этот массив занимает 4 * 20 = 80 байт (сумма 4-битных слов)
+
+    // Можно обнулить массив при объявлении.
+    char my_array[20] = {0};
+
+    // Индексация массива происходит также как и в других Си-подобных языках.
+    my_array[0]; // => 0
+
+    // Массивы изменяемы. Это просто память как и другие переменные.
+    my_array[1] = 2;
+    printf("%d\n", my_array[1]); // => 2
+
+    // В C99 (а также опционально в C11), массив может быть объявлен динамически.
+    // Размер массива не обязательно должен быть рассчитан на этапе компиляции.
+    printf("Enter the array size: "); // спрашиваем юзера размер массива
+    char buf[0x100];
+    fgets(buf, sizeof buf, stdin);
+    size_t size = strtoul(buf, NULL, 10); // strtoul парсит строку в беззнаковое целое
+    int var_length_array[size]; // объявление динамического массива
+    printf("sizeof array = %zu\n", sizeof var_length_array);
+    // Вывод программы (в зависимости от архитектуры) будет таким:
+    // > Enter the array size: 10
+    // > sizeof array = 40
+
+    // Строка – это просто массив символов, оканчивающийся нулевым (NUL (0x00)) байтом
+    // представляемым в строке специальным символом '\0'.
+    // Нам не нужно вставлять нулевой байт в строковой литерал,
+    // компилятор всё сделает за нас.
+    char a_string[20] = "This is a string";
+    printf("%s\n", a_string); // %s обозначает вывод строки
+
+    printf("%d\n", a_string[16]); // => 0
+    // байт #17 тоже равен 0 (а также 18, 19, и 20)
+
+    // Если между одинарными кавычками есть символ – это символьный литерал,
+    // но это тип int, а не char (по историческим причинам).
+    
+    int cha = 'a'; // хорошо
+    char chb = 'a'; // тоже хорошо (подразумевается преобразование int в char)
+
+    ///////////////////////////////////////
+    // Операторы
+    ///////////////////////////////////////
+
+    // Можно использовать множественное объявление.
+    int i1 = 1, i2 = 2;
+    float f1 = 1.0, f2 = 2.0;
+
+    // Арифметика обычная
+    i1 + i2; // => 3
+    i2 - i1; // => 1
+    i2 * i1; // => 2
+    i1 / i2; // => 0 (0.5, но обрезается до 0)
+
+    f1 / f2; // => 0.5, плюс-минус погрешность потому что,
+    // цифры с плавающей точкой вычисляются неточно!
+
+    // Модуль
+    11 % 3; // => 2
+
+    // Операции сравнения вам уже знакомы, но в Си нет булевого типа.
+    // Вместо него используется int. 0 это false, всё остальное это true.
+    // Операции сравнения всегда возвращают 1 или 0.
+    3 == 2; // => 0 (false)
+    3 != 2; // => 1 (true)
+    3 > 2; // => 1
+    3 < 2; // => 0
+    2 <= 2; // => 1
+    2 >= 2; // => 1
+
+    // Си это не Питон – операции сравнения могут быть только парными.
+    int a = 1;
+    // ОШИБКА:
+    int between_0_and_2 = 0 < a < 2;
+    // Правильно:
+    int between_0_and_2 = 0 < a && a < 2;
+
+    // Логика 
+    !3; // => 0 (логическое НЕ)
+    !0; // => 1
+    1 && 1; // => 1 (логическое И)
+    0 && 1; // => 0
+    0 || 1; // => 1 (лигическое ИЛИ)
+    0 || 0; // => 0
+
+    // Битовые операторы
+    ~0x0F; // => 0xF0 (побитовое отрицание)
+    0x0F & 0xF0; // => 0x00 (побитовое И)
+    0x0F | 0xF0; // => 0xFF (побитовое ИЛИ)
+    0x04 ^ 0x0F; // => 0x0B (исключающее ИЛИ (XOR))
+    0x01 << 1; // => 0x02 (побитовый сдвиг влево (на 1))
+    0x02 >> 1; // => 0x01 (побитовый сдвиг вправо (на 1))
+
+    // Будьте осторожны при сдвиге беззнакового int, эти операции не определены:
+    // - сдвиг в знаковый бит у целого числа (int a = 1 << 32)
+    // - сдвиг влево отрицательных чисел (int a = -1 << 2)
+
+    ///////////////////////////////////////
+    // Структуры ветвления
+    ///////////////////////////////////////
+
+    // Условный оператор
+    if (0) {
+      printf("I am never run\n");
+    } else if (0) {
+      printf("I am also never run\n");
+    } else {
+      printf("I print\n");
+    }
+
+    // Цикл с предусловием
+    int ii = 0;
+    while (ii < 10) {
+        printf("%d, ", ii++); // инкрементация происходит после того как
+                              // знаечние ii передано ("postincrement")
+    } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+    printf("\n");
+    
+    //Цикл с постусловием
+    int kk = 0;
+    do {
+        printf("%d, ", kk);
+    } while (++kk < 10); // инкрементация происходит перед тем как
+                         // передаётся знаечние kk ("preincrement")
+    // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+    printf("\n");
+
+    // Цикл со счётчиком
+    int jj;
+    for (jj=0; jj < 10; jj++) {
+        printf("%d, ", jj);
+    } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+    printf("\n");
+
+    // Ветвление с множественным выбором
+    switch (some_integral_expression) {
+    case 0: // значения должны быть целыми константами (и могут быть выражениями)
+        do_stuff();
+        break; // если не написать break; то управление будет передено следующему блоку
+    case 1:
+        do_something_else();
+        break;
+    default:
+        // если не было совпадения, то выполняется блок default:
+        fputs("ошибка!\n", stderr);
+        exit(-1);
+        break;
+    }
+    
+    ///////////////////////////////////////
+    // Форматирование вывода
+    ///////////////////////////////////////
+
+    // Каждое выражение в Си имеет тип, но вы можете привести один тип к другому, 
+    // если хотите (с некоторыми искажениями).
+
+    int x_hex = 0x01; // Вы можете назначать переменные с помощью шеснадцатеричного кода.
+
+    // Приведение типов будет пытаться сохранять цифровые значения.
+    printf("%d\n", x_hex); // => Prints 1
+    printf("%d\n", (short) x_hex); // => Prints 1
+    printf("%d\n", (char) x_hex); // => Prints 1
+
+    // Типы могут переполняться без вызова предупреждения.
+    printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 if char is 8 bits long)
+
+    // Для определения максимального значения типов `char`, `signed char` и `unisigned char`,
+    // соответственно используйте CHAR_MAX, SCHAR_MAX и UCHAR_MAX макросы из <limits.h>
+    
+    // Целые типы могут быть приведены к вещественным и наоборот.
+    printf("%f\n", (float)100); // %f formats a float
+    printf("%lf\n", (double)100); // %lf formats a double
+    printf("%d\n", (char)100.0);
+
+    ///////////////////////////////////////
+    // Указатели
+    ///////////////////////////////////////
+
+    // Указатель – это переменная которая хранит адрес в памяти.
+    // При объявлении указателя указывается тип данных переменной на которую он будет ссылаться.
+    // Вы можете получить адрес любой переменной, а потом работать с ним.
+
+    // Используйте & для получения адреса переменной.
+    int x = 0;
+    printf("%p\n", (void *)&x); // => Напечатает адрес в памяти, где лежит переменная x
+    // (%p выводит указатель на void *)
+
+    // Для объявления указателя нужно поставить * перед именем.
+    int *px, not_a_pointer; // px это указатель на int
+    px = &x; // сохранит адрес x в px
+    printf("%p\n", (void *)px); // => Напечатает адрес в памяти, где лежит переменная px
+    printf("%zu, %zu\n", sizeof(px), sizeof(not_a_pointer));
+    // => Напечатает "8, 4" в 64 битной системе
+
+    // Для того, чтобы получить знаечние по адресу, напечатайте * перед именем.
+    // Да, использование * при объявлении указателя и получении значения по адресу
+    // немного запутано, но вы привыкнете.
+    printf("%d\n", *px); // => Напечаатет 0, значение перемененной x
+
+    // Вы также можете изменять значение, на которое указывает указатель.
+    (*px)++; // Инкрементирует значение на которое указывает px на единицу
+    printf("%d\n", *px); // => Напечатает 1
+    printf("%d\n", x); // => Напечатает 1
+
+    // Массивы удобно использовать для болшого количества однотипных данных.
+    int x_array[20];
+    int xx;
+    for (xx = 0; xx < 20; xx++) {
+        x_array[xx] = 20 - xx;
+    } // Объявление x_array с значениями 20, 19, 18,... 2, 1
+
+    // Объявление указателя на int с адресом массива.
+    int* x_ptr = x_array;
+    // x_ptr сейчас указывает на первый элемент массива (со значением 20). 
+    // Это рабоатет, потому что имя массива возвращает указатель на первый элемент.
+    // Например, когда массив передаётся в функцию или назначается указателю, он
+    // невявно преобразуется в указатель.
+    // Исключения: когда массив является аргументом для оператор '&':
+    int arr[10];
+    int (*ptr_to_arr)[10] = &arr; // &arr не является 'int *'!
+                                  // он является "указателем на массив" (из десяти 'int'ов).
+    // или когда массив это строчный литерал, используемый при объявлении массива символов:
+    char arr[] = "foobarbazquirk";
+    // или когда массив является аргументом `sizeof` или `alignof` операторов:
+    int arr[10];
+    int *ptr = arr; // то же самое что и "int *ptr = &arr[0];"
+    printf("%zu %zu\n", sizeof arr, sizeof ptr); // напечатает "40, 4" или "40, 8"
+
+    // Декрементация и инкрементация указателей зависит от их типа
+    // (это называется арифметика указателей)
+    printf("%d\n", *(x_ptr + 1)); // => Напечатает 19
+    printf("%d\n", x_array[1]); // => Напечатает 19
+
+    // Вы также можете динамически выделять несколько блоков памяти с помощью
+    // функции malloc из стандартной библиотеки, которая принимает один 
+    // аргумент типа size_t – количество байт необходимых для выделения.
+    int *my_ptr = malloc(sizeof(*my_ptr) * 20);
+    for (xx = 0; xx < 20; xx++) {
+        *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx
+    } // Выделяет память для 20, 19, 18, 17... 2, 1 (как int'ы)
+
+    // Работа с памятью с помощью указателей может давать неожиданные и
+    // непредсказуемые результаты.
+    printf("%d\n", *(my_ptr + 21)); // => Напечатает кто-нибудь-знает-что? 
+                                    // Скорей всего программа вылетит.
+
+    // Когда вы закончили работать с памятью, которую ранее выделили, вам необходимо 
+    // освободить её, иначе это может вызвать утечку памяти или ошибки.
+    free(my_ptr);
+
+    // Строки это массивы символов, но обычно они представляются как 
+    // указатели на символ (как указатели на первый элемент массива).
+    // Хорошей практикой считается использование `const char *' при объявлении 
+    // строчного литерала. При таком подходе литерал не может быть изменён.
+    // (например "foo"[0] = 'a' вызовет ошибку!)
+
+    const char *my_str = "This is my very own string literal";
+    printf("%c\n", *my_str); // => 'T'
+
+    // Это не работает, если строка является массивом
+    // (потенциально задаваемой с помощью строкового литерала)
+    // который находиться в перезаписываемой части памяти:
+
+    char foo[] = "foo";
+    foo[0] = 'a'; // это выполнится и строка теперь "aoo"
+
+    void function_1()
+} // конец функции main()
+
+///////////////////////////////////////
+// Функции
+///////////////////////////////////////
+
+// Синтаксис объявления функции:
+// <возвращаемый тип> <имя функции>(аргументы)
+
+int add_two_ints(int x1, int x2) {
+    return x1 + x2; // Используйте return для возврата значения
+}
+
+/*
+Данные в функцию передаются "по значению", но никто не мешает
+вам передавать в функцию указатели и менять данные по указателям.
+
+Например: инвертировать строку прямо в функции
+*/
+
+// void означает, что функция ничего не возвращает
+void str_reverse(char *str_in) {
+    char tmp;
+    int ii = 0;
+    size_t len = strlen(str_in); // `strlen()` является частью стандартной библиотеки
+    for (ii = 0; ii < len / 2; ii++) {
+        tmp = str_in[ii];
+        str_in[ii] = str_in[len - ii - 1]; // ii-тый символ с конца
+        str_in[len - ii - 1] = tmp;
+    }
+}
+
+char c[] = "This is a test.";
+str_reverse(c);
+printf("%s\n", c); // => Выведет ".tset a si sihT"
+
+///////////////////////////////////////
+// Типы и структуры определяемые пользователем
+///////////////////////////////////////
+
+// typedef используется для задания стандартным типам своих названий
+typedef int my_type;
+my_type my_type_var = 0;
+
+// Структуры это просто коллекция данных, память выделяется последовательно,
+// в том порядке в котором записаны данные.
+struct rectangle {
+    int width;
+    int height;
+};
+
+// sizeof(struct rectangle) == sizeof(int) + sizeof(int) – не всегда верно
+// из-за особенностей компиляции (необычное поведение при отступах)[1].
+
+void function_1() {
+    struct rectangle my_rec;
+
+    // Доступ к структурам через точку
+    my_rec.width = 10;
+    my_rec.height = 20;
+
+    // Вы можете объявить указатель на структуру
+    struct rectangle *my_rec_ptr = &my_rec;
+
+    // Можно доступаться к структуре и через указатель
+    (*my_rec_ptr).width = 30;
+
+    // ... или ещё лучше: используйте оператор -> для лучшей читабельночти
+    my_rec_ptr->height = 10; // то же что и "(*my_rec_ptr).height = 10;"
+}
+
+// Вы можете применить typedef к структуре, для удобства.
+typedef struct rectangle rect;
+
+int area(rect r) {
+    return r.width * r.height;
+}
+
+// Если вы имеете большую структуру, можно доступаться к ней "по указателю",
+// чтобы избежать копирования всей структуры.
+int area(const rect *r) {
+    return r->width * r->height;
+}
+
+///////////////////////////////////////
+// Указатели на функции
+///////////////////////////////////////
+
+/*
+Во время исполнения функции находятся по известным адресам в памяти.
+Указатель на функцию может быть использован для непосредственного вызова функции.
+Однако синтаксис может сбивать с толку.
+
+Пример: использование str_reverse по указателю
+*/
+
+void str_reverse_through_pointer(char *str_in) {
+    // Определение функции через указатель.
+    void (*f)(char *); // Сигнатура должна полность совпадать с целевой функцией.
+    f = &str_reverse; // Присвоить фактический адрес (во время исполнения)
+    // "f = str_reverse;" тоже будет работать.
+    //Имя функции (как и массива) возвращает указатель на начало.
+    (*f)(str_in); // Просто вызываем функцию через указатель.
+    // "f(str_in);" или вот так
+}
+```
+
+## На почитать
+
+Лучше всего найдите копию [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)
+Это **книга** написанная создателями Си. Но будьте осторожны, она содержит идеи которые больше не считаются хорошими.
+
+Другой хороший ресурс: [Learn C the hard way](http://c.learncodethehardway.org/book/).
+
+Если у вас появился вопрос, почитайте [compl.lang.c Frequently Asked Questions](http://c-faq.com).
+
+Очень важно использовать правильные отступы и ставить пробелы в нужных местах.
+Читаемый код лучше чем красивый или быстрый код.
+Чтобы научиться писать хороший код, почитайте [Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle).
+
+Также не забывайте, что [Google](http://google.com) и [Яндекс](http://yandex.ru) – ваши хорошие друзья.
+
+[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
diff --git a/ru-ru/clojure-ru.html.markdown b/ru-ru/clojure-ru.html.markdown
new file mode 100644
index 00000000..2f508a00
--- /dev/null
+++ b/ru-ru/clojure-ru.html.markdown
@@ -0,0 +1,427 @@
+---
+language: clojure
+filename: learnclojure-ru.clj
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Alexey Pirogov", "http://twitter.com/alex_pir"]
+lang: ru-ru
+---
+
+Clojure, это представитель семейства Lisp-подобных языков, разработанный
+для Java Virtual Machine. Язык идейно гораздо ближе к чистому
+[функциональному программированию](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) чем его прародитель Common Lisp, но в то же время обладает набором инструментов для работы с состоянием,
+таких как [STM](https://ru.wikipedia.org/wiki/Software_transactional_memory).
+
+Благодаря такому сочетанию технологий в одном языке, разработка программ,
+предполагающих конкурентное выполнение, значительно упрощается
+и даже может быть автоматизирована.
+
+(Последующие примеры кода предполагают выполнение в Clojure версии 1.2 и выше)
+
+
+```clojure
+; Комментарии начинаются символом ";".
+
+; Код на языке Clojure записывается в виде "форм",
+; которые представляют собой обычные списки элементов, разделенных пробелами,
+; заключённые в круглые скобки
+;
+; Clojure Reader (инструмент языка, отвечающий за чтение исходного кода),
+; анализируя форму, предполагает, что первым элементом формы (т.е. списка)
+; является функция или макрос, который следует вызвать, передав ему
+; в качестве аргументов остальные элементы списка-формы.
+
+; Первым вызовом в файле должен быть вызов функции ns,
+; которая отвечает за выбор текущего пространства имен (namespace)
+(ns learnclojure-ru)
+
+; Несколько простых примеров:
+
+; str объединяет в единую строку все свои аргументы
+(str "Hello" " " "World") ; => "Hello World"
+
+; Арифметика тоже выглядит несложно
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+
+; Проверка на равенство (Equality)
+(= 1 1) ; => true
+(= 2 1) ; => false
+
+; Для булевой логики вам может понадобиться not
+(not true) ; => false
+
+; Вложенные формы, конечно же, допустимы и работают вполне предсказуемо
+(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+
+; Типы
+;;;;;;;;;;;;;
+
+; Clojure использует типы Java для представления булевых значений,
+; строк и чисел
+; Узнать тип мы можем, использую функцию `class
+(class 1)     ; Целочисленные литералы типа по-умолчанию являются java.lang.Long
+(class 1.)    ; Числа с плавающей точкой, это java.lang.Double
+(class "")    ; Строки всегда заключаются в двойные кавычки
+              ; и представляют собой java.lang.String
+(class false) ; Булевы значения, это экземпляры java.lang.Boolean
+(class nil)   ; "Пустое" значение называется "nil"
+
+; Если Вы захотите создать список из чисел, вы можете просто
+; предварить форму списка символом "'", который подскажет Reader`у,
+; что эта форма не требует вычисления
+'(+ 1 2) ; => (+ 1 2)
+; ("'", это краткая запись формы (quote (+ 1 2))
+
+; "Квотированный" список можно вычислить, передав его функции eval
+(eval '(+ 1 2)) ; => 3
+
+; Коллекции и Последовательности
+;;;;;;;;;;;;;;;;;;;
+
+; Списки (Lists) в clojure структурно представляют собой "связанные списки",
+; тогда как Векторы (Vectors), устроены как массивы.
+; Векторы и Списки тоже являются классами Java!
+(class [1 2 3]); => clojure.lang.PersistentVector
+(class '(1 2 3)); => clojure.lang.PersistentList
+
+; Список может быть записан, как (1 2 3), но в этом случае
+; он будет воспринят reader`ом, как вызов функции.
+; Есть два способа этого избежать:
+; '(1 2 3)     - квотирование,
+; (list 1 2 3) - явное конструирование списка с помощью функции list.
+
+; "Коллекции", это некие наборы данных
+; И списки, и векторы являются коллекциями:
+(coll? '(1 2 3)) ; => true
+(coll? [1 2 3]) ; => true
+
+; "Последовательности" (seqs), это абстракция над наборами данных,
+; элементы которых "упакованы" последовательно.
+; Списки - последовательности, а вектора - нет.
+(seq? '(1 2 3)) ; => true
+(seq? [1 2 3]) ; => false
+
+; Любая seq предоставляет доступ только к началу последовательности данных,
+; не предоставляя информацию о её длине.
+; При этом последовательности могут быть и бесконечными,
+; т.к. являются ленивыми и предоставляют данные только по требованию!
+(range 4) ; => (0 1 2 3)
+(range) ; => (0 1 2 3 4 ...) (бесконечная последовательность!)
+(take 4 (range)) ;  (0 1 2 3)
+
+; Добавить элемент в начало списка или вектора можно с помощью функции cons
+(cons 4 [1 2 3]) ; => (4 1 2 3)
+(cons 4 '(1 2 3)) ; => (4 1 2 3)
+
+; Функция conj добавляет элемент в коллекцию
+; максимально эффективным для неё способом.
+; Для списков эффективно добавление в начло, а для векторов - в конец.
+(conj [1 2 3] 4) ; => [1 2 3 4]
+(conj '(1 2 3) 4) ; => (4 1 2 3)
+
+; Функция concat объединяет несколько списков и векторов в единый список
+(concat [1 2] '(3 4)) ; => (1 2 3 4)
+
+; Работать с коллекциями удобно с помощью функций filter и map
+(map inc [1 2 3]) ; => (2 3 4)
+(filter even? [1 2 3]) ; => (2)
+
+; reduce поможет "свернуть" коллекцию
+(reduce + [1 2 3 4])
+; = (+ (+ (+ 1 2) 3) 4)
+; => 10
+
+; Вызывая reduce, мы можем указать начальное значение
+(reduce conj [] '(3 2 1))
+; = (conj (conj (conj [] 3) 2) 1)
+; => [3 2 1]
+
+; Функции
+;;;;;;;;;;;;;;;;;;;;;
+
+; Функция создается специальной формой fn.
+; "Тело"" функции может состоять из нескольких форм,
+; но результатом вызова функции всегда будет результат вычисления
+; последней из них.
+(fn [] "Hello World") ; => fn
+
+; (Вызов функции требует "оборачивания" fn-формы в форму вызова)
+((fn [] "Hello World")) ; => "Hello World"
+
+; Назначить значению имя можно специальной формой def
+(def x 1)
+x ; => 1
+
+; Назначить имя можно любому значению, в т.ч. и функции:
+(def hello-world (fn [] "Hello World"))
+(hello-world) ; => "Hello World"
+
+; Поскольку именование функций - очень частая операция,
+; clojure позволяет, сделать это проще:
+(defn hello-world [] "Hello World")
+
+; Вектор [] в форме описания функции, следующий сразу за именем,
+; описывает параметры функции:
+(defn hello [name]
+  (str "Hello " name))
+(hello "Steve") ; => "Hello Steve"
+
+; Одна функция может иметь сразу несколько наборов аргументов:
+(defn hello3
+  ([] "Hello World")
+  ([name] (str "Hello " name)))
+(hello3 "Jake") ; => "Hello Jake"
+(hello3) ; => "Hello World"
+
+; Также функция может иметь набор аргументов переменной длины
+(defn count-args [& args] ; args будет содержать seq аргументов
+  (str "You passed " (count args) " args: " args))
+(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
+
+; Можно комбинировать оба подхода задания аргументов
+(defn hello-count [name & args]
+  (str "Hello " name ", you passed " (count args) " extra args"))
+(hello-count "Finn" 1 2 3)
+; => "Hello Finn, you passed 3 extra args"
+
+; Для создания анонимных функций есть специальный синтаксис:
+; функциональные литералы
+(def hello2 #(str "Hello " %1))
+(hello2 "Fanny") ; => "Hello Fanny"
+
+; такие функциональные литералы удобно использовать с map, filter и reduce
+(map #(* 10 %1) [1 2 3 5])          ; => (10 20 30 50)
+(filter #(> %1 3) [1 2 3 4 5 6 7])  ; => (4 5 6 7)
+(reduce #(str %1 "," %2) [1 2 3 4]) ; => "1,2,3,4"
+
+; Отображения (Maps)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; Hash maps и array maps имеют одинаковый интерфейс.
+; Hash maps производят поиск по ключу быстрее, но не сохраняют порядок ключей
+(class {:a 1 :b 2 :c 3})          ; => clojure.lang.PersistentArrayMap
+(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
+
+; Array maps автоматически преобразуются в hash maps,
+; как только разрастутся до определенного размера
+
+; Отображения могут использовать в качестве ключей любые хэшируемые значения,
+; однако предпочтительными являются ключи,
+; являющиеся "ключевыми словами" (keywords)
+(class :a) ; => clojure.lang.Keyword
+
+(def stringmap {"a" 1, "b" 2, "c" 3})
+stringmap  ; => {"a" 1, "b" 2, "c" 3}
+
+(def keymap {:a 1, :b 2, :c 3})
+keymap ; => {:a 1, :c 3, :b 2}
+
+; Предыдущий пример содержит запятые в коде, однако reader не использует их,
+; при обработке литералов - запятые просто воспринимаются,
+; как "пробельные символы" (whitespaces)
+
+; Отображение может выступать в роли функции, возвращающей значение по ключу
+(stringmap "a")          ; => 1
+(keymap :a)              ; => 1
+
+; При попытке получить отсутствующее значение, будет возвращён nil
+(stringmap "d") ; => nil
+
+; Иногда бывает удобно указать конкретное значение по-умолчанию:
+({:a 1 :b 2} :c "Oops!") ; => "Oops!"
+
+; Keywords тоже могут использоваться в роли функций!
+(:b keymap) ; => 2
+
+; Однако этот фокус не пройдёт со строками.
+;("a" stringmap)
+; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+
+; Добавить пару ключ-значение в отображение можно функцией assoc
+(def newkeymap (assoc keymap :d 4))
+newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
+
+; Но всегда следует помнить, что значения в Clojure - неизменяемые!
+keymap ; => {:a 1, :b 2, :c 3} - оригинал не был затронут
+
+; dissoc позволяет исключить значение по ключу
+(dissoc keymap :a :b) ; => {:c 3}
+
+; Множества (Sets)
+;;;;;;;;;;;;;;;;;;
+
+(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
+(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
+
+; Добавляются элементы посредством conj
+(conj #{1 2 3} 4) ; => #{1 2 3 4}
+
+; Исключаются - посредством disj
+(disj #{1 2 3} 1) ; => #{2 3}
+
+; Вызов множества, как функции, позволяет проверить
+; принадлежность элемента этому множеству:
+(#{1 2 3} 1) ; => 1
+(#{1 2 3} 4) ; => nil
+
+; В пространстве имен clojure.sets
+; содержится множество функций для работы с множествами
+
+; Полезные формы
+;;;;;;;;;;;;;;;;;
+
+; Конструкции ветвления в clojure, это обычные макросы
+; и подобны их собратьям в других языках:
+(if false "a" "b") ; => "b"
+(if false "a") ; => nil
+
+; Специальная форма let позволяет присвоить имена значениям локально.
+; При этом все изменения будут видны только вложенным формам:
+(def a 10)
+(let [a 1 b 2]
+  (> a b)) ; => false
+
+; Несколько форм можно объединить в одну форму посредством do
+; Значением do-формы будет значение последней формы из списка вложенных в неё:
+(do
+  (print "Hello")
+  "World") ; => "World" (prints "Hello")
+
+; Множество макросов содержит внутри себя неявную do-форму.
+; Пример - макрос определения функции:
+(defn print-and-say-hello [name]
+  (print "Saying hello to " name)
+  (str "Hello " name))
+(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
+
+; Ещё один пример - let:
+(let [name "Urkel"]
+  (print "Saying hello to " name)
+  (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
+
+; Модули
+;;;;;;;;;
+
+; Форма "use" позволяет добавить в текущее пространство имен
+; все имена (вместе со значениями) из указанного модуля:
+(use 'clojure.set)
+
+; Теперь нам доступны операции над множествами:
+(intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
+(difference #{1 2 3} #{2 3 4}) ; => #{1}
+
+; use позволяет указать, какие конкретно имена
+; должны быть импортированы из модуля:
+(use '[clojure.set :only [intersection]])
+
+; Также модуль может быть импортирован формой require
+(require 'clojure.string)
+
+; После этого модуль становится доступе в текущем пространстве имен,
+; а вызов его функций может быть осуществлен указанием полного имени функции:
+(clojure.string/blank? "") ; => true
+
+; Импортируемому модулю можно назначить короткое имя:
+(require '[clojure.string :as str])
+(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst."
+; (Литерал вида #"" обозначает регулярное выражение)
+
+; Вместо отдельной формы require (и use, хотя это и не приветствуется) можно
+; указать необходимые модули прямо в форме ns:
+(ns test
+  (:require
+    [clojure.string :as str] ; Внимание: при указании внутри формы ns
+    [clojure.set :as set]))  ; имена пакетов не квотируются!
+
+; Java
+;;;;;;;
+
+; Стандартная библиотека Java очень богата,
+; и всё это богатство доступно и для Clojure!
+
+; import позволяет импортировать модули Java
+(import java.util.Date)
+
+; В том числе и из ns
+(ns test
+  (:import java.util.Date
+           java.util.Calendar))
+
+; Имя класса, сопровождаемое символом "." позволяет
+; инстанцировать объекты Java-классов:
+(Date.) ; <a date object>
+
+; форма . позволяет вызывать методы:
+(. (Date.) getTime) ; <a timestamp>
+(.getTime (Date.))  ; а можно и так
+
+; Статические методы вызываются как функции модуля:
+(System/currentTimeMillis) ; <a timestamp> (Модуль system всегда доступен!)
+
+; doto позволяет удобно работать с объектами, изменяющими свое состояние
+(import java.util.Calendar)
+(doto (Calendar/getInstance)
+  (.set 2000 1 1 0 0 0)
+  .getTime) ; => A Date. set to 2000-01-01 00:00:00
+
+; Работа с изменяемым сотоянием
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; Clojure предоставляет набор инструментов
+; для работы с изменяемым состоянием: Software Transactional Memory.
+; Структуры STM представлены тремя типами:
+; - атомы (atoms)
+; - агенты (agents)
+; - ссылки (references)
+
+; Самые простые хранители состояния - атомы:
+(def my-atom (atom {})) ; {} - начальное состояние атома
+
+; Обновляется атом посредством swap!.
+; swap! применяет функцию аргумент к текущему значению
+; атома и помещает в атом результат
+(swap! my-atom assoc :a 1) ; Обновляет my-atom, помещая в него (assoc {} :a 1)
+(swap! my-atom assoc :b 2) ; Обновляет my-atom, помещая в него (assoc {:a 1} :b 2)
+
+; Получить значение атома можно посредством '@'
+; (провести так называемую операцию dereference)
+my-atom  ;=> Atom<#...> (Возвращает объект типа Atom)
+@my-atom ; => {:a 1 :b 2}
+
+; Пример реализации счётчика на атоме
+(def counter (atom 0))
+(defn inc-counter []
+  (swap! counter inc))
+
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+
+@counter ; => 5
+
+; С другими STM-конструкциями - refs и agents - можно ознакомиться тут:
+; Refs: http://clojure.org/refs
+; Agents: http://clojure.org/agents
+```
+
+### Для будущего чтения
+
+Это руководство не претендует на полноту, но мы смеем надеяться, способно вызвать интерес к дальнейшему изучению языка.
+
+Clojure.org - сайт содержит большое количество статей по языку:
+[http://clojure.org/](http://clojure.org/)
+
+Clojuredocs.org - сайт документации языка с примерами использования функций:
+[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+
+4Clojure - отличный способ закрепить навыки программирования на clojure, решая задачи вместе с коллегами со всего мира:
+[http://www.4clojure.com/](http://www.4clojure.com/)
+
+Clojure-doc.org (да, именно) неплохой перечень статей для начинающих:
+[http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/ru-ru/coffeescript-ru.html.markdown b/ru-ru/coffeescript-ru.html.markdown
new file mode 100644
index 00000000..f8416f38
--- /dev/null
+++ b/ru-ru/coffeescript-ru.html.markdown
@@ -0,0 +1,104 @@
+---
+language: coffeescript
+contributors:
+  - ["Tenor Biel", "http://github.com/L8D"]
+  - ["Xavier Yao", "http://github.com/xavieryao"]
+translators:
+  - ["asaskevich", "http://github.com/asaskevich"]
+filename: learncoffee-ru.coffee
+lang: ru-ru
+---
+
+CoffeeScript - это небольшой язык, который компилируется один-в-один в эквивалентный код на языке JavaScript, а потому он не интерпретируется во время исполнения JavaScript кода.
+Ключевой особенностью CoffeeScript является то, что он пытается создать читабельный, качественно оформленный и плавный JavaScript код, прекрасно работающий в любой среде JavaScript.
+
+Также загляните на официальный сайт [языка](http://coffeescript.org/), где можно найти весьма полное учебное пособие по CoffeeScript.
+
+```coffeescript
+# CoffeeScript - язык хипстеров.
+# Язык использует самое модное из множества современных языков.
+# Эти комментарии по стилю похожи на комментарии Ruby или Python, они используют "решетку" в качестве знака комментария.
+
+###
+Блоки комментариев выделяются тремя символами "решетки", в результирующем JavaScript коде они будут преобразованы в  '/ * и '* /'.
+
+Перед тем, как идти далее, Вам нужно понимать семантику JavaScript.
+###
+
+# Присвоение:
+number   = 42 #=> var number = 42;
+opposite = true #=> var opposite = true;
+
+# Условия:
+number = -42 if opposite #=> if(opposite) { number = -42; }
+
+# Функции:
+square = (x) -> x * x #=> var square = function(x) { return x * x; }
+
+fill = (container, liquid = "coffee") ->
+  "Заполняем #{container} жидкостью #{liquid}..."
+#=>var fill;
+#
+#fill = function(container, liquid) {
+#  if (liquid == null) {
+#    liquid = "coffee";
+#  }
+#  return "Заполняем " + container + " жидкостью " + liquid + "...";
+#};
+
+# Списки и диапазоны:
+list = [1..5] #=> var list = [1, 2, 3, 4, 5];
+
+# Объекты:
+math =
+  root:   Math.sqrt
+  square: square
+  cube:   (x) -> x * square x
+#=> var math = {
+#  "root": Math.sqrt,
+#  "square": square,
+#  "cube": function(x) { return x * square(x); }
+#}
+
+# Многоточия:
+race = (winner, runners...) ->
+  print winner, runners
+#=>race = function() {
+#  var runners, winner;
+#  winner = arguments[0], runners = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+#  return print(winner, runners);
+#};
+
+# Проверка на существование объекта:
+alert "Так и знал!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Так и знал!"); }
+
+# Итерации по массивам:
+cubes = (math.cube num for num in list) 
+#=>cubes = (function() {
+#	var _i, _len, _results;
+#	_results = [];
+# 	for (_i = 0, _len = list.length; _i < _len; _i++) {
+#		num = list[_i];
+#		_results.push(math.cube(num));
+#	}
+#	return _results;
+#  })();
+
+foods = ['broccoli', 'spinach', 'chocolate']
+eat food for food in foods when food isnt 'chocolate'
+#=>foods = ['broccoli', 'spinach', 'chocolate'];
+#
+#for (_k = 0, _len2 = foods.length; _k < _len2; _k++) {
+#  food = foods[_k];
+#  if (food !== 'chocolate') {
+#    eat(food);
+#  }
+#}
+```
+
+## На почитать
+
+- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/)
+- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
+- [CoffeeScript на русском](http://cidocs.ru/coffeescript/)
diff --git a/ru-ru/erlang-ru.html.markdown b/ru-ru/erlang-ru.html.markdown
new file mode 100644
index 00000000..99ea79ee
--- /dev/null
+++ b/ru-ru/erlang-ru.html.markdown
@@ -0,0 +1,256 @@
+---
+language: erlang
+contributors:
+    - ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
+translators:
+    - ["Nikita Kalashnikov", "https://root.yuuzukiyo.net/"]
+filename: learnerlang-ru.erl
+lang: ru-ru
+---
+
+```erlang
+% Символ процента предваряет однострочный комментарий.
+
+%% Два символа процента обычно используются для комментариев к функциям.
+
+%%% Три символа процента используются для комментариев к модулям.
+
+% Пунктуационные знаки, используемые в Erlang:
+% Запятая (`,`) разделяет аргументы в вызовах функций, структурах данных и
+% образцах.
+% Точка (`.`) (с пробелом после них) разделяет функции и выражения в
+% оболочке.
+% Точка с запятой (`;`) разделяет выражения в следующих контекстах:
+% формулы функций, выражения `case`, `if`, `try..catch` и `receive`.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 1. Переменные и сопоставление с образцом.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+Num = 42.  % Все названия переменных начинаются с большой буквы.
+
+% Erlang использует единичное присваивание переменным. Если вы попытаетесь
+% присвоить другое значение переменной `Num`, вы получите ошибку.
+Num = 43. % ** exception error: no match of right hand side value 43
+
+% В большинстве языков `=` обозначает операцию присвоения. В отличие от них, в
+% Erlang `=` — операция сопоставления с образцом. `Lhs = Rhs` на самом
+% деле подразумевает «вычисли правую часть выражения (Rhs) и затем сопоставь
+% результат с образцом слева (Lhs)».
+Num = 7 * 6.
+
+% Числа с плавающей точкой.
+Pi = 3.14159.
+
+% Атомы используются для представления различных нечисловых констант. Названия
+% атомов начинаются с буквы в нижнем регистре, за которой могут следовать другие
+% буквы английского алфавита, цифры, символ подчёркивания (`_`) или «собака»
+% (`@`).
+Hello = hello.
+OtherNode = example@node.
+
+% Если в имени атома нужно использовать другие символы, кроме допустимых,
+% имя атома необходимо взять в одинарные кавычки (`'`).
+AtomWithSpace = 'some atom with space'.
+
+% Кортежы подобны структурам в языке C.
+Point = {point, 10, 45}.
+
+% Если нужно извлечь определённые данные из кортежа, используется оператор
+% сопоставления с образцом — `=`.
+{point, X, Y} = Point.  % X = 10, Y = 45
+
+% Символ `_` может использоваться как «заполнитель» для переменных, значения
+% которых в текущем выражении нас не интересуют. Он называется анонимной
+% переменной. В отличие от остальных переменных, множественные использования
+% `_` в одном образце не требуют, чтобы все значения, присваевыемые этой
+% переменной, были идентичными.
+Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}.
+{_, {_, {_, Who}, _}, _} = Person.  % Who = joe
+
+% Список создаётся путём заключения его элементов в квадратные скобки и
+% разделения их запятыми. Отдельные элементы списка могут быть любого типа.
+% Первый элемент списка называется головой списка. Список, получающийся в
+% результате отделения головы, называется хвостом списка.
+ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}].
+
+% Если `T` — список, то `[H|T]` — тоже список, где `H` является головой, а `T` —
+% хвостом. Вертикальная черта (`|`) разделяет голову и хвост списка.
+% `[]` — пустой список.
+% Мы можем извлекать элементы из списка с помощью сопоставления с образцом.
+% Если у нас есть непустой список `L`, тогда выражение `[X|Y] = L`, где `X` и
+% `Y` — свободные (не связанные с другими значениям) переменные, извлечёт голову
+% списка в `X` и его хвост в `Y`.
+[FirstThing|OtherThingsToBuy] = ThingsToBuy.
+% FirstThing = {apples, 10}
+% OtherThingsToBuy = {pears, 6}, {milk, 3}
+
+% В Erlang нет строк как отдельного типа. Все используемые в программах строки
+% являются обычным списком целых чисел. Строковые значения всегда должны быть в
+% двойных кавычках (`"`).
+Name = "Hello".
+[72, 101, 108, 108, 111] = "Hello".
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 2. Последовательное программирование.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Модуль — основная единица кода в Erlang. В них пишутся и сохраняются все
+% функции. Модули хранятся в файлах с расширением `.erl`.
+% Модули должны быть скомпилированы перед тем, как использовать код из них.
+% Скомпилированный файл модуля имеет разрешение `.beam`.
+-module(geometry).
+-export([area/1]). % список функций, экспортируемых из модуля.
+
+% Функция `area` состоит из двух формул (clauses). Формулы отделяются друг от
+% друга точкой с запятой, после последнего определения должна стоять точка с
+% пробелом после неё.
+% Каждое определение имеет заголовок и тело. Заголовок состоит из названия
+% функции и образца (в скобках); тело состоит из последовательных выражений,
+% вычисляемых, когда аргументы функции совпадают с образцом в заголовке.
+% Сопоставление с образцами в заголовках происходит в том порядке, в котором
+% они перечислены в определении функции.
+area({rectangle, Width, Ht}) -> Width * Ht;
+area({circle, R})            -> 3.14159 * R * R.
+
+% Компиляция файла с исходным кодом geometry.erl.
+c(geometry).  % {ok,geometry}
+
+% Необходимо указывать имя модуля вместе с именем функции для определения, какую
+% именно фукнцию мы хотим вызвать.
+geometry:area({rectangle, 10, 5}).  % 50
+geometry:area({circle, 1.4}).  % 6.15752
+
+% В Erlang две функции с разной арностью (числом аргументов) в пределах одного
+% модуля представляются как две разные функции.
+-module(lib_misc).
+-export([sum/1]). % экспорт функции `sum` с арностью 1, принимающую один аргумент.
+sum(L) -> sum(L, 0).
+sum([], N)    -> N;
+sum([H|T], N) -> sum(T, H+N).
+
+% Fun'ы — анонимные функции, называемые так по причине отсутствия имени. Зато
+% их можно присваивать переменным.
+Double = fun(X) -> 2*X end. % `Double` указывает на анонимную функцию с идентификатором: #Fun<erl_eval.6.17052888>
+Double(2).  % 4
+
+% Функции могут принимать fun'ы как параметры и возвращать их в качестве
+% результата вычислений.
+Mult = fun(Times) -> ( fun(X) -> X * Times end ) end.
+Triple = Mult(3).
+Triple(5).  % 15
+
+% Выделения списоков (list comprehensions) — выражения, создающие списки без
+% применения анонимных функций, фильтров или map'ов.
+% Запись `[F(X) || X <- L]` значит «список `F(X)`, где `X` последовательно
+% выбирается из списка `L`».
+L = [1,2,3,4,5].
+[2*X || X <- L].  % [2,4,6,8,10]
+% В выделениях списков могут быть генераторы и фильтры для отделения подмножеств
+% генерируемых значений.
+EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4]
+
+% Охранные выражения используются для простых проверок переменных в образцах,
+% что значительно расширяет возможности сопоставления. Они могут использоваться
+% в заголовках определений функций, предварённые ключевым словом `when`, а также
+% в условных конструкциях.
+max(X, Y) when X > Y -> X;
+max(X, Y) -> Y.
+
+% Охранные выражения можно группировать, разделяя запятой.
+% Последовательность `GuardExpr1, GuardExpr2, ..., GuardExprN` является истинной
+% только в том случае, когда все выражения, которые она содержат, являются
+% истинными.
+is_cat(A) when is_atom(A), A =:= cat -> true;
+is_cat(A) -> false.
+is_dog(A) when is_atom(A), A =:= dog -> true;
+is_dog(A) -> false.
+
+% Последовательность охранных выражений, разделённых точками с запятой, является
+% истинной в том случае, если хотя бы одно выражение из списка `G1; G2; ...; Gn`
+% является истинным.
+is_pet(A) when is_dog(A); is_cat(A) -> true;
+is_pet(A) -> false.
+
+% Записи предоставляют возможность именования определённых элементов в кортежах.
+% Определения записей могут быть включены в исходный код модулей Erlang или же
+% в заголовочные файлы с расширением `.hrl`.
+-record(todo, {
+  status = reminder,  % Значение по умолчанию.
+  who = joe,
+  text
+}).
+
+% Для чтения определений записей из файлов в оболочке можно использовать команду
+% `rr`.
+rr("records.hrl").  % [todo]
+
+% Создание и изменение записей.
+X = #todo{}.
+% #todo{status = reminder, who = joe, text = undefined}
+X1 = #todo{status = urgent, text = "Fix errata in book"}.
+% #todo{status = urgent, who = joe, text = "Fix errata in book"}
+X2 = X1#todo{status = done}.
+% #todo{status = done,who = joe,text = "Fix errata in book"}
+
+% Условное выражение `case`.
+% Функция `filter` возвращет список всех элементов `X` из списка `L`, для
+% которых выражение `P(X)` является истинным.
+filter(P, [H|T]) ->
+  case P(H) of
+    true -> [H|filter(P, T)];
+    false -> filter(P, T)
+  end;
+filter(P, []) -> [].
+filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4]
+
+% Условное выражение `if`.
+max(X, Y) ->
+  if
+    X > Y -> X;
+    X < Y -> Y;
+    true -> nil;
+  end.
+
+% Внимание: в выражении `if` должно быть как минимум одно охранное выраженние,
+% вычисляющееся в true, иначе возникнет исключение.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 3. Обработка исключений.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Исключения возникают в случае внутренних ошибок системы или вызываются
+% непосредственно из кода программы с помощью вызовов `throw(Exception)`,
+% `exit(Exception)` или `erlang:error(Exception)`.
+generate_exception(1) -> a;
+generate_exception(2) -> throw(a);
+generate_exception(3) -> exit(a);
+generate_exception(4) -> {'EXIT', a};
+generate_exception(5) -> erlang:error(a).
+
+% В Erlang есть два способа обработки исключений. Первый заключается в
+% использовании выражения `try..catch` в функции, в которой возможен выброс
+% исключения.
+catcher(N) ->
+  try generate_exception(N) of
+    Val -> {N, normal, Val}
+  catch
+    throw:X -> {N, caught, thrown, X};
+    exit:X -> {N, caught, exited, X};
+    error:X -> {N, caught, error, X}
+  end.
+
+% Второй способ заключается в использовании `catch`. Во время поимки исключения
+% оно преобразуется в кортеж с информацией об ошибке.
+catcher(N) -> catch generate_exception(N).
+
+```
+
+## Ссылки:
+
+* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/)
+* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang/programming-erlang)
+* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/)
+* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml)
diff --git a/ru-ru/go-ru.html.markdown b/ru-ru/go-ru.html.markdown
new file mode 100644
index 00000000..e06ae9bd
--- /dev/null
+++ b/ru-ru/go-ru.html.markdown
@@ -0,0 +1,336 @@
+---
+language: Go
+filename: learngo-ru.go
+contributors:
+    - ["Sonia Keys", "https://github.com/soniakeys"]
+    - ["Christopher Bess", "https://github.com/cbess"]
+    - ["Jesse Johnson", "https://github.com/holocronweaver"]
+    - ["Quint Guvernator", "https://github.com/qguv"]
+translators:
+    - ["Artem Medeusheyev", "https://github.com/armed"]
+    - ["Valery Cherepanov", "https://github.com/qumeric"]
+lang: ru-ru
+---
+
+Go - это язык общего назначения, целью которого является удобство, простота,
+конкурентность. Это не тренд в компьютерных науках, а новейший и быстрый
+способ решать насущные проблемы.
+
+Концепции Go схожи с другими императивными статически типизированными языками.
+Быстро компилируется и быстро исполняется, имеет лёгкие в понимании конструкции
+для создания масштабируемых и многопоточных программ.
+
+Может похвастаться отличной стандартной библиотекой и большим комьюнити, полным
+энтузиастов.
+
+```go
+// Однострочный комментарий
+/* Многострочный
+   комментарий */
+
+// Ключевое слово package присутствует в начале каждого файла.
+// Main это специальное имя, обозначающее исполняемый файл, нежели библиотеку.
+package main
+
+// Import предназначен для указания зависимостей этого файла.
+import (
+    "fmt"      // Пакет в стандартной библиотеке Go
+    "net/http" // Да, это веб-сервер!
+    "strconv"  // Конвертирование типов в строки и обратно
+    m "math"   // Импортировать math под локальным именем m.
+)
+
+// Объявление функции. Main это специальная функция, служащая точкой входа для
+// исполняемой программы. Нравится вам или нет, но Go использует фигурные
+// скобки.
+func main() {
+    // Println выводит строку в stdout.
+    // Данная функция находится в пакете fmt.
+    fmt.Println("Hello world!")
+
+    // Вызов другой функции из текущего пакета.
+    beyondHello()
+}
+
+// Функции содержат входные параметры в круглых скобках.
+// Пустые скобки все равно обязательны, даже если параметров нет.
+func beyondHello() {
+    var x int // Переменные должны быть объявлены до их использования.
+    x = 3     // Присвоение значения переменной.
+    // Краткое определение := позволяет объявить переменную с автоматической
+    // подстановкой типа из значения.
+    y := 4
+    sum, prod := learnMultiple(x, y)        // Функция возвращает два значения.
+    fmt.Println("sum:", sum, "prod:", prod) // Простой вывод.
+    learnTypes()                            // < y minutes, learn more!
+}
+
+// Функция, имеющая входные параметры и возвращающая несколько значений.
+func learnMultiple(x, y int) (sum, prod int) {
+    return x + y, x * y // Возврат двух значений.
+}
+
+// Некоторые встроенные типы и литералы.
+func learnTypes() {
+    // Краткое определение переменной говорит само за себя.
+    s := "Learn Go!" // Тип string.
+
+    s2 := `"Чистый" строковой литерал
+может содержать переносы строк` // Тоже тип данных string
+
+    // Символ не из ASCII. Исходный код Go в кодировке UTF-8.
+    g := 'Σ' // тип rune, это алиас для типа int32, содержит символ юникода.
+
+    f := 3.14195 // float64, 64-х битное число с плавающей точкой (IEEE-754).
+    c := 3 + 4i  // complex128, внутри себя содержит два float64.
+
+    // Синтаксис var с инициализациями.
+    var u uint = 7 // Беззнаковое, но размер зависит от реализации, как и у int.
+    var pi float32 = 22. / 7
+
+    // Синтаксис приведения типа с кратким определением
+    n := byte('\n') // byte – это алиас для uint8.
+
+    // Массивы имеют фиксированный размер на момент компиляции.
+    var a4 [4]int           // массив из 4-х int, инициализирован нулями.
+    a3 := [...]int{3, 1, 5} // массив из 3-х int, ручная инициализация.
+
+    // Слайсы (slices) имеют динамическую длину. И массивы, и слайсы имеют свои
+    // преимущества, но слайсы используются гораздо чаще.
+    s3 := []int{4, 5, 9}    // Сравните с a3, тут нет троеточия.
+    s4 := make([]int, 4)    // Выделение памяти для слайса из 4-х int (нули).
+    var d2 [][]float64      // Только объявление, память не выделяется.
+    bs := []byte("a slice") // Синтаксис приведения типов.
+
+    p, q := learnMemory() // Объявление p и q как указателей на int.
+    fmt.Println(*p, *q)   // * извлекает указатель. Печатает два int-а.
+
+    // Map, также как и словарь или хеш из некоторых других языков, является 
+    // ассоциативным массивом с динамически изменяемым размером.
+    m := map[string]int{"three": 3, "four": 4}
+    m["one"] = 1
+
+    delete(m, "three") // Встроенная функция, удаляет элемент из map-а.
+
+    // Неиспользуемые переменные в Go являются ошибкой.
+    // Нижнее подчёркивание позволяет игнорировать такие переменные.
+    _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
+    // Вывод считается использованием переменной.
+    fmt.Println(s, c, a4, s3, d2, m)
+
+    learnFlowControl() // Идем дальше.
+}
+
+// У Go есть полноценный сборщик мусора. В нем есть указатели, но нет арифметики
+// указателей. Вы можете допустить ошибку с указателем на nil, но не с
+// инкрементацией указателя.
+func learnMemory() (p, q *int) {
+    // Именованные возвращаемые значения p и q являются указателями на int.
+    p = new(int) // Встроенная функция new выделяет память.
+    // Выделенный int проинициализирован нулём, p больше не содержит nil.
+    s := make([]int, 20) // Выделение единого блока памяти под 20 int-ов.
+    s[3] = 7             // Присвоить значение одному из них.
+    r := -2              // Определить ещё одну локальную переменную.
+    return &s[3], &r     // Амперсанд(&) обозначает получение адреса переменной.
+}
+
+func expensiveComputation() float64 {
+    return m.Exp(10)
+}
+
+func learnFlowControl() {
+    // If-ы всегда требуют наличие фигурных скобок, но не круглых.
+    if true {
+        fmt.Println("told ya")
+    }
+    // Форматирование кода стандартизировано утилитой "go fmt".
+    if false {
+        // Будущего нет.
+    } else {
+        // Жизнь прекрасна.
+    }
+    // Используйте switch вместо нескольких if-else.
+    x := 42.0
+    switch x {
+    case 0:
+    case 1:
+    case 42:
+        // Case-ы в Go не "проваливаются" (неявный break).
+    case 43:
+        // Не выполнится.
+    }
+    // For, как и if не требует круглых скобок
+    // Переменные, объявленные в for и if являются локальными.
+    for x := 0; x < 3; x++ { // ++ – это операция.
+        fmt.Println("итерация", x)
+    }
+    // Здесь x == 42.
+
+    // For – это единственный цикл в Go, но у него есть альтернативные формы.
+    for { // Бесконечный цикл.
+        break    // Не такой уж и бесконечный.
+        continue // Не выполнится.
+    }
+    // Как и в for, := в if-е означает объявление и присвоение значения y,
+    // проверка y > x происходит после.
+    if y := expensiveComputation(); y > x {
+        x = y
+    }
+    // Функции являются замыканиями.
+    xBig := func() bool {
+        return x > 10000 // Ссылается на x, объявленный выше switch.
+    }
+    fmt.Println("xBig:", xBig()) // true (т.к. мы присвоили x = e^10).
+    x = 1.3e3                    // Тут х == 1300
+    fmt.Println("xBig:", xBig()) // Теперь false.
+
+    // Метки, куда же без них, их все любят.
+    goto love
+love:
+
+    learnDefer()      // Быстрый обзор важного ключевого слова.
+    learnInterfaces() // О! Интерфейсы, идём далее.
+}
+
+func learnDefer() (ok bool) {
+    // Отложенные(deferred) выражения выполняются сразу перед тем, как функция
+    // возвратит значение.
+    defer fmt.Println("deferred statements execute in reverse (LIFO) order.")
+    defer fmt.Println("\nThis line is being printed first because")
+    // defer широко используется для закрытия файлов, чтобы закрывающая файл
+    // функция находилась близко к открывающей.
+    return true
+}
+
+// Объявление Stringer как интерфейса с одним методом, String.
+type Stringer interface {
+    String() string
+}
+
+// Объявление pair как структуры с двумя полями x и y типа int.
+type pair struct {
+    x, y int
+}
+
+// Объявление метода для типа pair. Теперь pair реализует интерфейс Stringer.
+func (p pair) String() string { // p в данном случае называют receiver-ом.
+    // Sprintf – ещё одна функция из пакета fmt.
+    // Обращение к полям p через точку.
+    return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func learnInterfaces() {
+    // Синтаксис с фигурными скобками это "литерал структуры". Он возвращает
+    // проинициализированную структуру, а оператор := присваивает её p.
+    p := pair{3, 4}
+    fmt.Println(p.String()) // Вызов метода String у переменной p типа pair.
+    var i Stringer          // Объявление i как типа с интерфейсом Stringer.
+    i = p                   // Валидно, т.к. pair реализует Stringer.
+    // Вызов метода String у i типа Stringer. Вывод такой же, что и выше.
+    fmt.Println(i.String())
+
+    // Функции в пакете fmt сами всегда вызывают метод String у объектов для
+    // получения строкового представления о них.
+    fmt.Println(p) // Вывод такой же, что и выше. Println вызывает метод String.
+    fmt.Println(i) // Вывод такой же, что и выше.
+
+    learnVariadicParams("Учиться", "учиться", "и ещё раз учиться!")
+}
+
+// Функции могут иметь варьируемое количество параметров.
+func learnVariadicParams(myStrings ...interface{}) {
+    // Вывести все параметры с помощью итерации.
+    for _, param := range myStrings {
+        fmt.Println("param:", param)
+    }
+
+    // Передать все варьируемые параметры.
+    fmt.Println("params:", fmt.Sprintln(myStrings...))
+
+    learnErrorHandling()
+}
+
+func learnErrorHandling() {
+    // Идиома ", ok" служит для обозначения корректного срабатывания чего-либо.
+    m := map[int]string{3: "three", 4: "four"}
+    if x, ok := m[1]; !ok { // ok будет false, потому что 1 нет в map-е.
+        fmt.Println("тут никого нет")
+    } else {
+        fmt.Print(x) // x содержал бы значение, если бы 1 был в map-е.
+    }
+    // Идиома ", err" служит для обозначения была ли ошибка или нет.
+    if _, err := strconv.Atoi("non-int"); err != nil { // _ игнорирует значение
+        // выведет "strconv.ParseInt: parsing "non-int": invalid syntax"
+        fmt.Println(err)
+    }
+    // Мы ещё обратимся к интерфейсам чуть позже, а пока...
+    learnConcurrency()
+}
+
+// c – это тип данных channel (канал), объект для конкурентного взаимодействия.
+func inc(i int, c chan int) {
+    c <- i + 1 // когда channel слева, <- являтся оператором "отправки".
+}
+
+// Будем использовать функцию inc для конкурентной инкрементации чисел.
+func learnConcurrency() {
+    // Тот же make, что и в случае со slice. Он предназначен для выделения
+    // памяти и инициализации типов slice, map и channel.
+    c := make(chan int)
+    // Старт трех конкурентных goroutine. Числа будут инкрементированы
+    // конкурентно и, может быть параллельно, если машина правильно
+    // сконфигурирована и позволяет это делать. Все они будут отправлены в один
+    // и тот же канал.
+    go inc(0, c) // go начинает новую горутину.
+    go inc(10, c)
+    go inc(-805, c)
+    // Считывание всех трех результатов из канала и вывод на экран.
+    // Нет никакой гарантии в каком порядке они будут выведены.
+    fmt.Println(<-c, <-c, <-c) // канал справа, <- обозначает "получение".
+
+    cs := make(chan string)       // другой канал, содержит строки.
+    cc := make(chan chan string)  // канал каналов со строками.
+    go func() { c <- 84 }()       // пуск новой горутины для отправки значения
+    go func() { cs <- "wordy" }() // ещё раз, теперь для cs
+    // Select тоже что и switch, но работает с каналами. Он случайно выбирает
+    // готовый для взаимодействия канал.
+    select {
+    case i := <-c: // полученное значение можно присвоить переменной
+        fmt.Printf("это %T", i)
+    case <-cs: // либо значение можно игнорировать
+        fmt.Println("это строка")
+    case <-cc: // пустой канал, не готов для коммуникации.
+        fmt.Println("это не выполнится.")
+    }
+    // В этой точке значение будет получено из c или cs. Одна горутина будет
+    // завершена, другая останется заблокированной.
+
+    learnWebProgramming() // Да, Go это может.
+}
+
+// Всего одна функция из пакета http запускает web-сервер.
+func learnWebProgramming() {
+    // У ListenAndServe первый параметр это TCP адрес, который нужно слушать.
+    // Второй параметр это интерфейс типа http.Handler.
+    err := http.ListenAndServe(":8080", pair{})
+    fmt.Println(err) // не игнорируйте сообщения об ошибках
+}
+
+// Реализация интерфейса http.Handler для pair, только один метод ServeHTTP.
+func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+    // Обработка запроса и отправка данных методом из http.ResponseWriter
+    w.Write([]byte("You learned Go in Y minutes!"))
+}
+```
+
+## Что дальше
+
+Основа всех основ в Go это [официальный веб сайт](http://golang.org/).
+Там можно пройти туториал, поиграться с интерактивной средой Go и почитать
+объёмную документацию.
+
+Для живого ознакомления рекомендуется почитать исходные коды [стандартной
+библиотеки Go](http://golang.org/src/pkg/). Отлично задокументированная, она
+является лучшим источником для чтения и понимания Go, его стиля и идиом. Либо
+можно, кликнув на имени функции в [документации](http://golang.org/pkg/),
+перейти к ее исходным кодам.
diff --git a/ru-ru/haskell-ru.html.markdown b/ru-ru/haskell-ru.html.markdown
new file mode 100644
index 00000000..e15fe6b7
--- /dev/null
+++ b/ru-ru/haskell-ru.html.markdown
@@ -0,0 +1,546 @@
+---
+language: Haskell
+contributors:
+    - ["Adit Bhargava", "http://adit.io"]
+translators:
+    - ["Aleksey Pirogov", "http://astynax.github.io"]
+lang: ru-ru
+---
+
+Haskell разрабатывался, как чистый функциональный язык программирования, применимый на практике. Язык известен благодаря своей системе типов, и "знаменит" благодаря монадам. [Меня][autor] же Haskell заставляет возвращаться к себе снова и снова именно своей элегантностью и [я][autor] получаю истинное удовольствие, программируя на Haskell.
+
+```haskell
+-- Однострочные комментарии начинаются с двух дефисов
+{- Многострочный комментарий
+заключается в пару фигурных скобок с дефисами с внутренней стороны.
+-}
+
+-------------------------------------------------------
+-- 1. Примитивные типы и простейшие операции над ними
+-------------------------------------------------------
+
+-- Числа объявляются просто
+3 -- 3
+
+-- Арифметика тоже выглядит вполне ожидаемо
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- Операция деления всегда возвращает действительное число
+35 / 4 -- 8.75
+
+-- Делим нацело так
+35 `div` 4 -- 8
+
+-- Булевы значения - тоже примитивные значения
+True
+False
+
+-- Булева алгебра
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- В примере выше `not`, это функция, принимающая один аргумент.
+-- При вызове функции в Haskell список аргументов
+-- не нужно заключать в скобки - аргументы просто
+-- перечисляются через пробелы сразу после имени функции.
+-- Т.о. типичный вызов выглядит так:
+-- func arg1 arg2 arg3...
+-- Ниже же будет показано, как определять свои функции.
+
+-- Строки и символы
+"Это строка."
+'ы' -- а это символ
+'Нельзя заключать длинные строки в одинарные кавычки.' -- ошибка!
+
+-- Строки можно конкатенировать
+"Привет" ++ ", Мир!" -- "Привет, Мир!"
+
+-- При этом строки - это просто списки символов!
+"Я - строка!" !! 0 -- 'Я'
+
+
+----------------------------------------------------
+-- Списки и Кортежи
+----------------------------------------------------
+
+-- Все элементы списка в Haskell
+-- должны иметь один и тот же тип.
+
+-- Эти два списка - эквивалентны:
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- Haskell позволяет определять даже бесконечные списки!
+[1..] -- список всех натуральных чисел!
+
+-- Бесконечные списки возможно в Haskell потому, что он "ленив".
+-- В Haskell все вычисления производятся тогда и только тогда,
+-- когда их результат потребуется.
+-- Эта стратегия так и называется - "lazy evaluation".
+-- Скажем, если вам нужен тысячный элемент из
+-- списка натуральных чисел (бесконечного) и вы напишете так:
+
+[1..] !! 999 -- 1000
+
+-- То Haskell вычислит элементы этого списка от 1 до 1000...
+-- ... и остановится, ведь последующие элементы пока не нужны.
+-- Это значит, что остальные элементы нашего
+-- "бесконечного" списка не будут вычисляться! По крайней мере,
+-- пока не понадобятся и они.
+
+-- Списки можно объединять
+[1..5] ++ [6..10]
+
+-- И добавлять значения в начало
+0:[1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- А можно обратиться по индексу
+[0..] !! 5 -- 5
+
+-- Вот ещё несколько функций, часто используемых со списками
+head [1..5] -- 1
+tail [1..5] -- [2, 3, 4, 5]
+init [1..5] -- [1, 2, 3, 4]
+last [1..5] -- 5
+
+-- list comprehensions - "формулы" для описания списков
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+-- можно указать условие попадания элементов в список
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- Списки могут даже состоять из других списков
+[[1,2,3],[4,5,6]] !! 1 !! 2 -- 6 (вторая строка, третий столбец)
+
+-- Кортежи позволяют своим элементам иметь различные типы,
+-- но при этом кортежи имеют фиксированную длину.
+-- Кортеж:
+("haskell", 1)
+
+-- Часто кортежи из двух элементов называются "парами".
+-- Элементы пары можно получать так:
+fst ("haskell", 1) -- "haskell"
+snd ("haskell", 1) -- 1
+
+----------------------------------------------------
+-- 3. Функции
+----------------------------------------------------
+-- Простая функция, принимающая два аргумента
+add a b = a + b
+
+-- Внимание!
+-- Если вы используете ghci (интерактивный интерпретатор Haskell),
+-- вам нужно использовать ключевое слово `let`, примерно так:
+-- let add a b = a + b
+
+-- Вызовем нашу функцию
+add 1 2 -- 3
+
+-- Функцию можно поместить между первым и вторым аргументами,
+-- если заключить её имя в обратные кавычки
+1 `add` 2 -- 3
+
+{- Вы можете также определять функции, имя которых
+вообще не содержит букв! Таки функции и называются "операторами",
+и, да, вы можете определять свои операторы!
+Скажем, оператор целочисленного деления можно определить так -}
+(//) a b = a `div` b
+35 // 4 -- 8
+{- Здесь оператор заключен в скобки - как говорят,
+поставлен в префиксную позицию.
+В префиксной позиции оператор можно не только определять,
+но и вызывать -}
+(+) 1 2 -- 3
+
+-- Охранные выражения (guards) порой удобны,
+-- если наша функция ветвится
+fib x
+  | x < 2 = x
+  | otherwise = fib (x - 1) + fib (x - 2)
+
+{- Сопоставление с образцом (pattern matching)
+чем-то напоминает охранные выражения.
+Здесь мы видим три определения функции fib.
+При вызове функции по имени Haskell использует
+первое определение, к образцу которого
+"подойдет" набор аргументов -}
+fib 1 = 1
+fib 2 = 2
+fib x = fib (x - 1) + fib (x - 2)
+
+-- Pattern matching для кортежей выглядит так
+foo (x, y) = (x + 1, y + 2)
+
+{- Pattern matching для списков устроен чуть сложнее.
+Пусть `x` - первый элемент списка, а `xs` - остальные элементы.
+Тогда операции `head` и `tail` могут быть определены так -}
+myHead (x:xs) = x
+myTail (x:xs) = xs
+
+-- Функцию отображения мы можем написать так
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
+
+-- При сопоставлении происходит привязка
+-- элементов значения с именами в образце
+fstPlusThird (a : _ : b : _) = a + b
+fstPlusThird [1,2,3,4,5] -- 4
+-- Значения, для которых вместо имени указано `_`,
+-- игнорируются. Это удобно, когда важен сам факт
+-- совпадения образца
+oneElem [_] = True
+oneElem _ = False
+
+startsWith x (y:_) = x == y
+startsWith _ _ = False
+
+startsWith 'H' "Hello!" -- True
+startsWith 'H' "hello!" -- False
+
+{- Обратите внимание на тот факт,
+что первый аргумент нашей функции `myMap` - тоже функция!
+Функции, подобно `myMap`, принимающие другие функции
+в качестве параметров, или, скажем, возвращающие функции
+в качестве результата, называются
+Функциями Высших Порядков (ФВП, High Order Functions, HOF)
+-}
+
+-- Вместе с ФВП часто используются анонимные функции
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+-- Такие функции описываются в виде
+-- \arg1 arg1 .. -> expression
+
+-- Популярные в других языках ФВП присутствуют и в Haskell
+map (\x -> x * 10) [1..5] -- [10, 20, 30, 40, 50]
+filter (\x -> x > 2) [1..5] -- [3, 4, 5]
+
+{- Функция свертки
+(она же `reduce` или `inject` в других языках)
+в Haskell представлены функциями `foldr` и `foldl`.
+Суть свертки можно представить так:
+
+foldl f x0 [x1,x2,x3] -> (f (f (f x0 x1) x2) x3)
+foldr f x0 [x1,x2,x3] -> (f x1 (f x2 (f x3 x0)))
+
+Здесь x0 - начальное значения так называемого "аккумулятора"
+-}
+-- Эти два вызова дают одинаковый результат
+foldr (\x acc -> acc + x) 0 [1..5] -- 15
+foldl (\acc x -> acc + x) 0 [1..5] -- 15
+-- Тут можно даже заменить анонимную функцию на оператор
+foldr (+) 0 [1..5] -- 15
+foldl (+) 0 [1..5] -- 15
+
+-- Зато здесь разница видна
+foldr (\x acc -> (x + 10) : acc) [] [1..3] -- [11, 12, 13]
+foldl (\acc x -> (x + 10) : acc) [] [1..3] -- [13, 12, 11]
+
+{- Часто в качестве начального значения
+удобно брать крайнее значение списка (крайнее слева или справа).
+Для этого есть пара функций - `foldr1` и `foldl1`  -}
+foldr1 (+) [1..5] -- 15
+foldl1 (+) [1..5] -- 15
+
+----------------------------------------------------
+-- 4. Больше о функциях
+----------------------------------------------------
+
+{- Каррирование (currying)
+Если в Haskell при вызове функции передать не все аргументы,
+Функция становится "каррированой" - результатом вызова станет
+новая функция, которая при вызове и примет оставшиеся аргументы -}
+
+add a b = a + b
+foo = add 10 -- теперь foo будет принимать число
+             -- и добавлять к нему 10
+foo 5 -- 15
+
+-- Для операторов можно "опустить" любой из двух аргументов
+-- Используя этот факт можно определить
+-- функцию `foo` из кода выше несколько иначе
+foo = (+10)
+foo 5 -- 15
+
+-- Поупражняемся
+map (10-) [1..3] -- [9, 8, 7]
+filter (<5) [1..10] -- [1, 2, 3, 4]
+
+{- Композиция функций
+Функция (.) соединяет пару функций в цепочку.
+К примеру, можно соединить функцию, добавляющую 10,
+с функцией, умножающей на 5 -}
+foo = (*5) . (+10)
+
+-- (5 + 10) * 5 = 75
+foo 5 -- 75
+
+{- Управление приоритетом вычисления
+В Haskell есть функция `$`, которая применяет
+свой первый аргумент ко второму с наименьшим приоритетом
+(обычное применение функций имеет наивысший приоритет)
+Эта функция часто позволяет избежать использования
+"лишних" скобок -}
+head (tail (tail "abcd")) -- 'c'
+head $ tail $ tail "abcd" -- 'c'
+-- того же эффекта иногда можно достичь использованием композиции
+(head . tail . tail) "abcd" -- 'c'
+head . tail . tail $ "abcd" -- 'c'
+{- Тут стоит сразу запомнить, что композиция функций
+возвращает именно новую функцию, как в последнем примере.
+Т.е. можно делать так -}
+third = head . tail . tail
+-- но не так
+third = head $ tail $ tail -- (head (tail (tail))) - ошибка!
+
+----------------------------------------------------
+-- 5. Сигнатуры типов
+----------------------------------------------------
+
+{- Haskell обладает очень сильной системой типов.
+И типизация в Haskell - строгая. Каждое выражение имеет тип,
+который может быть описан сигнатурой.
+Сигнатура записывается в форме
+expression :: type signature
+-}
+
+-- Типы примитивов
+5 :: Integer
+"hello" :: String
+True :: Bool
+
+{- Функции тоже имеют тип
+`not` принимает булево значение и возвращает булев результат
+not :: Bool -> Bool
+
+Вот функция двух аргументов
+add :: Integer -> Integer -> Integer
+
+Тут то мы и видим предпосылки к каррированию: тип
+на самом деле выглядит так (скобки просто обычно опускаются)
+add :: (Integer -> Integer) -> Integer
+т.е. функция принимает аргумент,
+и возвращает функцию от второго аргумента! -}
+
+-- Считается хорошим тоном указывать сигнатуру определений,
+-- которые доступны другим разработчикам (публичны). Пример:
+double :: Integer -> Integer
+double x = x * 2
+
+----------------------------------------------------
+-- 6. Управление потоком исполнения
+----------------------------------------------------
+
+-- Выражение `if`
+haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
+
+-- Выражение `if` можно записать и в несколько строк.
+-- Соблюдайте отступы!
+haskell = if 1 == 1
+            then "awesome"
+            else "awful"
+
+-- Так как `if` - выражение, ветка `else` обязательна!
+-- И более того, результаты выражений в ветках `then` и `else`
+-- должны иметь одинаковый тип!
+
+-- `case`-выражение выглядит так
+case args of -- парсим аргументы командной строки
+  "help" -> printHelp
+  "start" -> startProgram
+  _ -> putStrLn "bad args"
+
+-- При вычислении результата `case`-выражения производится
+-- сопоставление с образцом:
+fib x = case x of
+          1 -> 1
+          2 -> 1
+          _ -> fib (x - 1) + fib (x - 2)
+
+-- В Haskell нет циклов - вместо них используются рекурсия,
+-- отображение, фильтрация и свертка (map/filter/fold)
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+for array func = map func array
+for [0..3] $ \i -> show i -- ["0", "1", "2", "3"]
+for [0..3] show           -- ["0", "1", "2", "3"]
+
+----------------------------------------------------
+-- 7. Пользовательские типы данных
+----------------------------------------------------
+
+-- Создадим свой Haskell-тип данных
+
+data Color = Red | Blue | Green
+
+-- Попробуем использовать
+
+say :: Color -> String
+say Red   = "You are Red!"
+say Blue  = "You are Blue!"
+say Green = "You are Green!"
+
+-- Типы могут иметь параметры (параметры типов)
+
+data Maybe a = Nothing | Just a
+
+-- Все эти выражения имеют тип `Maybe`
+Just "hello"    -- :: `Maybe String`
+Just 1          -- :: `Maybe Int`
+Nothing         -- :: `Maybe a` для любого `a`
+
+-- Типы могут быть достаточно сложными
+data Figure = Rectangle (Int, Int) Int Int
+            | Square (Int, Int) Int
+            | Point (Int, Int)
+
+area :: Figure -> Int
+area (Point     _)     = 0
+area (Square    _ s)   = s * s
+area (Rectangle _ w h) = w * h
+
+----------------------------------------------------
+-- 8. Ввод-вывод в Haskell
+----------------------------------------------------
+
+-- Полноценно объяснить тему ввода-вывода невозможно
+-- без объяснения монад, но для использования в простых случаях
+-- вводного описания будет достаточно.
+
+-- Когда программа на Haskell выполняется,
+-- вызывается функция с именем `main`.
+-- Эта функция должна вернуть значение типа `IO ()`
+-- Например
+
+main :: IO ()
+main = putStrLn $ "Hello, sky! " ++ (say Blue)
+-- `putStrLn` имеет тип `String -> IO ()`
+
+-- Проще всего реализовать программу с вводом-выводом (IO),
+-- если вы реализуете функцию с типом `String -> String`.
+-- Далее ФВП
+--    interact :: (String -> String) -> IO ()
+-- сделает всё за нас!
+
+countLines :: String -> String
+countLines = show . length . lines
+-- здесь `lines` разделяет строку на список строк
+-- по символу перевода строки
+
+main' :: IO ()
+main' = interact countLines
+
+{- Вы можете думать о типе `IO ()`,
+как о некотором представлении последовательности
+действий, которые должен совершить компьютер.
+Такое представление напоминает программу
+на императивном языке программирования. Для описания
+такой последовательности используется `do`-нотация -}
+
+sayHello :: IO ()
+sayHello = do
+   putStrLn "What is your name?"
+   name <- getLine -- запрашиваем строку и связываем с "name"
+   putStrLn $ "Hello, " ++ name
+
+-- Упражнение:
+--     напишите свою реализацию функции `interact`,
+--     которая запрашивает и обрабатывает только одну строку
+
+{- Код функции `sayHello` не будет исполняться
+при её определении. Единственное место, где IO-действия
+могут быть произведены - функция `main`!
+Чтобы эта программа выполнила действия в функции `sayHello`,
+закомментируйте предыдущее определение функции `main`
+и добавьте новое определение:
+
+main = sayHello -}
+
+{- Давайте подробнее рассмотрим, как работает функция `getLine`
+Её тип:
+   getLine :: IO String
+Вы можете думать, что значение типа `IO a` представляет
+собой компьютерную программу, в результате выполнения которой
+генерируется значение типа `a`, в дополнение
+к остальным эффектам, производимым при выполнении - таким как
+печать текста на экран. Это значение типа `a` мы можем
+сохранить с помощью оператора `<-`. Мы даже можем реализовать
+свое действие, возвращающее значение: -}
+
+action :: IO String
+action = do
+   putStrLn "This is a line. Duh"
+   input1 <- getLine
+   input2 <- getLine
+   -- Тип блока `do` будет соответствовать типу последнего
+   -- выполненного в блоке выражения.
+   -- Заметим, что `return` - не ключевое слово, а функция
+   -- типа `a -> IO a`
+   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
+
+-- Теперь это действие можно использовать вместо `getLine`:
+
+main'' = do
+    putStrLn "I will echo two lines!"
+    result <- action
+    putStrLn result
+    putStrLn "This was all, folks!"
+
+{- Тип `IO` - пример "монады". Языку Haskell нужны монады,
+чтобы оставаться преимущественно чистым функциональным языком.
+Любые функции, взаимодействующие с внешним миром
+(производящие ввод-вывод) имеют `IO` в своих сигнатурах.
+Это позволяет судить о функции как о "чистой" - такая не будет
+производить ввод-вывод. В ином случая функция - не "чистая".
+
+Такой подход позволяет очень просто разрабатывать многопоточные
+программы - чистые функции, запущенные параллельно
+не будут конфликтовать между собой в борьбе за ресурсы. -}
+
+----------------------------------------------------
+-- 9. Haskell REPL
+----------------------------------------------------
+
+{- Интерактивная консоль Haskell запускается командой `ghci`.
+Теперь можно вводить строки кода на Haskell.
+Связывание значений с именами производится
+с помощью выражения `let`: -}
+
+let foo = 5
+
+-- Тип значения или выражения можно узнать
+-- с помощью команды `:t`:
+
+>:t foo
+foo :: Integer
+
+-- Также можно выполнять действия с типом `IO ()`
+
+> sayHello
+What is your name?
+Friend!
+Hello, Friend!
+
+```
+
+Многое о Haskell, например классы типов и монады невозможно уместить в столь короткую статью. Огромное количество очень интересных идей лежит в основе языка, и именно благодаря этому фундаменту на языке так приятно писать код. Позволю себе привести ещё один маленький пример кода на Haskell - реализацию быстрой сортировки:
+
+```haskell
+qsort [] = []
+qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
+    where lesser  = filter (< p) xs
+          greater = filter (>= p) xs
+```
+
+Haskell прост в установке, забирайте [здесь](http://www.haskell.org/platform/) и пробуйте! Это же так интересно!.
+
+Более глубокое погрузиться в язык позволят прекрасные книги
+[Learn you a Haskell](http://learnyouahaskell.com/) и
+[Real World Haskell](http://book.realworldhaskell.org/).
+
+[autor]: http://adit.io имеется в виду автор оригинального текста Adit Bhargava *(примечание переводчика)*
diff --git a/ru-ru/java-ru.html.markdown b/ru-ru/java-ru.html.markdown
new file mode 100644
index 00000000..005495cc
--- /dev/null
+++ b/ru-ru/java-ru.html.markdown
@@ -0,0 +1,506 @@
+---
+language: java
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Madison Dickson", "http://github.com/mix3d"]
+translators:
+    - ["Sergey Gaykov", "https://github.com/gaykov"]
+filename: LearnJavaRu.java
+lang: ru-ru
+---
+
+Java - это объектно ориентированный язык программирования общего назначения,
+основанный на классах и поддерживающий параллельное программирование.
+[Подробнее читайте здесь.](http://docs.oracle.com/javase/tutorial/java/index.html)
+
+```java
+// Однострочные комментарии начинаются с //.
+/*
+Многострочные комментарии
+выглядят так.
+*/
+/**
+JavaDoc-комментарии выглядят так. Они используются для описания класса
+и его членов.
+*/
+
+// Импорт класса ArrayList из пакета java.util.
+import java.util.ArrayList;
+// Импорт всех классов из пакета java.security.
+import java.security.*;
+
+// Каждый .java файл содержит один публичный класс, имя которого совпадает с
+// именем файла. 
+public class LearnJavaRu {
+
+    // Программа должна содержать метод main, который является точкой входа.
+    public static void main (String[] args) {
+
+        // System.out.println используется для печати строк.
+        System.out.println("Hello World!");
+        System.out.println(
+            "Integer: " + 10 +
+            " Double: " + 3.14 +
+            " Boolean: " + true);
+
+        // Чтобы напечатать что-либо не заканчивая переводом строки
+        // используется System.out.print.
+        System.out.print("Hello ");
+        System.out.print("World");
+
+
+        ///////////////////////////////////////
+        // Типы и Переменные
+        ///////////////////////////////////////
+
+        // Переменные объявляются с использованием <тип> <имя>
+        // Byte - 8-битное целое число.
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+
+        // Short - 16-битное целое число.
+        // (-32,768 <= short <= 32,767)
+        short fooShort = 10000;
+
+        // Integer - 32-битное целое число.
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int fooInt = 1;
+
+        // Long - 64-битное целое число.
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long fooLong = 100000L;
+        // L используется для указания на то, что переменная имеет тип long;
+        // По умолчанию, числа без L являются integer.
+
+        // Замечание: в Java нет беззнаковых типов.
+
+        // Float - 32-битное IEEE 754 число с плавающей запятой с одинарной степенью точности.
+        float fooFloat = 234.5f;
+        // f используется для указания на то, что переменная имеет тип float;
+        // иначе, число являлось бы double.
+
+        // Double - 64-битное IEEE 754 число с плавающей запятой с двойной степенью точности.
+        double fooDouble = 123.4;
+
+        // Boolean - true или false
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char - Простой 16-битный символ Unicode.
+        char fooChar = 'A';
+
+        // Переменным final не может быть присвоен другой объект.
+        final int HOURS_I_WORK_PER_WEEK = 9001;
+
+        // Строки.
+        String fooString = "My String Is Here!";
+
+        // \n - это экранированный символ, который означает начало новой строки.
+        String barString = "Printing on a new line?\nNo Problem!";
+        // \t - это экранированный символ, который добавляет символ табуляции.
+        String bazString = "Do you want to add a tab?\tNo Problem!";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // Массивы
+        // Размер массива должен быть указан при объявлении.
+        // Объявлять массив можно в следующих форматах:
+        //<тип данных> [] <имя> = new <тип данных>[<размер массива>];
+        //<тип данных> <имя>[] = new <тип данных>[<размер массива>];
+        int [] intArray = new int[10];
+        String [] stringArray = new String[1];
+        boolean boolArray [] = new boolean[100];
+
+        // Другой способ объявления и инициализации массива:
+        int [] y = {9000, 1000, 1337};
+        String names [] = {"Bob", "John", "Fred", "Juan Pedro"};
+        boolean bools[] = new boolean[] {true, false, false};
+
+        // Индексация массива - доступ к элементу.
+        System.out.println("intArray @ 0: " + intArray[0]);
+
+        // Массивы изменяемы и индекс в них начинается с 0.
+        intArray[1] = 1;
+        System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+        // Дополнительно.
+        // ArrayLists - похож на массив, но предлагает больше возможностей,
+        //             его размер изменяемый.
+        // LinkedLists - реализация двусвязного списка. Все операции
+        //             выполняются так, как ожидается от двусвязного
+        //             списка.
+        // Maps        - набор объектов, в которых присутствует связь
+        //             ключ-значение. В Map ключ не может дублироваться.
+        //             Каждый ключ связан только с одним значением.
+        // HashMaps    - этот класс использует хэш-таблицу для реализации
+        //             интерфейса Map. Это позволяет сохранить постоянной
+        //             скорость выполнения базовых операций, таких как
+        //             добавление и удаление элементов, вне зависимости
+        //             от размера множества. 
+
+        ///////////////////////////////////////
+        // Операторы
+        ///////////////////////////////////////
+        System.out.println("\n->Операторы");
+
+        int i1 = 1, i2 = 2; // Сокращение для множественного объявления.
+
+        // Арифметика в Java проста.
+        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 (0.5 округлено)
+
+        // Остаток от деления
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Операторы сравнения.
+        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
+
+        // Побитовые операторы!
+        /*
+        ~       Унарное побитовое дополнение.
+        <<      Знаковый сдвиг влево.
+        >>      Знаковый сдвиг вправо.
+        >>>     Беззнаковый сдвиг вправо.
+        &       Побитовое И.
+        ^       Побитовое исключающее ИЛИ.
+        |       Побитовое ИЛИ.
+        */
+
+        // Операторы инкремента.
+        int i = 0;
+        System.out.println("\n->Inc/Dec-rementation");
+        // Операторы ++ и -- увеличивают и уменьшают значение на 1 соответственно.
+        // Если они находятся перед переменной, сначала происходит
+        // увеличение/уменьшение, затем операция, если после,
+        // то сначала выполняется операция, затем увеличение/уменьшение.
+        System.out.println(i++); //i = 1, напечатает 0 (пост-инкремент)
+        System.out.println(++i); //i = 2, напечатает 2 (пре-инкремент)
+        System.out.println(i--); //i = 1, напечатает 2 (пост-декремент)
+        System.out.println(--i); //i = 0, напечатает 0 (пре-декремент)
+
+        ///////////////////////////////////////
+        // Контролирующие операторы.
+        ///////////////////////////////////////
+        System.out.println("\n->Контролирующие операторы");
+
+        // Оператор if такой же, как и в С.
+        int j = 10;
+        if (j == 10){
+            System.out.println("Я напечатаюсь!");
+        } else if (j > 10) {
+            System.out.println("Я нет.");
+        } else {
+            System.out.println("И я тоже нет.");
+        }
+
+        // Цикл while.
+        int fooWhile = 0;
+        while(fooWhile < 100)
+        {
+            // System.out.println(fooWhile);
+            // Увеличить счетчик.
+            // Будет пройдено 100 итераций, fooWhile 0,1,2...99
+            fooWhile++;
+        }
+        System.out.println("Значение fooWhile: " + fooWhile);
+
+        // Цикл Do While.
+        int fooDoWhile = 0;
+        do
+        {
+            // System.out.println(fooDoWhile);
+            // Увеличить счетчик.
+            // Будет пройдено 100 итераций, fooDoWhile 0->99
+            fooDoWhile++;
+        } while(fooDoWhile < 100);
+        System.out.println("Значение fooDoWhile: " + fooDoWhile);
+
+        // Цикл for.
+        int fooFor;
+        // Структура цикла for => for(<начальное_состояние>; <условие>; <шаг>)
+        for(fooFor=0; fooFor<10; fooFor++){
+            // System.out.println(fooFor);
+            // Пройдет 10 итераций., fooFor 0->9
+        }
+        System.out.println("Значение fooFor: " + fooFor);
+
+        // Цикл For Each
+        // Автоматический проход через массив или список объектов.
+        int[] fooList = {1,2,3,4,5,6,7,8,9};
+        // Структура цикла for each => for(<объект> : <объект_массив>)
+        // читается как: для каждого объекта в массиве
+        // заметка: тип объекта должен совпадать с типом массива.
+
+        for( int bar : fooList ){
+            System.out.println(bar);
+            //Пройдет 9 итераций и напечатает 1-9 на новых строках.
+        }
+
+        // Switch Case
+        // switch работает с типами byte, short, char и int.
+        // Также он работает с перечислениями,
+        // классом String и с некоторыми классами-обертками над
+        // примитивными типами: Character, Byte, Short и Integer.
+        int month = 3;
+        String monthString;
+        switch (month){
+            case 1:
+                    monthString = "Январь";
+                    break;
+            case 2:
+                    monthString = "Февраль";
+                    break;
+            case 3:
+                    monthString = "Март";
+                    break;
+            default:
+                    monthString = "Другой месяц";
+                    break;
+        }
+        System.out.println("Результат Switch Case: " + monthString);
+
+        // Сокращенный синтаксис условного оператора.
+        // Вы можете использовать этот синтаксис для быстрого присвоения
+        // или логических переходов.
+        // Читается так: "Если (условие) истинно, использовать <значение 1>,
+        // в ином случае, использовать <значение 2>"
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println(bar); // Напечатает А, потому что условие истинно
+
+
+        ///////////////////////////////////////
+        // Преобразование и приведение типов данных.
+        ///////////////////////////////////////
+
+        // Преобразование данных.
+
+        // Преобразование строки в число.
+        Integer.parseInt("123"); // Вернет числовое представление "123".
+
+        // Преобразование числа в строку
+        Integer.toString(123); // Вернет строковое представление 123.
+
+        // Для других преобразований смотрите следующие классы:
+        // Double
+        // Long
+        // String
+
+        // Приведение типов
+        // Вы так же можете приводить типы в Java.
+        // Подробнее об этом можно узнать по ссылке:
+        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+        ///////////////////////////////////////
+        // Классы и Функции
+        ///////////////////////////////////////
+
+        System.out.println("\n->Классы и Функции");
+
+        // (Класс Bicycle определен ниже)
+
+        // Для создания экземпляра класса используется new.
+        Bicycle trek = new Bicycle();
+
+        // Вызов методов объекта.
+        trek.speedUp(3); // Вы должны всегда использовать сеттеры и геттеры.
+        trek.setCadence(100);
+
+        // toString возвращает строковое представление объекта.
+        System.out.println("trek info: " + trek.toString());
+
+    } // Конец метода main.
+} // Конец класса LearnJava.
+
+
+// Вы можете включать другие, не публичные классы в .java файл.
+
+
+// Синтаксис объявления класса:
+// <public/private/protected> class <имя класса>{
+//    // Поля с данными, конструкторы, функции, все внутри.
+//    // Функции называют методами в Java.
+// }
+
+class Bicycle {
+
+    // Поля/Переменные класса Bicycle.
+    public int cadence;// Публичные(public): Доступны из любого места.
+    private int speed; // Приватные(private): Доступны только внутри класса.
+    protected int gear;// Защищенные(protected): Доступ из класса и наследников.
+    String name; // по умолчанию: Доступны только внутри пакета.
+
+    // Конструкторы - способ создания класса.
+    // Это конструктор:
+    public Bicycle() {
+        gear = 1;
+        cadence = 50;
+        speed = 5;
+        name = "Bontrager";
+    }
+
+    // Это конструктор, который принимает аргументы:
+    public Bicycle(int startCadence, int startSpeed, int startGear, String name) {
+        this.gear = startGear;
+        this.cadence = startCadence;
+        this.speed = startSpeed;
+        this.name = name;
+    }
+
+    // Синтаксис функций:
+    // <public/private/protected> <тип возвращаемого значения> <имя>(<аргументы>)
+
+    // Классы в Java часто реализуют сеттеры и геттеры для своих полей.
+
+    // Синтаксис определения метода:
+    // <модификатор> <тип возвращаемого значения> <имя>(<аргументы>)
+    public int getCadence() {
+        return cadence;
+    }
+
+    // void-методы не возвращают значений.
+    public void setCadence(int newValue) {
+        cadence = newValue;
+    }
+
+    public void setGear(int newValue) {
+        gear = newValue;
+    }
+
+    public void speedUp(int increment) {
+        speed += increment;
+    }
+
+    public void slowDown(int decrement) {
+        speed -= decrement;
+    }
+
+    public void setName(String newName) {
+        name = newName;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    //Метод для отображения значений атрибутов объекта.
+    @Override
+    public String toString() {
+        return "gear: " + gear +
+                " cadence: " + cadence +
+                " speed: " + speed +
+                " name: " + name;
+    }
+} // конец класса Bicycle.
+
+// PennyFarthing - это класс, наследованный от Bicycle
+class PennyFarthing extends Bicycle {
+    // (Penny Farthings - это такие велосипеды с большим передним колесом,
+    // у них нет передач.)
+
+    public PennyFarthing(int startCadence, int startSpeed){
+        // Вызов конструктора родительского класса.
+        super(startCadence, startSpeed, 0, "PennyFarthing");
+    }
+
+    // Вы должны пометить метод, который переопределяете, при помощи @аннотации
+    // Чтобы узнать о том, что такое аннотации и зачем они нужны, почитайте:
+    // http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setGear(int gear) {
+        gear = 0;
+    }
+
+}
+
+// Интерфейсы
+// Синтаксис определения интерфейса: 
+// <модификатор доступа> interface <имя> extends <базовый интерфейс> {
+//        // Константы
+//        // Определение методов.
+//}
+
+// Пример - Еда:
+public interface Edible {
+    // Любой класс, реализующий этот интерфейс, должен реализовать этот метод.
+    public void eat();
+}
+
+public interface Digestible {
+    public void digest();
+}
+
+
+// Сейчас мы можем создать класс, реализующий оба эти интерфейса.
+public class Fruit implements Edible, Digestible {
+    public void eat() {
+        //...
+    }
+
+    public void digest() {
+        //... 
+    }
+}
+
+// В Java Вы можете наследоватьтолько один класс, однако можете реализовывать
+// несколько интерфейсов. Например:
+public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo {
+    public void InterfaceOneMethod() {
+
+    }
+
+    public void InterfaceTwoMethod() {
+
+    }
+}
+
+```
+
+## Почитать еще
+
+Здесь приведены ссылки только для того, чтобы получить общее представление о Java. Гуглите, чтобы найти какие-либо конкретные примеры.
+
+**Официальные руководства Oracle**:
+
+* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+
+* [Модификаторы доступа в Java](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Концепции объектно-ориентированного программирования](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Наследование](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Полиморфизм](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Абстракция](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Исключения](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Интерфейсы](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/codeconv-138413.html)
+
+**Уроки онлайн**
+
+* [Learneroo.com - Изучение Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+
+**Книги**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [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/ru-ru/javascript-ru.html.markdown b/ru-ru/javascript-ru.html.markdown
new file mode 100644
index 00000000..8655ae4a
--- /dev/null
+++ b/ru-ru/javascript-ru.html.markdown
@@ -0,0 +1,513 @@
+---
+language: javascript
+contributors:
+    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Ariel Krakowski", "http://www.learneroo.com"]
+filename: javascript-ru.js
+translators:
+  - ["Alexey Gonchar", "http://github.com/finico"]
+  - ["Andre Polykanine", "https://github.com/Oire"]
+lang: ru-ru
+---
+
+JavaScript был создан в 1995 году Бренданом Айком, работавшим в компании Netscape.
+Изначально он был задуман как простой язык сценариев для веб-сайтов, дополняющий
+Java для более сложных веб-приложений, но его тесная интеграция с веб-страницами
+и встроенная поддержка браузерами привели к тому, что он стал более распространённым,
+чем Java в веб-интерфейсах.
+
+JavaScript не ограничивается только веб-браузером: например, Node.js, программная
+платформа, позволяющая выполнять JavaScript, основанная на движке V8 от браузера
+Google Chrome, становится все более популярной.
+
+```js
+// Си-подобные комментарии. Однострочные комментарии начинаются с двух символов слэш,
+/* а многострочные комментарии начинаются с последовательности слэш-звёздочка
+   и заканчиваются символами звёздочка-слэш */
+
+// Инструкции могут заканчиваться точкой с запятой ;
+doStuff();
+
+// ... но она необязательна, так как точки с запятой автоматически вставляются
+// везде, где есть символ новой строки, за некоторыми исключениями.
+doStuff()
+
+// Так как эти исключения могут привести к неожиданным результатам, мы будем всегда
+// использовать точку с запятой в этом руководстве.
+
+///////////////////////////////////
+// 1. Числа, Строки и Операторы
+
+// В JavaScript только один тип числа (64-bit IEEE 754 double).
+// Он имеет 52-битную мантиссу, которой достаточно для хранения целых чисел
+// с точностью вплоть до 9✕10¹⁵.
+3; // = 3
+1.5; // = 1.5
+
+// Некоторые простые арифметические операции работают так, как вы ожидаете.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004 (а некоторые - нет)
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Включая деление с остатком.
+5 / 2; // = 2.5
+
+// Побитовые операции также имеются; когда вы проводите такую операцию,
+// ваше число с плавающей запятой переводится в целое со знаком 
+// длиной *до* 32 разрядов.
+1 << 2; // = 4
+
+// Приоритет в выражениях можно явно задать скобками.
+(1 + 3) * 2; // = 8
+
+// Есть три специальных значения, которые не являются реальными числами:
+Infinity; // "бесконечность", например, результат деления на 0
+-Infinity; // "минус бесконечность", результат деления отрицательного числа на 0
+NaN; // "не число", например, результат деления 0/0
+
+// Существует также логический тип.
+true;
+false;
+
+// Строки создаются при помощи двойных или одинарных кавычек.
+'абв';
+"Привет, мир!";
+
+// Для логического отрицания используется восклицательный знак.
+!true; // = false
+!false; // = true
+
+// Строгое равенство ===
+1 === 1; // = true
+2 === 1; // = false
+
+// Строгое неравенство !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Другие операторы сравнения
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Строки объединяются при помощи оператора +
+"привет, " + "мир!"; // = "Привет, мир!"
+
+// и сравниваются при помощи < и >
+"a" < "b"; // = true
+
+// Проверка равенства с приведением типов осуществляется двойным символом равно
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...если только не использовать ===
+"5" === 5; // = false
+null === undefined; // = false 
+
+// ...приведение типов может привести к странному поведению...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// Вы можете получить доступ к любому символу строки, используя метод charAt
+"Это строка".charAt(0);  // = 'Э'
+
+// ...или используйте метод substring, чтобы получить более крупные части
+"Привет, мир".substring(0, 6); // = "Привет"
+
+// length - это свойство, для его получения не нужно использовать ()
+"Привет".length; // = 6
+
+// Также есть null и undefined
+null; // Намеренное отсутствие значения
+undefined; // используется для обозначения переменных, не имеющих
+           // присвоенного значения (хотя непосредственно undefined
+           // является значением)
+
+// false, null, undefined, NaN, 0 и "" — это ложь; всё остальное - истина.
+// Следует отметить, что 0 — это ложь, а "0" — истина, несмотря на то, что
+// 0 == "0".
+
+///////////////////////////////////
+// 2. Переменные, Массивы и Объекты
+
+// Переменные объявляются при помощи ключевого слова var. JavaScript — язык с
+// динамической типизацией, поэтому не нужно явно указывать тип. Для присваивания
+// значения переменной используется символ =
+var someVar = 5;
+
+// если вы пропустите слово var, вы не получите сообщение об ошибке, ...
+someOtherVar = 10;
+
+// ...но ваша переменная будет создана в глобальном контексте, а не в текущем,
+// где вы ее объявили.
+
+// Переменным, объявленным без присвоения, устанавливается значение undefined.
+var someThirdVar; // = undefined
+
+// У математических операций есть сокращённые формы:
+someVar += 5; // как someVar = someVar + 5; someVar теперь имеет значение 10
+someVar *= 10; // теперь someVar имеет значение 100
+
+// Ещё более краткая запись увеличения и уменьшения на единицу:
+someVar++; // теперь someVar имеет значение 101
+someVar--; // вернулись к 100
+
+// Массивы — это нумерованные списки, содержащие значения любого типа.
+var myArray = ["Привет", 45, true];
+
+// Их элементы могут быть доступны при помощи синтаксиса с квадратными скобками.
+// Индексы массивов начинаются с нуля.
+myArray[1]; // = 45
+
+// Массивы можно изменять, как и их длину,
+myArray.push("Мир");
+myArray.length; // = 4
+
+// добавлять и редактировать определённый элемент
+myArray[3] = "Привет";
+
+// Объекты в JavaScript похожи на словари или ассоциативные массивы в других
+// языках: неупорядоченный набор пар ключ-значение.
+var myObj = {key1: "Привет", key2: "Мир"};
+
+// Ключи — это строки, но кавычки необязательны, если строка удовлетворяет
+// ограничениям для имён переменных. Значения могут быть любых типов.
+var myObj = {myKey: "myValue", "my other key": 4};
+
+// Атрибуты объектов можно также получить, используя квадратные скобки
+myObj["my other key"]; // = 4
+
+// или через точку, при условии, что ключ является допустимым идентификатором.
+myObj.myKey; // = "myValue"
+
+// Объекты изменяемы; можно изменять значения и добавлять новые ключи.
+myObj.myThirdKey = true;
+
+// Если вы попытаетесь получить доступ к несуществующему значению,
+// вы получите undefined.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Логика и управляющие конструкции.
+
+// Синтаксис для этого раздела почти такой же, как в Java.
+
+// Условная конструкция работает, как и следовало ожидать,
+var count = 1;
+if (count == 3) {
+    // выполняется, если count равен 3
+} else if (count == 4) {
+    // выполняется, если count равен 4
+} else {
+    // выполняется, если не 3 и не 4
+}
+
+// ...как и цикл while.
+while (true){
+    // Бесконечный цикл!
+}
+
+// Цикл do-while такой же, как while, но он всегда выполняется хотя бы раз.
+var input
+do {
+    input = getInput();
+} while (!isValid(input))
+
+// цикл for такой же, как в C и Java:
+// инициализация; условие; шаг.
+for (var i = 0; i < 5; i++) {
+    // выполнится 5 раз
+}
+
+// && — это логическое И, || — это логическое ИЛИ
+if (house.size == "big" && house.color == "blue") {
+    house.contains = "bear";
+}
+if (color == "red" || color == "blue") {
+    // цвет красный или синий
+}
+
+// && и || используют сокращённое вычисление, что полезно
+// для задания значений по умолчанию.
+var name = otherName || "default";
+
+// Оператор switch выполняет проверку на равенство при помощи ===
+// используйте break, чтобы прервать выполнение после каждого case, 
+// или выполнение пойдёт далее даже после правильного варианта. 
+grade = 4;
+switch (grade) {
+  case 5:
+    console.log("Отлично");
+    break;
+  case 4:
+    console.log("Хорошо");
+    break;
+  case 3:
+    console.log("Можете и лучше");
+    break;
+  default:
+    console.log("Ой-вей!");
+    break;
+}
+
+
+///////////////////////////////////
+// 4. Функции, Область видимости и Замыкания
+
+// Функции в  JavaScript объявляются при помощи ключевого слова function.
+function myFunction(thing) {
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+// Обратите внимание, что значение, которое будет возвращено, должно начинаться
+// на той же строке, что и ключевое слово return, в противном случае вы будете
+// всегда возвращать undefined по причине автоматической вставки точки с запятой.
+// Следите за этим при использовании стиля форматирования Allman.
+function myFunction()
+{
+    return // <- здесь точка с запятой вставится автоматически
+    {
+        thisIsAn: 'object literal'
+    }
+}
+myFunction(); // = undefined
+
+// В JavaScript функции — это объекты первого класса, поэтому они могут быть
+// присвоены различным именам переменных и передаваться другим функциям 
+// в качестве аргументов, например, когда назначается обработчик события:
+function myFunction() {
+    // этот код будет вызван через 5 секунд
+}
+setTimeout(myFunction, 5000);
+// Примечание: setTimeout не является частью языка, но реализован в браузерах и Node.js
+
+// Функции не обязательно должны иметь имя при объявлении — вы можете написать
+// анонимное определение функции непосредственно в аргументе другой функции.
+setTimeout(function() {
+    // этот код будет вызван через 5 секунд
+}, 5000);
+
+// В JavaScript есть область видимости; функции имеют свою область
+// видимости, а другие блоки — нет.
+if (true) {
+    var i = 5;
+}
+i; // = 5, а не undefined, как ожидалось бы в языках с блочной областью видимости
+
+// Это привело к общепринятому шаблону "самозапускающихся анонимных функций",
+// которые препятствуют проникновению переменных в глобальную область видимости
+(function() {
+    var temporary = 5;
+    // Мы можем получить доступ к глобальной области для записи в «глобальный объект»,
+    // который в веб-браузере всегда window. Глобальный объект может иметь другое
+    // имя в таких платформах, как Node.js
+    window.permanent = 10;
+})();
+temporary; // вызовет сообщение об ошибке с типом ReferenceError
+permanent; // = 10
+
+// Одной из самых мощных возможностей JavaScript являются замыкания. Если функция
+// определена внутри другой функции, то внутренняя функция имеет доступ к 
+// переменным внешней функции даже после того, как контекст выполнения выйдет из
+// внешней функции.
+function sayHelloInFiveSeconds(name) {
+    var prompt = "Привет, " + name + "!";
+    // Внутренние функции по умолчанию помещаются в локальную область видимости,
+    // как если бы они были объявлены с помощью var.
+    function inner() {
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // setTimeout асинхронна, поэтому функция sayHelloInFiveSeconds сразу выйдет,
+    // после чего setTimeout вызовет функцию inner. Однако поскольку функция inner
+    // «замкнута» вокруг sayHelloInFiveSeconds, она по-прежнему имеет доступ к переменной prompt
+    // на то время, когда она наконец будет вызвана.
+}
+sayHelloInFiveSeconds("Адам"); // Через 5 с откроется окно «Привет, Адам!»
+
+///////////////////////////////////
+// 5. Подробнее об объектах; конструкторы и прототипы
+
+// Объекты могут содержать в себе функции.
+var myObj = {
+    myFunc: function() {
+        return "Привет, мир!";
+    }
+};
+myObj.myFunc(); // = "Привет, мир!"
+
+// Когда вызываются функции, прикреплённые к объекту, они могут получить доступ
+// к этому объекту с помощью ключевого слова this.
+myObj = {
+    myString: "Привет, мир!",
+    myFunc: function() {
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Привет, мир!"
+
+// Значение this зависит от того, как функция вызывается, 
+// а не от того, где она определена. Таким образом, наша функция не работает, 
+// если она вызывается не в контексте объекта.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// И наоборот, функция может быть присвоена объекту и получать доступ к нему
+// через this, даже если она не была прикреплена к нему при объявлении.
+var myOtherFunc = function() {
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "ПРИВЕТ, МИР!"
+
+// Мы можем также указать контекст для выполнения функции при её вызове,
+// используя call или apply.
+var anotherFunc = function(s) {
+    return this.myString + s;
+}
+anotherFunc.call(myObj, " И привет, Луна!"); // = "Привет, мир! И привет, Луна!"
+
+// Функция apply почти такая же, но принимает в качестве списка аргументов массив.
+anotherFunc.apply(myObj, [" И привет, Солнце!"]); // = "Привет, мир! И привет, Солнце!"
+
+// Это полезно при работе с функцией, которая принимает последовательность
+// аргументов, а вы хотите передать массив.
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (Ой-ой!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Но call и apply — только временные. Когда мы хотим связать функцию с объектом, 
+// мы можем использовать bind.
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" И привет, Сатурн!"); // = "Привет, мир! И привет, Сатурн!"
+
+// Bind также может использоваться для частичного применения (каррирования) функции
+var product = function(a, b) { return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Когда вы вызываете функцию с помощью ключевого слова new, создается новый объект,
+// доступный функции при помощи this. Такие функции называют конструкторами.
+var MyConstructor = function() {
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// У каждого объекта в JavaScript есть прототип. Когда вы хотите получить
+// доступ к свойству объекта, которое не существует в этом объекте, интерпретатор
+// будет искать это свойство в прототипе.
+
+// Некоторые реализации языка позволяют получить доступ к прототипу объекта
+// через «магическое» свойство __proto__. Несмотря на то, что это может быть полезно
+// для понимания прототипов, это не часть стандарта; мы увидим стандартные способы
+// использования прототипов позже.
+var myObj = {
+    myString: "Привет, мир!"
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function() {
+        return this.myString.toLowerCase()
+    }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// Для функций это тоже работает.
+myObj.myFunc(); // = "Привет, мир!"
+
+// Если интерпретатор не найдёт свойство в прототипе, то продожит поиск
+// в прототипе прототипа и так далее.
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Здесь не участвует копирование; каждый объект хранит ссылку на свой прототип.
+// Это означает, что мы можем изменить прототип, и наши изменения будут отражены везде.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+// Мы упомянули, что свойство __proto__ нестандартно, и нет никакого стандартного
+// способа, чтобы изменить прототип существующего объекта. Однако есть два
+// способа создать новый объект с заданным прототипом.
+
+// Первый способ — это Object.create, который появился в JavaScript недавно,
+// а потому доступен ещё не во всех реализациях языка.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// Второй способ, который работает везде, имеет дело с конструкторами.
+// У конструкторов есть свойство с именем prototype. Это *не* прототип
+// функции-конструктора; напротив, это прототип для новых объектов, которые
+// будут созданы с помощью этого конструктора и ключевого слова new.
+MyConstructor.prototype = {
+    myNumber: 5,
+    getMyNumber: function() {
+        return this.myNumber;
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6
+myNewObj2.getMyNumber(); // = 6
+
+// У встроенных типов, таких, как строки и числа, также есть конструкторы, которые
+// создают эквивалентные объекты-обёртки.
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// За исключением того, что они не в точности равны.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0) {
+    // Этот код не выполнится, потому что 0 - это ложь.
+}
+
+// Впрочем, объекты-обёртки и встроенные типы имеют общие прототипы,
+// поэтому вы можете расширить функционал строк, например:
+String.prototype.firstCharacter = function() {
+    return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// Это часто используется в т.н. полифилах, которые реализуют новые возможности
+// JavaScript в старой реализации языка, так что они могут быть использованы в
+// старых средах, таких, как устаревшие браузеры.
+
+// Например, мы упомянули, что Object.create доступен не во всех реализациях, но
+// мы сможем использовать его с помощью такого полифила:
+if (Object.create === undefined) { // не перезаписываем метод, если он существует
+    Object.create = function(proto) {
+        // создаём временный конструктор с правильным прототипом
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // затем используем его для создания нового,
+        // правильно прототипированного объекта
+        return new Constructor();
+    }
+}
+```
+
+## Что ещё почитать
+
+[Современный учебник JavaScript (Илья Кантор)](http://learn.javascript.ru) — 
+качественный учебник по JavaScript на русском языке.
+
+[Mozilla Developer Network](https://developer.mozilla.org/ru/docs/Web/JavaScript) —
+предоставляет отличную документацию для JavaScript, как он используется в браузерах.
+Кроме того, это вики, поэтому, если вы знаете больше, вы можете помочь другим,
+делясь своими знаниями.
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/ru/) — это
+подробное руководство по всем неинтуитивным особенностей языка.
+
+[Stack Overflow](http://stackoverflow.com/questions/tagged/javascript) — можно
+найти ответ почти на любой ваш вопрос, а если его нет, то задать вопрос самому.
diff --git a/ru-ru/json-ru.html.markdown b/ru-ru/json-ru.html.markdown
new file mode 100644
index 00000000..52af3696
--- /dev/null
+++ b/ru-ru/json-ru.html.markdown
@@ -0,0 +1,61 @@
+---
+language: json
+filename: learnjson-ru.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+  - ["Dmitry Bessonov", "https://github.com/TheDmitry"]
+lang: ru-ru
+---
+
+JSON - это очень простой формат обмена данными, и это будет самый легкий
+курс из когда-либо представленных "Learn X in Y Minutes".
+
+В чистом виде у JSON нет фактических комментариев, но большинство парсеров примут
+комментарии в Си-стиле (//, /\* \*/). Для таких целей, конечно, все правильно
+будет на 100% с точки зрения JSON. К счастью, в нашем случае данные скажут сами за себя.
+
+```json
+{
+  "ключ": "значение",
+  
+  "ключи": "должны всегда заключаться в двойные кавычки",
+  "числа": 0,
+  "строки": "Пρивет, миρ. Допускаются все unicode-символы вместе с \"экранированием\".",
+  "содержит логический тип?": true,
+  "ничего": null,
+
+  "большое число": 1.2e+100,
+
+  "объекты": {
+    "комментарий": "Большинство ваших структур будут представлять из себя объекты.",
+
+    "массив": [0, 1, 2, 3, "Массивы могут содержать в себе любой тип.", 5],
+
+    "другой объект": {
+      "комментарий": "Они могут быть вложенными, и это очень полезно."
+    }
+  },
+
+  "бессмыслие": [
+    {
+      "источники калия": ["бананы"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "нео"],
+      [0, 0, 0, 1]
+    ]
+  ],
+  
+  "альтернативный стиль": {
+    "комментарий": "проверьте это!"
+  , "позиция запятой": "неважна, хоть и перед значением, все равно правильно"
+  , "еще один комментарий": "как хорошо"
+  },
+
+  "это было недолго": "И вы справились. Теперь вы знаете все о JSON."
+}
+```
diff --git a/ru-ru/julia-ru.html.markdown b/ru-ru/julia-ru.html.markdown
new file mode 100644
index 00000000..29392604
--- /dev/null
+++ b/ru-ru/julia-ru.html.markdown
@@ -0,0 +1,750 @@
+---
+language: Julia
+contributors:
+    - ["Leah Hanson", "http://leahhanson.us"]
+translators:
+    - ["Sergey Skovorodkin", "https://github.com/skovorodkin"]
+filename: learnjulia-ru.jl
+lang: ru-ru
+---
+
+Julia — гомоиконный функциональный язык программирования для технических расчётов.
+Несмотря на полную поддержку гомоиконных макросов, функций первого класса и конструкций управления низкого уровня, этот язык так же прост в изучении и применении, как и Python.
+
+Документ описывает текущую dev-версию Julia от 18-о октября 2013 года.
+
+```ruby
+
+# Однострочные комментарии начинаются со знака решётки.
+
+####################################################
+## 1. Примитивные типы данных и операторы
+####################################################
+
+# Всё в Julia — выражение.
+
+# Простые численные типы
+3 # => 3 (Int64)
+3.2 # => 3.2 (Float64)
+2 + 1im # => 2 + 1im (Complex{Int64})
+2//3 # => 2//3 (Rational{Int64})
+
+# Доступны все привычные инфиксные операторы
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+35 / 5 # => 7.0
+5 / 2 # => 2.5 # деление Int на Int всегда возвращает Float
+div(5, 2) # => 2 # для округления к нулю используется div
+5 \ 35 # => 7.0
+2 ^ 2 # => 4 # возведение в степень
+12 % 10 # => 2
+
+# С помощью скобок можно изменить приоритет операций
+(1 + 3) * 2 # => 8
+
+# Побитовые операторы
+~2 # => -3   # НЕ (NOT)
+3 & 5 # => 1 # И (AND)
+2 | 4 # => 6 # ИЛИ (OR)
+2 $ 4 # => 6 # сложение по модулю 2 (XOR)
+2 >>> 1 # => 1 # логический сдвиг вправо
+2 >> 1  # => 1 # арифметический сдвиг вправо
+2 << 1  # => 4 # логический/арифметический сдвиг влево
+
+# Функция bits возвращает бинарное представление числа
+bits(12345)
+# => "0000000000000000000000000000000000000000000000000011000000111001"
+bits(12345.0)
+# => "0100000011001000000111001000000000000000000000000000000000000000"
+
+# Логические значения являются примитивами
+true
+false
+
+# Булевы операторы
+!true # => false
+!false # => true
+1 == 1 # => true
+2 == 1 # => false
+1 != 1 # => false
+2 != 1 # => true
+1 < 10 # => true
+1 > 10 # => false
+2 <= 2 # => true
+2 >= 2 # => true
+# Сравнения можно объединять цепочкой
+1 < 2 < 3 # => true
+2 < 3 < 2 # => false
+
+# Строки объявляются с помощью двойных кавычек — "
+"This is a string."
+
+# Символьные литералы создаются с помощью одинарных кавычек — '
+'a'
+
+# Строки индексируются как массивы символов
+"This is a string"[1] # => 'T' # Индексы начинаются с единицы
+# Индексирование не всегда правильно работает для UTF8-строк,
+# поэтому рекомендуется использовать итерирование (map, for-циклы и т.п.).
+
+# Для строковой интерполяции используется знак доллара ($):
+"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
+# В скобках можно использовать любое выражение языка.
+
+# Другой способ форматирования строк — макрос printf
+@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000
+
+####################################################
+## 2. Переменные и коллекции
+####################################################
+
+# Вывод
+println("I'm Julia. Nice to meet you!")
+
+# Переменные инициализируются без предварительного объявления
+some_var = 5 # => 5
+some_var # => 5
+
+# Попытка доступа к переменной до инициализации вызывает ошибку
+try
+    some_other_var # => ERROR: some_other_var not defined
+catch e
+    println(e)
+end
+
+# Имена переменных начинаются с букв.
+# После первого символа можно использовать буквы, цифры, 
+# символы подчёркивания и восклицательные знаки.
+SomeOtherVar123! = 6 # => 6
+
+# Допустимо использование unicode-символов
+☃ = 8 # => 8
+# Это особенно удобно для математических обозначений
+2 * π # => 6.283185307179586
+
+# Рекомендации по именованию:
+# * имена переменных в нижнем регистре, слова разделяются символом 
+#   подчёркивания ('\_');
+#
+# * для имён типов используется CamelCase;
+#
+# * имена функций и макросов в нижнем регистре
+#   без разделения слов символом подчёркивания;
+#
+# * имя функции, изменяющей переданные ей аргументы (in-place function),
+#   оканчивается восклицательным знаком.
+
+# Массив хранит последовательность значений, индексируемых с единицы до n:
+a = Int64[] # => пустой массив Int64-элементов
+
+# Одномерный массив объявляется разделёнными запятой значениями.
+b = [4, 5, 6] # => массив из трёх Int64-элементов: [4, 5, 6]
+b[1] # => 4
+b[end] # => 6
+
+# Строки двумерного массива разделяются точкой с запятой.
+# Элементы строк разделяются пробелами.
+matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
+
+# push! и append! добавляют в список новые элементы
+push!(a,1)     # => [1]
+push!(a,2)     # => [1,2]
+push!(a,4)     # => [1,2,4]
+push!(a,3)     # => [1,2,4,3]
+append!(a,b) # => [1,2,4,3,4,5,6]
+
+# pop! удаляет из списка последний элемент
+pop!(b)        # => возвращает 6; массив b снова равен [4,5]
+
+# Вернём 6 обратно
+push!(b,6)   # b снова [4,5,6].
+
+a[1] # => 1 # индексы начинаются с единицы!
+
+# Последний элемент можно получить с помощью end
+a[end] # => 6
+
+# Операции сдвига
+shift!(a) # => 1 and a is now [2,4,3,4,5,6]
+unshift!(a,7) # => [7,2,4,3,4,5,6]
+
+# Восклицательный знак на конце названия функции означает,
+# что функция изменяет переданные ей аргументы.
+arr = [5,4,6] # => массив из 3 Int64-элементов: [5,4,6]
+sort(arr) # => [4,5,6]; но arr равен [5,4,6]
+sort!(arr) # => [4,5,6]; а теперь arr — [4,5,6]
+
+# Попытка доступа за пределами массива выбрасывает BoundsError
+try
+    a[0] # => ERROR: BoundsError() in getindex at array.jl:270
+    a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270
+catch e
+    println(e)
+end
+
+# Вывод ошибок содержит строку и файл, где произошла ошибка,
+# даже если это случилось в стандартной библиотеке.
+# Если вы собрали Julia из исходных кодов, 
+# то найти эти файлы можно в директории base.
+
+# Создавать массивы можно из последовательности
+a = [1:5] # => массив из 5 Int64-элементов: [1,2,3,4,5]
+
+# Срезы
+a[1:3] # => [1, 2, 3]
+a[2:] # => [2, 3, 4, 5]
+a[2:end] # => [2, 3, 4, 5]
+
+# splice! удаляет элемент из массива
+# Remove elements from an array by index with splice!
+arr = [3,4,5]
+splice!(arr,2) # => 4 ; arr теперь равен [3,5]
+
+# append! объединяет списки
+b = [1,2,3]
+append!(a,b) # теперь a равен [1, 2, 3, 4, 5, 1, 2, 3]
+
+# Проверка на вхождение
+in(1, a) # => true
+
+# Длина списка
+length(a) # => 8
+
+# Кортеж — неизменяемая структура.
+tup = (1, 2, 3) # => (1,2,3) # кортеж (Int64,Int64,Int64).
+tup[1] # => 1
+try:
+    tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
+catch e
+    println(e)
+end
+
+# Многие функции над списками работают и для кортежей
+length(tup) # => 3
+tup[1:2] # => (1,2)
+in(2, tup) # => true
+
+# Кортежи можно распаковывать в переменные
+a, b, c = (1, 2, 3) # => (1,2,3)  # a = 1, b = 2 и c = 3
+
+# Скобки из предыдущего примера можно опустить
+d, e, f = 4, 5, 6 # => (4,5,6)
+
+# Кортеж из одного элемента не равен значению этого элемента
+(1,) == 1 # => false
+(1) == 1 # => true
+
+# Обмен значений
+e, d = d, e  # => (5,4) # d = 5, e = 4
+
+
+# Словари содержат ассоциативные массивы
+empty_dict = Dict() # => Dict{Any,Any}()
+
+# Для создания словаря можно использовать литерал
+filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
+# => Dict{ASCIIString,Int64}
+
+# Значения ищутся по ключу с помощью оператора []
+filled_dict["one"] # => 1
+
+# Получить все ключи
+keys(filled_dict)
+# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# Заметьте, словарь не запоминает порядок, в котором добавляются ключи.
+
+# Получить все значения.
+values(filled_dict)
+# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# То же касается и порядка значений.
+
+# Проверка вхождения ключа в словарь
+in(("one", 1), filled_dict) # => true
+in(("two", 3), filled_dict) # => false
+haskey(filled_dict, "one") # => true
+haskey(filled_dict, 1) # => false
+
+# Попытка обратиться к несуществующему ключу выбросит ошибку
+try
+    filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
+catch e
+    println(e)
+end
+
+# Используйте метод get со значением по умолчанию, чтобы избежать этой ошибки
+# get(dictionary,key,default_value)
+get(filled_dict,"one",4) # => 1
+get(filled_dict,"four",4) # => 4
+
+# Для коллекций неотсортированных уникальных элементов используйте Set
+empty_set = Set() # => Set{Any}()
+# Инициализация множества
+filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+
+# Добавление элементов
+push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
+
+# Проверка вхождения элементов во множество
+in(2, filled_set) # => true
+in(10, filled_set) # => false
+
+# Функции для получения пересечения, объединения и разницы.
+other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
+intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
+union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
+setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
+
+
+####################################################
+## 3. Поток управления
+####################################################
+
+# Создадим переменную
+some_var = 5
+
+# Выражение if. Отступы не имеют значения.
+if some_var > 10
+    println("some_var is totally bigger than 10.")
+elseif some_var < 10    # Необязательная ветка elseif.
+    println("some_var is smaller than 10.")
+else                    # else-ветка также опциональна.
+    println("some_var is indeed 10.")
+end
+# => prints "some var is smaller than 10"
+
+
+# Цикл for проходит по итерируемым объектам
+# Примеры итерируемых типов: Range, Array, Set, Dict и String.
+for animal=["dog", "cat", "mouse"]
+    println("$animal is a mammal")
+    # Для вставки значения переменной или выражения в строку используется $
+end
+# Выведет:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+# Другой вариант записи.
+for animal in ["dog", "cat", "mouse"]
+    println("$animal is a mammal")
+end
+# Выведет:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+    println("$(a[1]) is a $(a[2])")
+end
+# Выведет:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+    println("$k is a $v")
+end
+# Выведет:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+# Цикл while выполняется до тех пор, пока верно условие
+x = 0
+while x < 4
+    println(x)
+    x += 1  # Короткая запись x = x + 1
+end
+# Выведет:
+#   0
+#   1
+#   2
+#   3
+
+# Обработка исключений
+try
+   error("help")
+catch e
+   println("caught it $e")
+end
+# => caught it ErrorException("help")
+
+
+####################################################
+## 4. Функции
+####################################################
+
+# Для определения новой функции используется ключевое слово 'function'
+#function имя(аргументы)
+#  тело...
+#end
+function add(x, y)
+    println("x is $x and y is $y")
+
+    # Функция возвращает значение последнего выражения
+    x + y
+end
+
+add(5, 6) # => Вернёт 11, напечатав "x is 5 and y is 6"
+
+# Функция может принимать переменное количество позиционных аргументов.
+function varargs(args...)
+    return args
+    # для возвращения из функции в любом месте используется 'return'
+end
+# => varargs (generic function with 1 method)
+
+varargs(1,2,3) # => (1,2,3)
+
+# Многоточие (...) — это splat.
+# Мы только что воспользовались им в определении функции.
+# Также его можно использовать при вызове функции,
+# где он преобразует содержимое массива или кортежа в список аргументов.
+Set([1,2,3])    # => Set{Array{Int64,1}}([1,2,3]) # формирует множество массивов
+Set([1,2,3]...) # => Set{Int64}(1,2,3) # эквивалентно Set(1,2,3)
+
+x = (1,2,3)     # => (1,2,3)
+Set(x)          # => Set{(Int64,Int64,Int64)}((1,2,3)) # множество кортежей
+Set(x...)       # => Set{Int64}(2,3,1)
+
+
+# Опциональные позиционные аргументы
+function defaults(a,b,x=5,y=6)
+    return "$a $b and $x $y"
+end
+
+defaults('h','g') # => "h g and 5 6"
+defaults('h','g','j') # => "h g and j 6"
+defaults('h','g','j','k') # => "h g and j k"
+try
+    defaults('h') # => ERROR: no method defaults(Char,)
+    defaults() # => ERROR: no methods defaults()
+catch e
+    println(e)
+end
+
+# Именованные аргументы
+function keyword_args(;k1=4,name2="hello") # обратите внимание на ;
+    return ["k1"=>k1,"name2"=>name2]
+end
+
+keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
+keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"]
+keyword_args() # => ["name2"=>"hello","k2"=>4]
+
+# В одной функции можно совмещать все виды аргументов
+function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
+    println("normal arg: $normal_arg")
+    println("optional arg: $optional_positional_arg")
+    println("keyword arg: $keyword_arg")
+end
+
+all_the_args(1, 3, keyword_arg=4)
+# Выведет:
+#   normal arg: 1
+#   optional arg: 3
+#   keyword arg: 4
+
+# Функции в Julia первого класса 
+function create_adder(x)
+    adder = function (y)
+        return x + y
+    end
+    return adder
+end
+
+# Анонимная функция
+(x -> x > 2)(3) # => true
+
+# Эта функция идентичная предыдущей версии create_adder
+function create_adder(x)
+    y -> x + y
+end
+
+# Если есть желание, можно воспользоваться полным вариантом
+function create_adder(x)
+    function adder(y)
+        x + y
+    end
+    adder
+end
+
+add_10 = create_adder(10)
+add_10(3) # => 13
+
+
+# Встроенные функции высшего порядка
+map(add_10, [1,2,3]) # => [11, 12, 13]
+filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+
+# Списковые сборки
+[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
+[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+
+####################################################
+## 5. Типы
+####################################################
+
+# Julia has a type system.
+# Каждое значение имеет тип, но переменные не определяют тип значения.
+# Функция `typeof` возвращает тип значения.
+typeof(5) # => Int64
+
+# Types are first-class values
+# Типы являются значениями первого класса
+typeof(Int64) # => DataType
+typeof(DataType) # => DataType
+# Тип DataType представляет типы, включая себя самого.
+
+# Типы используются в качестве документации, для оптимизации и организации.
+# Статически типы не проверяются.
+
+# Пользователь может определять свои типы
+# Типы похожи на структуры в других языках
+# Новые типы определяются с помощью ключевого слова `type`
+
+# type Name
+#   field::OptionalType
+#   ...
+# end
+type Tiger
+  taillength::Float64
+  coatcolor # отсутствие типа равносильно `::Any`
+end
+
+# Аргументы конструктора по умолчанию — свойства типа
+# в порядке их определения.
+tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange")
+
+# Тип объекта по сути является конструктором значений такого типа
+sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")
+
+# Эти типы, похожие на структуры, называются конкретными.
+# Можно создавать объекты таких типов, но не их подтипы.
+# Другой вид типов — абстрактные типы.
+
+# abstract Name
+abstract Cat # просто имя и точка в иерархии типов
+
+# Объекты абстрактных типов создавать нельзя, 
+# но зато от них можно наследовать подтипы.
+# Например, Number — это абстрактный тип.
+subtypes(Number) # => 6 элементов в массиве Array{Any,1}:
+                 #     Complex{Float16}
+                 #     Complex{Float32}
+                 #     Complex{Float64}
+                 #     Complex{T<:Real}
+                 #     ImaginaryUnit
+                 #     Real
+subtypes(Cat) # => пустой массив Array{Any,1}
+
+# У всех типов есть супертип. Для его определения есть функция `super`.
+typeof(5) # => Int64
+super(Int64) # => Signed
+super(Signed) # => Real
+super(Real) # => Number
+super(Number) # => Any
+super(super(Signed)) # => Number
+super(Any) # => Any
+# Все эти типы, за исключением Int64, абстрактные.
+
+# Для создания подтипа используется оператор <:
+type Lion <: Cat # Lion — это подтип Cat
+  mane_color
+  roar::String
+end
+
+# У типа может быть несколько конструкторов.
+# Для создания нового определите функцию с именем, как у типа,
+# и вызовите имеющийся конструктор.
+Lion(roar::String) = Lion("green",roar)
+# Мы создали внешний (т.к. он находится вне определения типа) конструктор.
+
+type Panther <: Cat # Panther — это тоже подтип Cat
+  eye_color
+
+  # Определим свой конструктор вместо конструктора по умолчанию
+  Panther() = new("green")
+end
+# Использование внутренних конструкторов позволяет
+# определять, как будут создаваться объекты типов.
+# Но по возможности стоит пользоваться внешними конструкторами.
+
+####################################################
+## 6. Мультиметоды
+####################################################
+
+# Все именованные функции являются generic-функциями,
+# т.е. все они состоят из разных методов.
+# Каждый конструктор типа Lion — это метод generic-функции Lion.
+
+# Приведём пример без использования конструкторов, создадим функцию meow
+
+# Определения Lion, Panther и Tiger
+function meow(animal::Lion)
+  animal.roar # доступ к свойству типа через точку
+end
+
+function meow(animal::Panther)
+  "grrr"
+end
+
+function meow(animal::Tiger)
+  "rawwwr"
+end
+
+# Проверка
+meow(tigger) # => "rawwr"
+meow(Lion("brown","ROAAR")) # => "ROAAR"
+meow(Panther()) # => "grrr"
+
+# Вспомним иерархию типов
+issubtype(Tiger,Cat) # => false
+issubtype(Lion,Cat) # => true
+issubtype(Panther,Cat) # => true
+
+# Определим функцию, принимающую на вход объекты типа Cat
+function pet_cat(cat::Cat)
+  println("The cat says $(meow(cat))")
+end
+
+pet_cat(Lion("42")) # => выведет "The cat says 42"
+try
+    pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,)
+catch e
+    println(e)
+end
+
+# В объектно-ориентированных языках распространена одиночная диспетчеризация —
+# подходящий метод выбирается на основе типа первого аргумента.
+# В Julia все аргументы участвуют в выборе нужного метода.
+
+# Чтобы понять разницу, определим функцию с несколькими аргументами.
+function fight(t::Tiger,c::Cat)
+  println("The $(t.coatcolor) tiger wins!")
+end
+# => fight (generic function with 1 method)
+
+fight(tigger,Panther()) # => выведет The orange tiger wins!
+fight(tigger,Lion("ROAR")) # => выведет The orange tiger wins!
+
+# Переопределим поведение функции, если Cat-объект является Lion-объектом
+fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!")
+# => fight (generic function with 2 methods)
+
+fight(tigger,Panther()) # => выведет The orange tiger wins!
+fight(tigger,Lion("ROAR")) # => выведет The green-maned lion wins!
+
+# Драться можно не только с тиграми!
+fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
+# => fight (generic function with 3 methods)
+
+fight(Lion("balooga!"),Panther()) # => выведет The victorious cat says grrr
+try
+  fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion)
+catch
+end
+
+# Вообще, пускай кошачьи могут первыми проявлять агрессию
+fight(c::Cat,l::Lion) = println("The cat beats the Lion")
+# => Warning: New definition
+#    fight(Cat,Lion) at none:1
+# is ambiguous with
+#    fight(Lion,Cat) at none:2.
+# Make sure
+#    fight(Lion,Lion)
+# is defined first.
+#fight (generic function with 4 methods)
+
+# Предупреждение говорит, что неясно, какой из методов вызывать:
+fight(Lion("RAR"),Lion("brown","rarrr")) # => выведет The victorious cat says rarrr
+# Результат может оказаться разным в разных версиях Julia
+
+fight(l::Lion,l2::Lion) = println("The lions come to a tie")
+fight(Lion("RAR"),Lion("brown","rarrr")) # => выведет The lions come to a tie
+
+
+# Под капотом
+# Язык позволяет посмотреть на сгенерированные ассемблерный и LLVM-код.
+
+square_area(l) = l * l      # square_area (generic function with 1 method)
+
+square_area(5) #25
+
+# Что происходит, когда мы передаём функции square_area целое число?
+code_native(square_area, (Int32,))  
+	#	    .section    __TEXT,__text,regular,pure_instructions
+	#	Filename: none
+	#	Source line: 1              # Вводная часть
+	#	    push    RBP
+	#	    mov RBP, RSP
+	#	Source line: 1
+	#	    movsxd  RAX, EDI        # 
+	#	    imul    RAX, RAX        # 
+	#	    pop RBP                 #
+	#	    ret                     #
+
+code_native(square_area, (Float32,))
+	#	    .section    __TEXT,__text,regular,pure_instructions
+	#	Filename: none
+	#	Source line: 1
+	#	    push    RBP
+	#	    mov RBP, RSP
+	#	Source line: 1
+	#	    vmulss  XMM0, XMM0, XMM0  # Произведение чисел одинарной точности (AVX)
+	#	    pop RBP
+	#	    ret
+
+code_native(square_area, (Float64,))
+	#	    .section    __TEXT,__text,regular,pure_instructions
+	#	Filename: none
+	#	Source line: 1
+	#	    push    RBP
+	#	    mov RBP, RSP
+	#	Source line: 1
+	#	    vmulsd  XMM0, XMM0, XMM0 # Произведение чисел двойной точности (AVX)
+	#	    pop RBP
+	#	    ret
+	#	
+# Если хотя бы один из аргументов является числом с плавающей запятой,
+# то Julia будет использовать соответствующие инструкции.
+# Вычислим площать круга
+circle_area(r) = pi * r * r     # circle_area (generic function with 1 method)
+circle_area(5)                  # 78.53981633974483
+
+code_native(circle_area, (Int32,))
+	#	    .section    __TEXT,__text,regular,pure_instructions
+	#	Filename: none
+	#	Source line: 1
+	#	    push    RBP
+	#	    mov RBP, RSP
+	#	Source line: 1
+	#	    vcvtsi2sd   XMM0, XMM0, EDI          # Загрузить целое число (r)
+	#	    movabs  RAX, 4593140240              # Загрузить pi
+	#	    vmulsd  XMM1, XMM0, QWORD PTR [RAX]  # pi * r
+	#	    vmulsd  XMM0, XMM0, XMM1             # (pi * r) * r
+	#	    pop RBP
+	#	    ret
+	#
+
+code_native(circle_area, (Float64,))
+	#	    .section    __TEXT,__text,regular,pure_instructions
+	#	Filename: none
+	#	Source line: 1
+	#	    push    RBP
+	#	    mov RBP, RSP
+	#	    movabs  RAX, 4593140496
+	#	Source line: 1
+	#	    vmulsd  XMM1, XMM0, QWORD PTR [RAX]
+	#	    vmulsd  XMM0, XMM1, XMM0
+	#	    pop RBP
+	#	    ret
+	#
+```
+
+## Что дальше?
+
+Для более подробной информации читайте [документацию по языку](http://docs.julialang.org/en/latest/manual/)
+
+Если вам нужна помощь, задавайте вопросы в [списке рассылки](https://groups.google.com/forum/#!forum/julia-users).
diff --git a/ru-ru/lua-ru.html.markdown b/ru-ru/lua-ru.html.markdown
new file mode 100644
index 00000000..da9ced6a
--- /dev/null
+++ b/ru-ru/lua-ru.html.markdown
@@ -0,0 +1,425 @@
+---
+language: Lua
+filename: learnlua-ru.lua
+contributors:
+    - ["Tyler Neylon", "http://tylerneylon.com/"]
+translators:
+    - ["Max Solomonov", "https://vk.com/solomonovmaksim"]
+    - ["Max Truhonin", "https://vk.com/maximmax42"]
+    - ["Konstantin Gromyko", "https://vk.com/id0x1765d79"]
+    - ["Stanislav Gromov", "https://vk.com/id156354391"]
+lang: ru-ru
+---
+
+```lua
+-- Два дефиса начинают однострочный комментарий.
+
+--[[
+    Добавление двух квадратных скобок
+    делает комментарий многострочным.
+--]]
+--------------------------------------------------------------------------------
+-- 1. Переменные, циклы и условия.
+--------------------------------------------------------------------------------
+
+num = 42  -- Все числа имеют тип double.
+-- Не волнуйтесь, в 64-битных double 52 бита
+-- отведено под хранение целой части числа;
+-- точность не является проблемой для
+-- целочисленных значений, занимающих меньше 52 бит.
+
+s = 'walternate'  -- Неизменные строки, как в Python.
+t = "Двойные кавычки также приветствуются"
+u = [[ Двойные квадратные скобки
+       начинают и заканчивают
+       многострочные значения.]]
+t = nil  -- Удаляет определение переменной t; в Lua есть сборка мусора.
+
+-- Блоки обозначаются ключевыми словами, такими как do/end:
+while num < 50 do
+  num = num + 1  -- Операторов ++ и += нет.
+end
+
+-- Ветвление "если":
+if num > 40 then
+  print('больше 40')
+elseif s ~= 'walternate' then  -- ~= обозначает "не равно".
+  -- Проверка равенства это ==, как в Python; работает для строк.
+  io.write('не больше 40\n')  -- По умолчанию вывод в stdout.
+else
+  -- По умолчанию переменные являются глобальными.
+  thisIsGlobal = 5  -- Стиль CamelСase является общим.
+
+  -- Как сделать переменную локальной:
+  local line = io.read()  -- Считывает введённую строку.
+
+  -- Для конкатенации строк используется оператор .. :
+  print('Зима пришла, ' .. line)
+end
+
+-- Неопределённые переменные возвращают nil.
+-- Этот пример не является ошибочным:
+foo = anUnknownVariable  -- Теперь foo = nil.
+
+aBoolValue = false
+
+-- Только значения nil и false являются ложными; 0 и '' являются истинными!
+if not aBoolValue then print('это значение ложно') end
+
+-- Для 'or' и 'and' действует принцип "какой оператор дальше,
+-- тот и применяется". Это действует аналогично оператору a?b:c в C/js:
+ans = aBoolValue and 'yes' or 'no'  --> 'no'
+
+karlSum = 0
+for i = 1, 100 do  -- Здесь указан диапазон, ограниченный с двух сторон.
+  karlSum = karlSum + i
+end
+
+-- Используйте "100, 1, -1" как нисходящий диапазон:
+fredSum = 0
+for j = 100, 1, -1 do fredSum = fredSum + j end
+
+-- В основном, диапазон устроен так: начало, конец[, шаг].
+
+-- Другая конструкция цикла:
+repeat
+  print('путь будущего')
+  num = num - 1
+until num == 0
+
+--------------------------------------------------------------------------------
+-- 2. Функции.
+--------------------------------------------------------------------------------
+
+function fib(n)
+  if n < 2 then return n end
+  return fib(n - 2) + fib(n - 1)
+end
+
+-- Вложенные и анонимные функции являются нормой:
+function adder(x)
+  -- Возращаемая функция создаётся, когда вызывается функция adder,
+  -- и запоминает значение переменной x:
+  return function (y) return x + y end
+end
+a1 = adder(9)
+a2 = adder(36)
+print(a1(16))  --> 25
+print(a2(64))  --> 100
+
+-- Возвраты, вызовы функций и присвоения работают со списками,
+-- которые могут иметь разную длину.
+-- Лишние получатели принимают значение nil, а лишние значения игнорируются.
+
+x, y, z = 1, 2, 3, 4
+-- Теперь x = 1, y = 2, z = 3, а 4 просто отбрасывается.
+
+function bar(a, b, c)
+  print(a, b, c)
+  return 4, 8, 15, 16, 23, 42
+end
+
+x, y = bar('zaphod')  --> выводит "zaphod  nil nil"
+-- Теперь x = 4, y = 8, а значения 15..42 отбрасываются.
+
+-- Функции могут быть локальными и глобальными. Эти строки делают одно и то же:
+function f(x) return x * x end
+f = function (x) return x * x end
+
+-- Эти тоже:
+local function g(x) return math.sin(x) end
+local g = function(x) return math.sin(x) end
+-- Эквивалентно для local function g(x)..., однако ссылки на g
+-- в теле функции не будут работать, как ожидалось.
+local g; g  = function (x) return math.sin(x) end
+-- 'local g' будет прототипом функции.
+
+-- Кстати, тригонометрические функции работают с радианами.
+
+-- Вызов функции с одним строковым параметром не требует круглых скобок:
+print 'hello'  -- Работает без ошибок.
+
+-- Вызов функции с одним табличным параметром также
+-- не требует круглых скобок (про таблицы в след. части):
+print {} -- Тоже сработает.
+
+--------------------------------------------------------------------------------
+-- 3. Таблицы.
+--------------------------------------------------------------------------------
+
+-- Таблица = единственная составная структура данных в Lua;
+-- представляет собой ассоциативный массив.
+-- Подобно массивам в PHP или объектам в JS, они представляют собой
+-- хеш-таблицы, которые также можно использовать в качестве списков.
+
+
+-- Использование словарей:
+
+-- Литералы имеют ключ по умолчанию:
+t = {key1 = 'value1', key2 = false}
+
+-- Строковые ключи используются, как в точечной нотации в JS:
+print(t.key1)  -- Печатает 'value1'.
+t.newKey = {}  -- Добавляет новую пару ключ/значение.
+t.key2 = nil   -- Удаляет key2 из таблицы.
+
+-- Литеральная нотация для любого значения ключа (кроме nil):
+u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
+print(u[6.28])  -- пишет "tau"
+
+-- Ключ соответствует значению для чисел и строк, но при
+-- использовании таблицы в качестве ключа берётся её экземпляр.
+a = u['@!#']  -- Теперь a = 'qbert'.
+b = u[{}]     -- Вы могли ожидать 1729, но получится nil:
+-- b = nil, т.к. ключ не будет найден.
+-- Это произойдёт потому, что за ключ мы использовали не тот же самый объект,
+-- который был использован для сохранения оригинального значения.
+-- Поэтому строки и числа удобнее использовать в качестве ключей.
+
+-- Вызов функции с одной таблицей в качестве аргумента
+-- не требует круглых скобок:
+function h(x) print(x.key1) end
+h{key1 = 'Sonmi~451'}  -- Печатает 'Sonmi~451'.
+
+for key, val in pairs(u) do  -- Цикл по таблице.
+  print(key, val)
+end
+
+-- _G - это таблица со всеми глобалями.
+print(_G['_G'] == _G)  -- Печатает 'true'.
+
+-- Использование таблиц, как списков / массивов:
+
+-- Список значений с неявно заданными целочисленными ключами:
+v = {'value1', 'value2', 1.21, 'gigawatts'}
+for i = 1, #v do  -- #v - размер списка v.
+  print(v[i])  -- Нумерация начинается с 1 !!
+end
+
+-- Список не является отдельным типом. v - всего лишь таблица
+-- с последовательными целочисленными ключами, воспринимаемая как список.
+
+--------------------------------------------------------------------------------
+-- 3.1 Метатаблицы и метаметоды.
+--------------------------------------------------------------------------------
+
+-- Таблицу можно связать с метатаблицей, задав ей поведение, как при
+-- перегрузке операторов. Позже мы увидим, что метатаблицы поддерживают
+-- поведение, как в js-прототипах.
+f1 = {a = 1, b = 2}  -- Представляет дробь a/b.
+f2 = {a = 2, b = 3}
+
+-- Это не сработает:
+-- s = f1 + f2
+
+metafraction = {}
+function metafraction.__add(f1, f2)
+  local sum = {}
+  sum.b = f1.b * f2.b
+  sum.a = f1.a * f2.b + f2.a * f1.b
+  return sum
+end
+
+setmetatable(f1, metafraction)
+setmetatable(f2, metafraction)
+
+s = f1 + f2  -- вызвать __add(f1, f2) на метатаблице от f1
+
+-- f1, f2 не имеют ключа для своих метатаблиц в отличии от прототипов в js,
+-- нужно получить его через getmetatable(f1). Метатаблица - обычная таблица
+-- поэтому с ключами, известными для Lua (например, __add).
+
+-- Но следущая строка будет ошибочной т.к в s нет метатаблицы:
+-- t = s + s
+-- Похожий на классы подход, приведенный ниже, поможет это исправить.
+
+-- __index перегружает в метатаблице просмотр через точку:
+defaultFavs = {animal = 'gru', food = 'donuts'}
+myFavs = {food = 'pizza'}
+setmetatable(myFavs, {__index = defaultFavs})
+eatenBy = myFavs.animal  -- работает! спасибо, мета-таблица.
+
+--------------------------------------------------------------------------------
+-- При неудаче прямой табличный поиск попытается использовать
+-- значение __index в метатаблице, причём это рекурсивно.
+
+-- Значение __index также может быть функцией
+-- function(tbl, key) для настраиваемого поиска.
+
+-- Значения типа __index, __add, ... называются метаметодами.
+-- Ниже приведён полный список метаметодов.
+
+-- __add(a, b)                          для a + b
+-- __sub(a, b)                          для a - b
+-- __mul(a, b)                          для a * b
+-- __div(a, b)                          для a / b
+-- __mod(a, b)                          для a % b
+-- __pow(a, b)                          для a ^ b
+-- __unm(a)                             для -a
+-- __concat(a, b)                       для a .. b
+-- __len(a)                             для #a
+-- __eq(a, b)                           для a == b
+-- __lt(a, b)                           для a < b
+-- __le(a, b)                           для a <= b
+-- __index(a, b) <функция или таблица>  для a.b
+-- __newindex(a, b, c)                  для a.b = c
+-- __call(a, ...)                       для a(...)
+
+--------------------------------------------------------------------------------
+-- 3.2 Классоподобные таблицы и наследование.
+--------------------------------------------------------------------------------
+
+-- В Lua нет поддержки классов на уровне языка,
+-- однако существуют разные способы их создания с помощью
+-- таблиц и метатаблиц.
+
+-- Ниже приведён один из таких способов.
+
+Dog = {}                                   -- 1.
+
+function Dog:new()                         -- 2.
+  local newObj = {sound = 'woof'}          -- 3.
+  self.__index = self                      -- 4.
+  return setmetatable(newObj, self)        -- 5.
+end
+
+function Dog:makeSound()                   -- 6.
+  print('I say ' .. self.sound)
+end
+
+mrDog = Dog:new()                          -- 7.
+mrDog:makeSound()  -- 'I say woof'         -- 8.
+
+-- 1. Dog похоже на класс, но на самом деле это таблица.
+-- 2. "function tablename:fn(...)" - то же самое, что и
+--    "function tablename.fn(self, ...)", просто : добавляет первый аргумент
+--    перед собой. См. пункты 7 и 8, чтобы понять, как self получает значение.
+-- 3. newObj - это экземпляр класса Dog.
+-- 4. "self" - экземпляр класса. Зачастую self = Dog, но с помощью наследования
+--    это можно изменить. newObj получит свои функции, когда мы установим
+--    метатаблицу для newObj и __index для self на саму себя.
+-- 5. Напоминание: setmetatable возвращает первый аргумент.
+-- 6. : работает, как в пункте 2, но в этот раз мы ожидаем,
+--    что self будет экземпляром, а не классом.
+-- 7. То же самое, что и Dog.new(Dog), поэтому self = Dog в new().
+-- 8. То же самое, что mrDog.makeSound(mrDog); self = mrDog.
+--------------------------------------------------------------------------------
+
+-- Пример наследования:
+
+LoudDog = Dog:new()                           -- 1.
+
+function LoudDog:makeSound()
+  local s = self.sound .. ' '                 -- 2.
+  print(s .. s .. s)
+end
+
+seymour = LoudDog:new()                       -- 3.
+seymour:makeSound()  -- 'woof woof woof'      -- 4.
+
+--------------------------------------------------------------------------------
+-- 1. LoudDog получит методы и переменные класса Dog.
+-- 2. В self будет ключ 'sound' из new(), см. пункт 3.
+-- 3. То же самое, что и "LoudDog.new(LoudDog)", конвертированное
+--    в "Dog.new(LoudDog)", поскольку в LoudDog нет ключа 'new',
+--    но в его метатаблице есть "__index = Dog".
+--    Результат: Метатаблицей для seymour стала LoudDog,
+--    а "LoudDog.__index = Dog". Поэтому seymour.key будет равно
+--    seymour.key, LoudDog.key, Dog.key, в зависимости от того,
+--    какая таблица будет первой с заданным ключом.
+-- 4. Ключ 'makeSound' находится в LoudDog;
+--    то же самое, что и "LoudDog.makeSound(seymour)".
+
+-- При необходимости функция new() в подклассе
+-- может быть похожа на аналог в базовом классе.
+function LoudDog:new()
+  local newObj = {}
+  -- установить newObj
+  self.__index = self
+  return setmetatable(newObj, self)
+end
+
+--------------------------------------------------------------------------------
+-- 4. Модули.
+--------------------------------------------------------------------------------
+
+
+--[[ Я закомментировал этот раздел, чтобы остальная часть скрипта осталась
+--   работоспособной.
+```
+
+```lua
+-- Предположим, файл mod.lua будет выглядеть так:
+local M = {}
+
+local function sayMyName()
+  print('Hrunkner')
+end
+
+function M.sayHello()
+  print('Привет, ')
+  sayMyName()
+end
+
+return M
+
+-- Другой файл может использовать функционал mod.lua:
+local mod = require('mod')  -- Запустим файл mod.lua.
+
+-- require - стандартный способ подключения модулей.
+-- require ведёт себя так:     (если не кэшировано, см. ниже)
+local mod = (function ()
+  <содержимое mod.lua>
+end)()
+-- Файл mod.lua воспринимается, как тело функции, поэтому
+-- все локальные переменные и функции внутри него не видны за его пределами.
+
+-- Это работает, так как здесь mod = M в mod.lua:
+mod.sayHello()  -- Выведет "Привет, Hrunkner".
+
+-- Это будет ошибочным; sayMyName доступна только в mod.lua:
+mod.sayMyName()  -- ошибка
+
+-- Значения, возвращаемые require, кэшируются,
+-- поэтому содержимое файла выполняется только 1 раз,
+-- даже если он подключается с помощью require много раз.
+
+-- Предположим, mod2.lua содержит "print('Hi!')".
+local a = require('mod2')  -- Выведет "Hi!"
+local b = require('mod2')  -- Ничего не выведет; a=b.
+
+-- dofile, в отличии от require, работает без кэширования:
+dofile('mod2')  --> Hi!
+dofile('mod2')  --> Hi! (запустится снова)
+
+-- loadfile загружает файл, но не запускает его.
+f = loadfile('mod2')  -- Вызов f() запустит содержимое mod2.lua.
+
+-- loadstring - это loadfile для строк.
+g = loadstring('print(343)')  -- Вернет функцию.
+g()  -- Напишет 343.
+
+--]]
+
+```
+## Примечание (от автора)
+
+Мне было интересно изучить Lua, чтобы делать игры при помощи <a href="http://love2d.org/">игрового движка LÖVE</a>.
+
+Я начинал с <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">BlackBulletIV's Lua for programmers</a>.
+Затем я прочитал официальную <a href="http://www.lua.org/pil/contents.html">Документацию по Lua</a>.
+
+Также может быть полезной <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Краткая справка по Lua</a> на lua-users.org.
+
+Ещё из основных тем не охвачены стандартные библиотеки:
+
+* <a href="http://lua-users.org/wiki/StringLibraryTutorial">библиотека string</a>
+* <a href="http://lua-users.org/wiki/TableLibraryTutorial">библиотека table</a>
+* <a href="http://lua-users.org/wiki/MathLibraryTutorial">библиотека math</a>
+* <a href="http://lua-users.org/wiki/IoLibraryTutorial">библиотека io</a>
+* <a href="http://lua-users.org/wiki/OsLibraryTutorial">библиотека os</a>
+
+Кстати, весь файл написан на Lua; сохраните его как learn.lua и запустите при помощи "lua learn.lua" !
+
+Изначально эта статья была написана для tylerneylon.com.
+Также она доступна как <a href="https://gist.github.com/tylerneylon/5853042">github gist</a>. Удачи с Lua!
diff --git a/ru-ru/markdown-ru.html.markdown b/ru-ru/markdown-ru.html.markdown
new file mode 100644
index 00000000..eb8e4881
--- /dev/null
+++ b/ru-ru/markdown-ru.html.markdown
@@ -0,0 +1,279 @@
+---
+language: markdown
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+    - ["Pirogov Alexey", "http://twitter.com/alex_pir"]
+filename: markdown-ru.md
+lang: ru-ru
+---
+
+Язык разметки Markdown создан Джоном Грубером (англ. John Gruber)
+и Аароном Шварцем (англ. Aaron H. Swartz) в 2004 году.
+Авторы задавались целью создать максимально удобочитаемый
+и удобный в публикации облегчённый язык разметки,
+пригодный для последующего преобразования в HTML
+(а также и в другие форматы).
+
+ ```markdown
+<!-- Markdown является надмножеством HTML, поэтому любой HTML-файл является
+валидным документом Markdown, что позволяет использовать напрямую
+любые элементы HTML-разметки, такие, например, как этот комментарий.
+  Встроенные в документ HTML-элементы не затрагиваются парсером Markdown
+и попадают в итоговый HTML без изменений. Однако, следует понимать,
+что эта же особенность не позволяет использовать разметку Markdown внутри
+HTML-элементов -->
+
+<!-- Ещё одна особенность формата Markdown состоит в том, что поддерживаемые
+возможности разметки зависят от конкретной реализации парсера. В данном
+руководстве возможности, поддерживаемые лишь определёнными парсерами,
+сопровождаются соответствующими примечаниями. -->
+
+<!-- Заголовки -->
+
+<!-- HTML-элементы от <h1> до <h6> размечаются очень просто:
+текст, который должен стать заголовком, предваряется
+соответствующим количеством символов "#": -->
+# Это заголовок h1
+## Это заголовок h2
+### Это заголовок h3
+#### Это заголовок h4
+##### Это заголовок h5
+###### Это заголовок h6
+
+<!-- Markdown позволяет размечать заголовки <h1> и <h2> ещё одним способом: -->
+Это заголовок h1
+================
+
+А это заголовок h2
+------------------
+
+<!-- Простейшая стилизация текста -->
+
+<!-- Текст легко сделать полужирным и/или курсивным: -->
+
+*Этот текст будет выведен курсивом.*
+_Так же, как этот._
+
+**А этот текст будет полужирным.**
+__И этот тоже.__
+
+***Полужирный курсив.***
+**_И тут!_**
+*__И даже здесь!__*
+
+<!-- В Github Flavored Markdown (версии Markdown, использующейся в Github,
+для рендеринга Markdown-документов) текст можно сделать зачёркнутым: -->
+
+~~Зачёркнутый текст.~~
+
+<!-- Абзацами являются любые строки, следующие друг за другом.
+Разделяются же абзацы одной или несколькими пустыми строками: -->
+
+Это абзац. Всё предельно просто.
+
+А тут уже параграф №2.
+Эта строка всё ещё относится к параграфу №2!
+
+
+О, а вот это уже параграф №3!
+
+<!-- Для вставки принудительных переносов можно использовать HTML-тэг <br/>: -->
+
+Принудительный <br/> перенос!
+
+<!-- Цитаты размечаются с помощью символа ">": -->
+
+> Это цитата. В цитатах можно
+> принудительно переносить строки, вставляя ">" в начало каждой следующей строки. А можно просто оставлять достаточно длинными, и такие длинные строки будут перенесены автоматически.
+> Разницы между этими двумя подходами к переносу строк нет, коль скоро
+> каждая строка начинается с символа ">"
+
+> А ещё цитаты могут быть многоуровневыми:
+>> как здесь
+>>> и здесь :)
+> Неплохо?
+
+<!-- Списки -->
+<!-- Маркированные списки размечаются вставкой в начало каждого элемента
+одного из символов "*", "+" или "-":
+(символ должен быть одним и тем же для всех элементов) -->
+
+* Список,
+* Размеченный
+* Звёздочками
+
+либо
+
++ Список,
++ Размеченный
++ Плюсами
+
+либо
+
+- Список,
+- Размеченный
+- Дефисами
+
+<!-- В нумерованных списках каждая строка начинается
+с числа и точки вслед за ним: -->
+
+1. Первый элемент
+2. Второй элемент
+3. Третий элемент
+
+<!-- Заметьте, нумеровать элементы корректно необязательно. Достаточно указать
+любое число в начале каждого элемента и рендер пронумерует элементы сам!
+Правда, злоупотреблять этим не стоит :) -->
+
+1. Первый элемент
+1. Второй элемент
+1. Третий элемент
+<!-- (Этот список будет отрендерен так же, как и предыдущий!) -->
+
+<!-- Списки могут быть вложенными: -->
+
+1. Введение
+2. Начало работы
+3. Примеры использования
+    * Простые
+    * Сложные
+4. Заключение
+
+<!-- Блоки с исходным кодом -->
+<!-- Фрагменты исходного кода выделяются очень просто - каждая строка блока должна иметь отступ в четыре пробела либо в один символ табуляции -->
+
+    Это код,
+    причём - многострочный
+
+<!-- Дополнительные отступы в коде следует делать с помощью четырёх пробелов: -->
+
+    my_array.each do |item|
+        puts item
+    end
+
+<!-- Иногда бывает нужно вставить фрагмент кода прямо в строку текста,
+не выделяя код в блок. Для этого фрагменты кода нужно обрамлять
+символами "`": -->
+
+Например, можно выделить имя функции `go_to()` прямо посреди текста.
+
+<!-- Github Flavored Markdown позволяет указать для блока кода синтаксис оного.
+В этом случае синтаксис внутри блока будет подсвечен. Пример: -->
+
+\`\`\`ruby <!-- Только нужно будет убрать символы "\", оставив лишь "```ruby" -->
+def foobar
+    puts "Hello world!"
+end
+\`\`\` <!-- И здесь тоже backslashes нужно убрать, т.е. оставить "```" -->
+
+<-- Обратите внимание: фрагмент, указанный выше, не предваряется отступами,
+поскольку Github сам в состоянии определить границы блока - по строкам "```" -->
+
+<!-- Горизонтальный разделитель (<hr />) -->
+<!-- Разделители добавляются вставкой строки из трёх и более
+(одинаковых) символов "*" или "-": -->
+
+***
+---
+- - - <!-- между символами допустимы пробелы -->
+****************
+
+<!-- Ссылки -->
+<!-- Одной из сильных сторон Markdown можно смело считать то,
+как просто размечаются гиперссылки. Для создания ссылки укажите
+текст ссылки, заключив его в квадратные скобки,
+и сразу после - url, заключенный в "круглые" -->
+
+[Ссылка!](http://test.com/)
+
+<!-- Также для ссылки можно указать всплывающую подсказку: -->
+
+[Ссылка!](http://test.com/ "Ссылка на Test.com")
+
+<!-- В url можно использовать относительные пути: -->
+
+[Перейти к музыке](/music/).
+
+<!-- Markdown позволяет размечать ссылку в виде сноски: -->
+
+[Здесь][link1] высможете узнать больше!
+А можно кликнуть [сюда][foobar], если очень хочется.
+
+<!-- где-нибудь внизу -->
+[link1]: http://test.com/ "Круто!"
+[foobar]: http://foobar.biz/ "Тоже хорошо!"
+
+<!-- Примечания:
+- Подсказка может быть заключена в одинарные кавычки вместо двойных,
+  а также в круглые скобки.
+- Сноска может находиться в любом месте документа и может иметь
+идентификатор (далее ID) произвольной длины,
+лишь бы это ID был уникальным. -->
+
+<!-- Также при разметке ссылок-сносок можно опустить ID,
+если текст ссылки уникален в пределах документа: -->
+
+Ссылка на [Google][].
+
+[google]: http://google.com/
+
+<!-- Правда, эта возможность не очень распространена. -->
+
+<!-- Изображения -->
+<!-- Разметка изображений очень похожа на разметку ссылок.
+Нужно всего лишь добавить "!" перед ссылкой! -->
+
+![Альтернативный текст для изображения](http://imgur.com/myimage.jpg "Подсказка")
+
+<!-- Изображения тоже могут быть оформлены, как сноски: -->
+
+![Альтернативный текст][myimage]
+
+![То же изображение ещё раз][myimage]
+
+[myimage]: relative/urls/cool/image.jpg "подсказка"
+
+<!-- Ещё немного ссылок: -->
+<!-- Автоссылки -->
+
+Ссылка вида <http://testwebsite.com/> эквивалентна
+[http://testwebsite.com/](http://testwebsite.com/)
+
+<!-- Автоссылки для адресов электронной почты -->
+
+<foo@bar.com>
+
+<!-- Экранирование символов -->
+
+<!-- Может потребоваться вставить спецсимвол в текст "как есть",
+т.е. защитить его от обработки парсером.
+Такой символ должен быть "экранирован" с помощью обратной косой черты
+(символа "\"): -->
+
+\*текст, заключённый в звёздочки!\*
+
+<!-- Таблицы -->
+<!-- Таблицы официально поддерживаются только в Github Flavored Markdown,
+да и синтаксис имеют не слишком удобный.
+Но если очень нужно, размечайте таблицы так: -->
+
+| Столбец 1    | Столбец 2    | Столбец 3    |
+| :----------- | :----------: | -----------: |
+| Выравнивание | Выравнивание | Выравнивание |
+| влево        | по центру    | вправо       |
+
+<!-- Или более компактно -->
+
+Колонка 1|Колонка 2|Колонка 3
+:--|:-:|--:
+Выглядит|это|страшновато...
+
+<!-- Ну вот и всё! -->
+
+```
+
+За более подробной информацией обращайтесь к [статье](http://daringfireball.net/projects/markdown/syntax) Джона Грубера о синтаксисе Markdown.
+
+Также часто бывает полезной отличная ["шпаргалка"](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) по Markdown от Adam Pritchard.
+
+Если вдруг встретите ошибки в переводе или же захотите его дополнить, делайте pull requests - авторы всегда рады обратной связи!
diff --git a/ru-ru/objective-c-ru.html.markdown b/ru-ru/objective-c-ru.html.markdown
new file mode 100644
index 00000000..ddff2e5c
--- /dev/null
+++ b/ru-ru/objective-c-ru.html.markdown
@@ -0,0 +1,819 @@
+---
+language: Objective-C
+filename: LearnObjectiveC-ru.m
+contributors:
+    - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
+    - ["Yannick Loriot", "https://github.com/YannickL"]
+    - ["Levi Bostian", "https://github.com/levibostian"]
+translators:
+    - ["Evlogy Sutormin", "http://evlogii.com"]
+    - ["Dmitry Bessonov", "https://github.com/TheDmitry"]
+lang: ru-ru
+---
+
+Objective-C — основной язык программирования, используемый корпорацией Apple
+для операционных систем OS X и iOS и их соответствующих фреймворках Cocoa и
+Cocoa Touch.
+Он является объектно-ориентированным языком программирования общего назначения,
+который добавляет обмен сообщениями в Smalltalk-стиле к языку программирования C.
+
+```objective_c
+// Однострочные комментарии начинаются с //
+
+/*
+Так выглядят многострочные комментарии
+*/
+
+// Импорт заголовочных файлов фреймворка Foundation с помощью #import
+// Используйте <>, чтобы импортировать глобальные файлы (обычно фреймворки)
+// Используйте "", чтобы импортировать локальные файлы (из проекта)
+#import <Foundation/Foundation.h>
+#import "MyClass.h"
+
+// Если вы включили модули для iOS >= 7.0 или OS X >= 10.9 проектов в
+// Xcode 5, вы можете импортировать фреймворки подобным образом:
+@import Foundation;
+
+// Точка входа в программу - это функция main,
+// которая возвращает целый тип
+int main (int argc, const char * argv[])
+{
+    // Создание autorelease pool для управления памятью в программе
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+    // В место этого воспользуйтесь @autoreleasepool, если вы используете
+    // автоматический подсчет ссылок (ARC)
+    @autoreleasepool {
+    
+    // Используйте NSLog для печати в консоль
+    NSLog(@"Привет Мир!"); // Напечатает строку "Привет Мир!"
+ 
+    ///////////////////////////////////////
+    // Типы и переменные
+    ///////////////////////////////////////
+    
+    // Объявление простых типов
+    int myPrimitive1  = 1;
+    long myPrimitive2 = 234554664565;
+    
+    // Объявление объектов
+    // Помещайте * в начало названия объекта для строго типизированного объявления
+    MyClass *myObject1 = nil;  // Строгая типизация	
+    id       myObject2 = nil;  // Слабая типизация 
+    // %@ – это объект
+    // 'description' - это общий для всех объектов метод вывода данных
+    NSLog(@"%@ and %@", myObject1, [myObject2 description]); // напечатает "(null) and (null)"
+    
+    // Строка
+    NSString *worldString = @"Мир";
+    NSLog(@"Привет %@!", worldString); // напечатает "Привет Мир!"
+    // NSMutableString - это изменяемая версия NSString-объекта
+    NSMutableString *mutableString = [NSMutableString stringWithString:@"Привет"];
+    [mutableString appendString:@" Мир!"];
+    NSLog(@"%@", mutableString); // напечатает => "Привет Мир!"
+    
+    // Символьные литералы
+    NSNumber *theLetterZNumber = @'Z';
+    char theLetterZ            = [theLetterZNumber charValue]; // или 'Z'
+    NSLog(@"%c", theLetterZ);
+
+    // Целочисленные литералы
+    NSNumber *fortyTwoNumber = @42;
+    int fortyTwo             = [fortyTwoNumber intValue]; // или '42'
+    NSLog(@"%i", fortyTwo);
+    
+    // Беззнаковый целочисленный литерал
+    NSNumber *fortyTwoUnsignedNumber = @42U;
+    unsigned int fortyTwoUnsigned    = [fortyTwoUnsignedNumber unsignedIntValue]; // или 42
+    NSLog(@"%u", fortyTwoUnsigned);
+
+    NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];
+    short fortyTwoShort           = [fortyTwoShortNumber shortValue]; // или 42
+    NSLog(@"%hi", fortyTwoShort);
+    
+    NSNumber *fortyOneShortNumber   = [NSNumber numberWithShort:41];
+    unsigned short fortyOneUnsigned = [fortyOneShortNumber unsignedShortValue]; // или 41
+    NSLog(@"%u", fortyOneUnsigned);
+    
+    NSNumber *fortyTwoLongNumber = @42L;
+    long fortyTwoLong            = [fortyTwoLongNumber longValue]; // или 42
+    NSLog(@"%li", fortyTwoLong);
+    
+    NSNumber *fiftyThreeLongNumber   = @53L;
+    unsigned long fiftyThreeUnsigned = [fiftyThreeLongNumber unsignedLongValue]; // или 53
+    NSLog(@"%lu", fiftyThreeUnsigned);
+
+    // Вещественный литерал
+    NSNumber *piFloatNumber = @3.141592654F;
+    float piFloat           = [piFloatNumber floatValue]; // или 3.141592654f
+    NSLog(@"%f", piFloat); // напечатает 3.141592654
+    NSLog(@"%5.2f", piFloat); // напечатает " 3.14"
+    
+    NSNumber *piDoubleNumber = @3.1415926535;
+    double piDouble                 = [piDoubleNumber doubleValue]; // или 3.1415926535
+    NSLog(@"%f", piDouble);
+    NSLog(@"%4.2f", piDouble); // напечатает "3.14"
+
+    // NSDecimalNumber - это класс с фиксированной точкой, который является
+    // более точным, чем float или double
+    NSDecimalNumber *oneDecNum = [NSDecimalNumber decimalNumberWithString:@"10.99"];
+    NSDecimalNumber *twoDecNum = [NSDecimalNumber decimalNumberWithString:@"5.002"];
+    // NSDecimalNumber не способен использовать стандартные +, -, *, / операторы,
+    // поэтому он предоставляет свои собственные:
+    [oneDecNum decimalNumberByAdding:twoDecNum]; 
+    [oneDecNum decimalNumberBySubtracting:twoDecNum];
+    [oneDecNum decimalNumberByMultiplyingBy:twoDecNum];
+    [oneDecNum decimalNumberByDividingBy:twoDecNum];
+    NSLog(@"%@", oneDecNum); // напечатает "10.99", т.к. NSDecimalNumber - изменяемый
+    
+    // BOOL (булевый) литерал
+    NSNumber *yesNumber = @YES;
+    NSNumber *noNumber  = @NO;
+    // или
+    BOOL yesBool = YES;
+    BOOL noBool  = NO;
+    NSLog(@"%i", yesBool); // напечатает 1
+    
+    // Массив
+    // Может содержать различные типы данных, но должен быть объектом Objective-C
+    NSArray *anArray      = @[@1, @2, @3, @4];
+    NSNumber *thirdNumber = anArray[2];
+    NSLog(@"Третье число = %@", thirdNumber); // Напечатает "Третье число = 3"
+    // NSMutableArray - это изменяемая версия NSArray, допускающая вам изменять
+    // элементы в массиве и расширять или сокращать массив.
+    // Удобный, но не эффективный как NSArray.
+    NSMutableArray *mutableArray = [NSMutableArray arrayWithCapacity:2];
+    [mutableArray addObject:@"Привет"];
+    [mutableArray addObject:@"Мир"];
+    [mutableArray removeObjectAtIndex:0];
+    NSLog(@"%@", [mutableArray objectAtIndex:0]); // напечатает "Мир"
+
+    // Словарь
+    NSDictionary *aDictionary = @{ @"ключ1" : @"значение1", @"ключ2" : @"значение2" };
+    NSObject *valueObject     = aDictionary[@"Ключ"];
+    NSLog(@"Объект = %@", valueObject); // Напечатает "Объект = (null)"
+    // NSMutableDictionary тоже доступен, как изменяемый словарь
+    NSMutableDictionary *mutableDictionary = [NSMutableDictionary dictionaryWithCapacity:2];
+    [mutableDictionary setObject:@"значение1" forKey:@"ключ1"];
+    [mutableDictionary setObject:@"значение2" forKey:@"ключ2"];
+    [mutableDictionary removeObjectForKey:@"ключ1"];
+
+    // Множество
+    NSSet *set = [NSSet setWithObjects:@"Привет", @"Привет", @"Мир", nil];
+    NSLog(@"%@", set); // напечатает {(Hello, World)} (порядок может отличаться)
+    // NSMutableSet тоже доступен, как изменяемое множество
+    NSMutableSet *mutableSet = [NSMutableSet setWithCapacity:2];
+    [mutableSet addObject:@"Привет"];
+    [mutableSet addObject:@"Привет"];
+    NSLog(@"%@", mutableSet); // напечатает => {(Привет)}
+    
+    ///////////////////////////////////////
+    // Операторы
+    ///////////////////////////////////////
+    
+    // Операторы работают также как в Си.
+    // Например:
+    2 + 5; // => 7
+    4.2f + 5.1f; // => 9.3f
+    3 == 2; // => 0 (НЕТ)
+    3 != 2; // => 1 (ДА)
+    1 && 1; // => 1 (логическое И)
+    0 || 1; // => 1 (логическое ИЛИ)
+    ~0x0F; // => 0xF0 (побитовое отрицание)
+    0x0F & 0xF0; // => 0x00 (побитовое И)
+    0x01 << 1; // => 0x02 (побитовый сдвиг влево (на 1))
+
+    ///////////////////////////////////////
+    // Структуры ветвления
+    ///////////////////////////////////////
+
+    // Условный оператор
+    if (NO)
+    {
+        NSLog(@"Я никогда не выполнюсь");
+    } else if (0)
+    {
+        NSLog(@"Я тоже никогда не выполнюсь");
+    } else
+    {
+        NSLog(@"Я напечатаюсь");
+    }
+
+    // Ветвление с множественным выбором
+    switch (2)
+    {
+        case 0:
+        {
+            NSLog(@"Я никогда не выполнюсь");
+        } break;
+        case 1:
+        {
+            NSLog(@"Я тоже никогда не выполнюсь");
+        } break;
+        default:
+        {
+            NSLog(@"Я напечатаюсь");
+        } break;
+    }
+    
+    // Цикл с предусловием
+    int ii = 0;
+    while (ii < 4)
+    {
+        NSLog(@"%d,", ii++); // ii++ инкрементирует ii после передачи значения
+    } // => напечатает "0," 
+      //               "1,"
+      //               "2,"
+      //               "3,"
+
+    // Цикл со счётчиком
+    int jj;
+    for (jj=0; jj < 4; jj++)
+    {
+        NSLog(@"%d,", jj);
+    } // => напечатает "0," 
+      //               "1,"
+      //               "2,"
+      //               "3,"
+     
+    // Цикл просмотра           
+    NSArray *values = @[@0, @1, @2, @3];
+    for (NSNumber *value in values)
+    {
+        NSLog(@"%@,", value);
+    } // => напечатает "0," 
+      //               "1,"
+      //               "2,"
+      //               "3,"
+
+    // Цикл for для объектов. Может использоваться с любым объектом Objective-C
+    for (id item in values) { 
+        NSLog(@"%@,", item); 
+    } // напечатает => "0," 
+      //           "1,"
+      //           "2,"
+      //           "3,"      
+      
+    // Обработка исключений
+    @try
+    {
+        // Ваше исключение здесь
+        @throw [NSException exceptionWithName:@"FileNotFoundException"
+                            reason:@"Файл не найден в системе" userInfo:nil];
+    } @catch (NSException * e)
+    {
+        NSLog(@"Исключение: %@", e);
+    } @finally
+    {
+        NSLog(@"В конце отводится время для очистки.");
+    } // => напечатает "Исключение: Файл не найден в системе"
+      //               "В конце отводится время для очистки."
+ 
+    // NSError - это полезные объекты для аргументов функции, чтобы заполнить их
+    // пользовательскими ошибками.
+    NSError *error = [NSError errorWithDomain:@"Неправильный эл. адрес." code:4 userInfo:nil];
+ 
+    ///////////////////////////////////////
+    // Объекты
+    ///////////////////////////////////////
+    
+    // Создание объектов через выделение памяти и инициализацию.
+    // Объект не является полнофункциональным пока обе части не выполнятся.
+    MyClass *myObject = [[MyClass alloc] init];
+        
+    // В Objective-C модель ООП базируется на передаче сообщений.
+    // В Objective-C Вы не просто вызваете метод; вы посылаете сообщение.
+    [myObject instanceMethodWithParameter:@"Стив Джобс"];
+
+    // Очищайте память, перед завершением работы программы.
+    [pool drain];
+    
+    // Конец @autoreleasepool
+    }
+    
+    // Конец программы.
+    return 0;
+}
+
+///////////////////////////////////////
+// Классы и функции
+///////////////////////////////////////
+
+// Объявляйте свой класс в файле МойКласс.h
+// Синтаксис объявления:
+// @interface ИмяКласса : ИмяКлассаРодителя <ИмплементируемыеПротоколы>
+// {
+//    тип имя; <= Объявление переменных;
+// }
+// @property тип имя; <= объявление свойств
+// -/+ (тип) Объявление метода(ов).
+// @end
+@interface MyClass : NSObject <MyProtocol> // NSObject - это базовый класс в Objective-C.
+{
+    // Объявления экземпляров переменных (может существовать в файлах интерфейса или реализвации)
+    int count; // По умолчанию защищенный доступ.
+    @private id data; // Приватный доступ (Намного удобнее объявлять в файле реализации)
+    NSString *name;
+}
+// Удобное обозначение для переменных с открытым (public) доступом
+// автоматически генерируется сеттер-метод
+// По умолчанию название сеттер-метода начинается с 'set' с последующим именем
+// переменной из @property
+@property int propInt; // Имя сеттер-метода = 'setPropInt'
+@property (copy) id copyId; // (copy) => Скопировать объект в ходе присвоения.
+// (readonly) => Не позволяет установить значение вне @interface
+@property (readonly) NSString *roString; // Используйте @synthesize 
+                               // в @implementation, чтобы создать аксессор
+// Вы можете настроить геттер и сеттер имена вместо используемого 'set'-имени по умолчанию:
+@property (getter=lengthGet, setter=lengthSet:) int length;
+
+// Методы
++/- (возвращаемый тип)сигнатураМетода:(Параметр типа *)имяПараметра;
+
+// + для методов класса
++ (NSString *)classMethod;
++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight;
+
+// - для методов объекта
+- (NSString *)instanceMethodWithParameter:(NSString *)string;
+- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number;
+
+// Методы-конструктор с аргументом:
+- (id)initWithDistance:(int)defaultDistance;
+// В Objective-C имена методов очень описательные. Всегда имена методов соответствуют своим аргументам
+
+@end // Устанавливает конец интерфейса (interface)
+
+
+// Чтобы обратиться к открытым (public) переменным из файла реализации, @property генерирует сеттер-метод
+// автоматически. Название метода - это 'set' с последующим именем переменной из @property:
+MyClass *myClass = [[MyClass alloc] init]; // создает экземпляр объекта класса MyClass
+[myClass setCount:10]; 
+NSLog(@"%d", [myClass count]); // напечатает => 10
+// Или используйте свой геттер и сеттер методы, которые определены в @interface:
+[myClass lengthSet:32];
+NSLog(@"%i", [myClass lengthGet]); // напечатает => 32
+// Для удобства вы можете использовать точечную нотацию,
+// чтобы установить и получить доступ к переменным объекта:
+myClass.count = 45;
+NSLog(@"%i", myClass.count); // напечатает => 45
+
+// Вызов методов класса:
+NSString *classMethodString = [MyClass classMethod];
+MyClass *classFromName = [MyClass myClassFromName:@"Привет"];
+
+// Вызов методов экземпляра:
+MyClass *myClass = [[MyClass alloc] init]; // Создает экземпляр объекта MyClass
+NSString *stringFromInstanceMethod = [myClass instanceMethodWithParameter:@"Привет"];
+
+// Селекторы
+// Это способ динамически представить методы. Используйте для вызова методов класса, передайте методы
+// через функции, чтобы сказать другим классам, что они должны вызвать их и сохранить методы
+// как переменные
+// SEL - это тип данных. @selector() вернет селектор из предоставленного имени метода
+// methodAParameterAsString:andAParameterAsNumber: - это название метода в MyClass
+SEL selectorVar = @selector(methodAParameterAsString:andAParameterAsNumber:); 
+if ([myClass respondsToSelector:selectorVar]) { // Проверяет содержит ли класс метод
+    // Необходимо установить все аргументы метода в один объект, что отправить его в performSelector-функцию
+    NSArray *arguments = [NSArray arrayWithObjects:@"Привет", @4, nil];
+    [myClass performSelector:selectorVar withObject:arguments]; // Вызывает метод
+} else {
+    // NSStringFromSelector() вернет NSString название метода полученного селектором
+    NSLog(@"MyClass не содержит метод: %@", NSStringFromSelector(selectedVar));
+}
+
+// Имплементируйте методы в файле МойКласс.m:
+@implementation MyClass {
+    long distance; // Переменная экземпляра с закрытым (private) доступом
+    NSNumber height;
+}
+
+// To access a public variable from the interface file, use '_' followed by variable name:
+_count = 5; // References "int count" from MyClass interface
+// Access variables defined in implementation file:
+distance = 18; // References "long distance" from MyClass implementation
+// To use @property variable in implementation, use @synthesize to create accessor variable:
+@synthesize roString = _roString; // _roString available now in @implementation
+
+// Called before calling any class methods or instantiating any objects
++ (void)initialize 
+{
+    if (self == [MyClass class]) {
+        distance = 0;
+    }
+}
+
+// Вызывается при высвобождении памяти под объектом
+- (void)dealloc
+{
+    [height release]; // Если не используется ARC, убедитесь в освобождении переменных объекта класса
+    [super dealloc];  // and call parent class dealloc
+}
+
+// Конструкторы – это способ создания объектов класса.
+// Это конструктор по умолчанию, который вызывается, когда объект инициализируется.
+- (id)init
+{
+    if ((self = [super init])) // 'super' используется для того, чтобы обратиться к методам родительского класса
+    {
+        self.count = 1; // 'self' используется для вызова самого себя
+    }
+    return self;
+}
+// Можно создать конструкторы, которые содержат аргументы:
+- (id)initWithDistance:(int)defaultDistance 
+{
+    distance = defaultDistance;
+    return self;
+}
+
++ (NSString *)classMethod
+{
+    return [[self alloc] init];
+}
+
++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight 
+{
+    height = defaultHeight;
+    return [[self alloc] init];
+}
+
+- (NSString *)instanceMethodWithParameter:(NSString *)string
+{
+    return @"Новая строка";
+}
+
+- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number
+{
+    return @42;
+}
+
+// Objective-C не содержит объявление приватных методов, но вы можете имитировать их.
+// Чтобы сымитировать приватный метод, создайте метод в @implementation, но не в @interface.
+- (NSNumber *)secretPrivateMethod {
+    return @72;
+}
+[self secretPrivateMethod]; // Вызывает приватный метод
+
+// Методы объявленные в МyProtocol (см. далее)
+- (void)myProtocolMethod
+{
+    // операторы
+}
+
+@end // Устанавливает конец реализации (implementation)
+
+///////////////////////////////////////
+// Категории
+///////////////////////////////////////
+// Категория - это группа методов предназначенные для того, чтобы расширить класс. Они позволяют вам добавить новые методы
+// к существующему классу для организационных целей. Это не стоит путать с подклассами.
+// Подклассы предназначены для ИЗМЕНЕНИЯ функциональности объекта пока как категории ДОБАВЛЯЮТ
+// функциональность в объект.
+// Категории позволяют вам:
+// -- Добавлять методы в существующий класс для организационных целей.
+// -- Допускает вам расширять объекты Objective-C классов (напр.: NSString) добавить ваши собственные методы.
+// -- Добавляет возможность создать защищенные и закрытые методы классов. 
+// ПРИМЕЧАНИЕ: Не переопределяйте методы базового класса в категории даже если у вас есть возможность это сделать
+// to. Переопределение методов может привести к ошибкам компиляции позднее между различными категориями и это 
+// нарушает цель категорий, чтобы добавлять только функциональность. Вместо этого подклассы переопределяют методы.
+
+// Здесь простой базовый класс Car.
+@interface Car : NSObject
+
+@property NSString *make;
+@property NSString *color;
+
+- (void)turnOn;
+- (void)accelerate;
+
+@end
+
+// И реализация базового класса Car:
+#import "Car.h"
+
+@implementation Car
+
+@synthesize make = _make;
+@synthesize color = _color;
+
+- (void)turnOn {
+    NSLog(@"Машина заведена.");
+}
+- (void)accelerate {
+    NSLog(@"Ускорение.");
+}
+
+@end
+
+// Теперь, если мы хотели создать грузовой объект, мы должны вместо создания подкласса класса Car, как это будет
+// изменять функциональность Car чтобы вести себя подобно грузовику. Но давайте посмотрим, если мы хотим только добавить
+// функциональность в существующий Car. Хороший пример должен быть чистить автомобиль. Итак мы создадим
+// категорию для добавления его очистительных методов:
+// @interface ИмяФайла: Car+Clean.h (ИмяБазовогоКласса+ИмяКатегории.h)
+#import "Car.h" // Убедитесь в том, что базовый класс импортирован для расширения.
+
+@interface Car (Clean) // Имя категории внутри (), следующие после имени базового класса.
+
+- (void)washWindows; // Названия новых методов, которые мы добавляем в наш объект Car.
+- (void)wax;
+
+@end
+
+// @implementation имя файла: Car+Clean.m (ИмяБазовогоКласса+ИмяКатегории.m)
+#import "Car+Clean.h" // Импортируйте Очистку файл @interface категории.
+
+@implementation Car (Clean)
+
+- (void)washWindows {
+    NSLog(@"Окна промыли.");
+}
+- (void)wax {
+    NSLog(@"Воском натерли.");
+}
+
+@end 
+
+// Любой экземпляр объекта Car имеет возможность воспользоваться категорией. Все, что нужно сделать, это импортировать ее:
+#import "Car+Clean.h" // Импортировать как множество различных категорий, как вы хотите использовать.
+#import "Car.h" // Кроме того, необходимо импортировать базовый класс для использования его оригинальные функциональные возможности.
+
+int main (int argc, const char * argv[]) {
+    @autoreleasepool {
+        Car *mustang = [[Car alloc] init];
+        mustang.color = @"Красный";
+        mustang.make = @"Форд";
+
+        [mustang turnOn]; // Используйте методы из базового класса Car.
+        [mustang washWindows]; // Используйте методы категории Clean из класса Car.
+    }
+    return 0; 
+}
+
+// Objective-C не поддерживает объявление защищенных методов, но вы можете имитировать их.
+// Создайте категорию, содержащую все защищенные методы, затем импортируйте ее только в
+// @implementation-файле класса, относящегося к классу Car:
+@interface Car (Protected) // Наименование категории с помощью 'Protected'
+// дает знать, что методы защищенные.
+
+- (void)lockCar; // Здесь перечисляются методы, которые должны быть созданы
+// только с помощью объектов класса Car.
+
+@end
+// Чтобы воспользоваться защищенными методами, импортируйте категорию, затем реализуйте методы:
+#import "Car+Protected.h" // Запомните, делайте импорт только в файле с @implementation.
+
+@implementation Car 
+
+- (void)lockCar {
+    NSLog(@"Машина закрыта."); // Экземпляры класса Car не могут использовать
+// метод lockCar, потому что он объявлен не в @interface.
+}
+
+@end
+
+///////////////////////////////////////
+// Расширения
+///////////////////////////////////////
+// Расширения позволяют вам переопределять атрибуты свойств и методов
+// с открытым доступом в @interface.
+// @interface имя файла: Shape.h
+@interface Shape : NSObject // Расширение базового класса Shape переопределяет
+                                        // свои поля ниже.
+
+@property (readonly) NSNumber *numOfSides;
+
+- (int)getNumOfSides;
+
+@end
+// Вы можете переопределить numOfSides-переменную или getNumOfSides-метод
+// Внесение изменений с помощью расширения делается следующим образом:
+// @implementation имя файла: Shape.m
+#import "Shape.h"
+// Расширения "живут" в том же файле, где и @implementation класса.
+@interface Shape () // После имени базового класса скобки () объявляют расширение.
+
+@property (copy) NSNumber *numOfSides; // Делает numOfSides-свойство
+             // копирующим (copy) вместо свойства только для чтения (readonly).
+-(NSNumber)getNumOfSides; // Изменяет метод getNumOfSides так,
+                         // чтобы он возвращал объект NSNumber вместо типа int.
+-(void)privateMethod; // Вы также можете создать новый закрытый метод
+                              // внутри расширения.
+
+@end
+// Главный @implementation:
+@implementation Shape
+
+@synthesize numOfSides = _numOfSides;
+
+-(NSNumber)getNumOfSides { // Все операторы внутри расширения
+                                         // должны быть в @implementation.
+    return _numOfSides;
+}
+-(void)privateMethod {
+    NSLog(@"Закрытый метод созданный с помощью расширения.");
+    NSLog(@"Экземпляр Shape не может вызвать этот метод.");
+}
+
+@end
+
+///////////////////////////////////////
+// Протоколы
+///////////////////////////////////////
+// Протокол объявляет методы, которые могут быть реализованы с помощью
+// любого класса. Протоколы сами по себе не являются классами. Они просто
+// определяют интерфейс, который должен быть реализован другими объектами.
+// @protocol имя файла: "CarUtilities.h"
+@protocol CarUtilities <NSObject> // <NSObject> => Имя другого протокола,
+// который включен в этот протокол.
+    @property BOOL engineOn; // Адаптирующий класс должен определить
+// все @synthesize для @property и
+    - (void)turnOnEngine; // определить все методы.
+@end
+// Ниже пример класса, реализующий протокол.
+#import "CarUtilities.h" // Импорт файла с @protocol.
+
+@interface Car : NSObject <CarUtilities> // Внутри <> имя протокола
+// Здесь вам не нужно указывать @property или имена методов для CarUtilities.
+// Они нужны только для @implementation.
+- (void)turnOnEngineWithUtilities:(id <CarUtilities>)car; // Вы также можете
+// указать тип протоколов.
+@end
+// В @implementation нужно реализовать все @property и методы для протокола.
+@implementation Car : NSObject <CarUtilities>
+
+@synthesize engineOn = _engineOn; // Создайте @synthesize-оператор
+// для "@property engineOn".
+
+- (void)turnOnEngine { // Реализуйте turnOnEngine как вам угодно. Протоколы
+// не определят,
+    _engineOn = YES; // как вам реализовать метод, он только требует,
+// чтобы вы реализовали его.
+}
+// Вы можете использовать протокол как данные, если вы знаете, что он реализует
+// методы и переменные.
+- (void)turnOnEngineWithCarUtilities:(id <CarUtilities>)objectOfSomeKind { 
+    [objectOfSomeKind engineOn]; // У вас есть доступ к переменным объекта
+    [objectOfSomeKind turnOnEngine]; // и методам.
+    [objectOfSomeKind engineOn]; // Может или не может быть значение YES. Класс
+// реализует как нужно.
+}
+
+@end
+// Экземпляры класса Car сейчас имеют доступ к протоколу.
+Car *carInstance = [[Car alloc] init];
+[carInstance setEngineOn:NO];
+[carInstance turnOnEngine];
+if ([carInstance engineOn]) {
+    NSLog(@"Двигатель запущен."); // напечатает => "Двигатель запущен."
+}
+// Убедитись в том, что объект типа 'id' реализует протокол перед вызовом методов протокола:
+if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
+    NSLog(@"Не работает, т.к. класс MyClass не реализует протокол CarUtilities.");
+} else if ([carInstance conformsToProtocol:@protocol(CarUtilities)]) {
+    NSLog(@"Работает как класс Car, который реализует протокол CarUtilities.");
+}
+// Категории тоже могут реализовать протоколы:
+// @interface Car (CarCategory) <CarUtilities>
+// Вы можете реализовать много протоколов:
+// @interface Car : NSObject <CarUtilities, CarCleaning>
+// ЗАМЕЧАНИЕ: Если два или более протоколов полагаются друг на друга,
+// убедитесь, что они ранее объявлены:
+#import "Brother.h"
+
+@protocol Brother; // Оператор раннего объявления. Без него компилятор
+// выдаст ошибку.
+
+@protocol Sister <NSObject>
+
+- (void)beNiceToBrother:(id <Brother>)brother;
+
+@end
+
+// Рассмотрите проблему, где протокол Sister полагается на протокол Brother,
+// а Brother полагается на Sister.
+#import "Sister.h"
+
+@protocol Sister; // Эти строки предотвращают рекурсию, решая этим проблему.
+
+@protocol Brother <NSObject>
+ 
+- (void)beNiceToSister:(id <Sister>)sister;
+
+@end
+
+
+///////////////////////////////////////
+// Блоки
+///////////////////////////////////////
+// Блоки - это операторы кода, наподобие функции, которую возможно использовать
+// как данные.
+// Ниже простой блок с целочисленным аргументом, и возвращает аргумент плюс 4.
+int (^addUp)(int n); // Объявите переменную, чтобы сохранить блок.
+void (^noParameterBlockVar)(void); // Пример объявления блока-переменной
+// без аргументов.
+// Блоки имею доступ к переменным в той же области видимости. Но переменные
+// будут только для чтения, и значения переданных в блок станут значением
+// переменной, когда блок создастся.
+int outsideVar = 17; // Если мы редактируем outsideVar после объявления addUp,
+// outsideVar остается равным 17.
+__block long mutableVar = 3; // __block делают переменные перезаписываемыми
+// в блоках, в отличие от outsideVar.
+addUp = ^(int n) { // Удалите (int n) в блоке, чтобы не принимать
+// какие-либо параметры.
+    NSLog(@"Вы можете иметь столько строк в блоке, сколько вы хотели.");
+    NSSet *blockSet; // Также вы можете объявить локальные переменные.
+    mutableVar = 32; // Присвоить новое значение к __block-переменной.
+    return n + outsideVar; // Необязательный оператор возврата.
+}
+int addUp = add(10 + 16); // Вызывает блок кода с аргументами.
+// Блоки часто используются как аргументы функции, чтобы позже их вызвать, или
+// как функции обратного вызова (callbacks).
+@implementation BlockExample : NSObject 
+ 
+- (void)runBlock:(void (^)(NSString))block {
+    NSLog(@"В аргументе блок ничего не возвращает и принимает NSString-объект.");
+    block(@"Аргумент передан блоку на исполнение."); // Вызов блока.
+}
+
+@end
+ 
+ 
+///////////////////////////////////////
+// Управление памятью
+///////////////////////////////////////
+/* 
+Для каждого объекта, используемого в приложении, должна быть выделена память
+для таких объектов. Когда приложение прекращает использование объекта, память
+должна быть освобождена, чтобы гарантировать эффективность приложения.
+Objective-C не использует сборщик мусора, а вместо этого применяет подсчет ссылок.
+Пока существует по крайней мере одна ссылка на объект (также называется
+"владение" объектом), то объект будет доступен к использованию (еще известно
+как "право владения").
+
+Когда экземпляр владеет объектом, его ссылка увеличивается на один. Когда
+объекта освобождается, счетчик ссылки уменьшается на один. Когда счетчик ссылки
+равен нулю, объект удаляется из памяти.
+
+Над всеми объектами взаимодействуют, следуя паттерну:
+(1) создание объекта, (2) использование объекта, (3) затем освобождение объекта из памяти.
+*/
+
+MyClass *classVar = [MyClass alloc]; // 'alloc' устанавливает счетчик ссылки
+// объекта classVar на 1 и возвращает указатель на объект.
+[classVar release]; // Уменьшает счетчик ссылки объекта classVar
+// 'retain' заявляет право собственности на существующий экземпляр объекта
+// и увеличивает счетчик ссылки. Затем вернет указатель на объект.
+MyClass *newVar = [classVar retain]; // Если classVar освободится, объект
+// останется в памяти, потому что newVar - владелец
+[classVar autorelease]; // Удалит право на владение объектом
+// в конце @autoreleasepool блока. Вернет указатель на объект.
+
+// @property может использовать 'retain' и 'assign' тоже для маленького
+// удобного определения
+@property (retain) MyClass *instance; // Освободит старое значение и сохранит
+// одно новое (строгая ссылка)
+@property (assign) NSSet *set; // Укажет на новое значение
+// без сохранения/освобождения старого значения (слабая ссылка)
+
+// Автоматический подсчет ссылок (ARC)
+// Управление памятью может быть трудным, поэтому в Xcode 4.2 и iOS 4 введен
+// автоматический подсчет ссылок (ARC).
+// ARC - это особенность компилятора, который помещает "retain", "release"
+// и "autorelease" автоматически за вас тогда, когда используется ARC,
+// вам не нужно больше обращаться к "retain", "relase" или "autorelease"
+MyClass *arcMyClass = [[MyClass alloc] init];
+// ... код, использующий объект arcMyClass
+// Без ARC, вам нужно было бы вызвать: [arcMyClass release] после того, как вы
+// завершите работу с объектом arcMyClass. Но с ARC,
+// теперь этого не нужно делать. Он будет помещать release-вызов за вас
+
+// Что касается 'assign' и 'retain' @property атрибутов, в ARC вы должны
+// использовать 'weak' и 'strong'
+@property (weak) MyClass *weakVar; // 'weak' не принимает право на владение
+// объектом. Если исходный счетчик ссылки экземпляра обнуляется,
+// weakVar-свойство автоматически примет значение nil,
+// во избежание падения приложения
+@property (strong) MyClass *strongVar; // 'strong' принимает право на владение
+// объектом. Гарантирует, что объект останится в памяти для использования
+
+// Для обычных переменных (не объявленных с помощью @property), используйте
+// следующий способ:
+__strong NSString *strongString; // По умолчанию. Переменная сохраняется в памяти,
+// пока она не покинет область видимости
+__weak NSSet *weakSet; // Слабая ссылка на существующий объект. Когда существующий
+// объект освобождается, weakSet принимает nil
+__unsafe_unretained NSArray *unsafeArray; // Похож на __weak, но unsafeArray
+// не принимает nil, когда существующий объект освобождается
+
+```
+## На почитать
+
+[Wikipedia Objective-C](http://en.wikipedia.org/wiki/Objective-C)
+
+[Learning Objective-C](http://developer.apple.com/library/ios/referencelibrary/GettingStarted/Learning_Objective-C_A_Primer/)
+
+[iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)
+
+[iOS разработчик: Обзор книг для новичка](http://habrahabr.ru/post/166213/)
+
+[Хочешь быть iOS разработчиком? Будь им!](http://www.pvsm.ru/ios/12662/print/)
diff --git a/ru-ru/paren-ru.html.markdown b/ru-ru/paren-ru.html.markdown
new file mode 100644
index 00000000..9b801e46
--- /dev/null
+++ b/ru-ru/paren-ru.html.markdown
@@ -0,0 +1,196 @@
+---
+language: Paren
+filename: learnparen-ru.paren
+contributors:
+  - ["KIM Taegyoon", "https://github.com/kimtg"]
+translators:
+  - ["Dmitry Bessonov", "https://github.com/TheDmitry"]
+lang: ru-ru
+---
+
+[Paren](https://bitbucket.org/ktg/paren) - это диалект языка Лисп. Он спроектирован как встроенный язык.
+
+Примеры взяты <http://learnxinyminutes.com/docs/racket/>.
+
+```scheme
+;;; Комментарии
+# комментарии
+
+;; Однострочные комментарии начинаются с точки с запятой или символа решетки
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 1. Примитивные типы данных и операторы
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Числа
+123 ; int
+3.14 ; double
+6.02e+23 ; double
+(int 3.14) ; => 3 : int
+(double 123) ; => 123 : double
+
+;; Обращение к функции записывается так: (f x y z ...),
+;; где f - функция, а x, y, z, ... - операнды
+;; Если вы хотите создать буквальный список данных, используйте (quote), чтобы
+;; предотвратить ненужные вычисления
+(quote (+ 1 2)) ; => (+ 1 2)
+;; Итак, некоторые арифметические операции
+(+ 1 1)  ; => 2
+(- 8 1)  ; => 7
+(* 10 2) ; => 20
+(^ 2 3) ; => 8
+(/ 5 2) ; => 2
+(% 5 2) ; => 1
+(/ 5.0 2) ; => 2.5
+
+;;; Логический тип
+true ; обозначает истину
+false ; обозначает ложь
+(! true) ; => false
+(&& true false (prn "досюда не доходим")) ; => false
+(|| false true (prn "досюда не доходим")) ; => true
+
+;;; Символы - это числа (int).
+(char-at "A" 0) ; => 65
+(chr 65) ; => "A"
+
+;;; Строки - это массив символов с фиксированной длиной.
+"Привет, мир!"
+"Benjamin \"Bugsy\" Siegel"   ; обратная косая черта экранирует символ
+"Foo\tbar\r\n" ; включает управляющие символы в стиле Cи: \t \r \n
+
+;; Строки тоже могут объединяться!
+(strcat "Привет " "мир!") ; => "Привет мир!"
+
+;; Строка может трактоваться подобно списку символов
+(char-at "Apple" 0) ; => 65
+
+;; Выводить информацию достаточно легко
+(pr "Я" "Paren. ") (prn "Приятно познакомиться!")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 2. Переменные
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Вы можете создать или инициализировать переменную, используя (set)
+;; имя переменной может содержать любой символ, исключая: ();#"
+(set some-var 5) ; => 5
+some-var ; => 5
+
+;; Обращение к переменной, прежде не определенной, вызовет исключение
+; x ; => Неизвестная переменная: x : nil
+
+;; Локальное связывание: Используйте лямбда-вычисление! `a' и `b' связывается
+;; с `1' и `2' только в пределах (fn ...)
+((fn (a b) (+ a b)) 1 2) ; => 3
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Коллекции
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Списки
+
+;; Списки подобны динамическому массиву (vector). (произвольный доступ равен O(1).)
+(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3)
+;; `list' - это удобный конструктор списков с переменным числом элементов
+(list 1 2 3) ; => (1 2 3)
+;; и quote может также использоваться для литеральных значений списка
+(quote (+ 1 2)) ; => (+ 1 2)
+
+;; Можно еще использовать `cons', чтобы добавить элемент в начало списка
+(cons 0 (list 1 2 3)) ; => (0 1 2 3)
+
+;; Списки являются основным типом, поэтому для них предусмотрено *много* функций
+;; немного примеров из них:
+(map inc (list 1 2 3))          ; => (2 3 4)
+(filter (fn (x) (== 0 (% x 2))) (list 1 2 3 4))    ; => (2 4)
+(length (list 1 2 3 4))     ; => 4
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Функции
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Используйте `fn' для создания функций.
+;; Функция всегда возвращает значение своего последнего выражения
+(fn () "Привет Мир") ; => (fn () Привет Мир) : fn
+
+;; Используйте скобки, чтобы вызвать все функции, в том числе лямбда-выражение
+((fn () "Привет Мир")) ; => "Привет Мир"
+
+;; Назначить функцию переменной
+(set hello-world (fn () "Привет Мир"))
+(hello-world) ; => "Привет Мир"
+
+;; Вы можете сократить это, используя синтаксический сахар определения функции:
+(defn hello-world2 () "Привет Мир")
+
+;; Как и выше, () - это список аргументов для функции
+(set hello
+  (fn (name)
+    (strcat "Привет " name)))
+(hello "Стив") ; => "Привет Стив"
+
+;; ... или, что эквивалентно, используйте синтаксический сахар определения:
+(defn hello2 (name)
+  (strcat "Привет " name))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 4. Равенство
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; для чисел используйте `=='
+(== 3 3.0) ; => true
+(== 2 1) ; => false
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 5. Поток управления
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Условный оператор
+
+(if true               ; проверка выражения
+    "это - истина"   ; тогда это выражение
+    "это - ложь") ; иначе другое выражение
+; => "это - истина"
+
+;;; Циклы
+
+;; Цикл for для чисел
+;; (for ИДЕНТИФИКАТОР НАЧАЛО КОНЕЦ ШАГ ВЫРАЖЕНИЕ ..)
+(for i 0 10 2 (pr i "")) ; => печатает 0 2 4 6 8 10
+(for i 0.0 10 2.5 (pr i "")) ; => печатает 0 2.5 5 7.5 10
+
+;; Цикл while
+((fn (i)
+  (while (< i 10)
+    (pr i)
+    (++ i))) 0) ; => печатает 0123456789
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 6. Изменение
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Используйте `set', чтобы назначить новое значение переменной или памяти
+(set n 5) ; => 5
+(set n (inc n)) ; => 6
+n ; => 6
+(set a (list 1 2)) ; => (1 2)
+(set (nth 0 a) 3) ; => 3
+a ; => (3 2)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 7. Макросы
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Макросы позволяют вам расширять синтаксис языка.
+;; Paren-макросы легкие.
+;; Фактически, (defn) - это макрос.
+(defmacro setfn (name ...) (set name (fn ...)))
+(defmacro defn (name ...) (def name (fn ...)))
+
+;; Давайте добавим инфиксную нотацию
+(defmacro infix (a op ...) (op a ...))
+(infix 1 + 2 (infix 3 * 4)) ; => 15
+
+;; Макросы приводят к неясному коду, т.е. вы можете затереть существующие переменные!
+;; Они являются кодопреобразующей конструкцией.
+```
diff --git a/ru-ru/php-ru.html.markdown b/ru-ru/php-ru.html.markdown
new file mode 100644
index 00000000..53b2f916
--- /dev/null
+++ b/ru-ru/php-ru.html.markdown
@@ -0,0 +1,663 @@
+---
+language: PHP
+contributors:
+    - ["Malcolm Fell", "http://emarref.net/"]
+    - ["Trismegiste", "https://github.com/Trismegiste"]
+translators:
+    - ["SlaF", "https://github.com/SlaF"]
+lang: ru-ru
+filename: learnphp-ru.php
+---
+
+Этот документ описывает версию PHP 5 и выше.
+
+```php
+<?php // PHP код должен быть заключен в теги <?php
+
+// Если ваш файл содержит только PHP код, то можно
+// пропустить закрывающийся ?>
+
+// А так начинаются комментарии
+
+# Это тоже комментарий но // предпочтительнее
+
+/*
+	Окруженный /* и */ текст превращается
+	в многострочный комментарий
+*/
+
+// Используйте "echo" или "print" для вывода.
+print('Hello '); // Напечатать "Hello " без перевода строки
+
+// () необязательно применять для print и echo
+echo "World\n"; // Печатать "World" и перейти на новую строку.
+// (все утверждения должны заканчиваться ;)
+
+// Любые символы за пределами закрывающегося тега выводятся автоматически:
+?>
+Hello World Again!
+<?php
+
+
+/************************************
+ * Типы и Переменные
+ */
+
+// Переменные начинаются с символа $.
+// Правильное имя переменной начинается с буквы или знака подчеркивания,
+// и может содержать любые цифры, буквы, или знаки подчеркивания.
+// Не рекомендуется использовать кирилические символы в именах (прим. пер.)
+
+// Логические значения нечувствительны к регистру
+$boolean = true;  // или TRUE или True
+$boolean = false; // или FALSE или False
+
+// Целые числа
+$int1 = 12;   // => 12
+$int2 = -12;  // => -12-
+$int3 = 012;  // => 10 (ведущий 0 обозначает восьмеричное число)
+$int4 = 0x0F; // => 15 (ведущие символы 0x означает шестнадцатеричное число)
+
+// Дробные числа
+$float = 1.234;
+$float = 1.2e3;
+$float = 7E-10;
+
+// Арифметика
+$sum        = 1 + 1; // 2
+$difference = 2 - 1; // 1
+$product    = 2 * 2; // 4
+$quotient   = 2 / 1; // 2
+
+// Арифметические сокращения
+$number = 0;
+$number += 1;      // Увеличивает $number на 1
+echo $number++;    // Печатает 1 (инкрементируется после вывода)
+echo ++$number;    // Печатает 3 (инкрементируется до вывода)
+$number /= $float; // Делится и результат присваивается $number
+
+// Строки должны быть заключены в одинарные кавычки;
+$sgl_quotes = '$String'; // => '$String'
+
+// Избегайте двойных кавычек за исключением случаев интерполирования переменной
+$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'
+
+// Специальные (escape) символы работают только в двойных кавычках
+$escaped   = "This contains a \t tab character.";
+$unescaped = 'This just contains a slash and a t: \t';
+
+// Заключайте переменные в фигурные скобки если это необходимо
+$money = "I have $${number} in the bank.";
+
+// Начиная с PHP 5.3, синтаксис nowdocs может использоваться для
+// неинтерполированного многострочного текста
+$nowdoc = <<<'END'
+Multi line
+string
+END;
+
+// Heredocs поддерживает интерполяцию переменных
+$heredoc = <<<END
+Multi line
+$sgl_quotes
+END;
+
+// Строки соединяются при помощи .
+echo 'This string ' . 'is concatenated';
+
+
+/********************************
+ * Константы
+ */
+ 
+// Константа определяется при помощи define()
+// и никогда не может быть изменена во время выполнения программы!
+
+// Правильное имя константы начинается с буквы или символа подчеркивания,
+// и содержит любое колличество букв, цифр и знаков подчеркивания.
+define("FOO", "something");
+
+// Доступ к константе возможен через прямое указание её имени
+echo 'This outputs '.FOO;
+
+/********************************
+ * Массивы
+ */
+
+// Все массивы в PHP - это ассоциативные массивы или хеши,
+
+// Ассоциативные массивы, известные в других языках как хеш-карты.
+
+// Работает во всех версиях РHP
+$associative = array('One' => 1, 'Two' => 2, 'Three' => 3);
+
+// В PHP 5.4 появился новый синтаксис
+$associative = ['One' => 1, 'Two' => 2, 'Three' => 3];
+
+echo $associative['One']; // печатает 1
+
+// Список тоже содержит целочисленные ключи
+$array = ['One', 'Two', 'Three'];
+echo $array[0]; // => "One"
+
+
+/********************************
+ * Вывод
+ */
+
+echo('Hello World!');
+// Печатает Hello World! на stdout.
+// Stdout это веб-страница запущенная в браузере.
+
+print('Hello World!'); // Аналогично echo
+
+// echo - это конструкция языка, вы можете опустить скобки.
+echo 'Hello World!';
+print 'Hello World!'; // Выводит Hello World!
+
+$paragraph = 'paragraph';
+
+echo 100;        // Печать скалярной переменной напрямую
+echo $paragraph; // или печать переменной
+
+// Если короткие теги разрешены, или ваша версия PHP >= 5.4
+// вы можете использовать сокращенный синтаксис echo
+?>
+<p><?= $paragraph ?></p>
+<?php
+
+$x = 1;
+$y = 2;
+$x = $y; // $x теперь содержит значение переменной $y
+$z = &$y;
+// $z содержит ссылку на $y. Изменение значения $z затронет значение $y и наоборот.
+// Значение $x остается неизменным. 
+
+echo $x; // => 2
+echo $z; // => 2
+$y = 0;
+echo $x; // => 2
+echo $z; // => 0
+
+
+/********************************
+ * Логические выражения
+ */
+$a = 0;
+$b = '0';
+$c = '1';
+$d = '1';
+
+// Утверждение (assert) выдает предупреждение если аргумент не true
+
+// Эти сравнения всегда будут истинными, даже если типы будут различаться
+assert($a == $b); // "равно"
+assert($c != $a); // "не равно"
+assert($c <> $a); // другое обозначение "не равно"
+assert($a < $c); // меньше
+assert($c > $b); // больше
+assert($a <= $b); // меньше или равно
+assert($c >= $d); // больше или равно
+
+// Следующие утверждения истинны если переменные имеют одинаковый тип.
+assert($c === $d);
+assert($a !== $d);
+assert(1 == '1');
+assert(1 !== '1');
+
+// Переменные могут изменять тип, в зависимости от их использования.
+$integer = 1;
+echo $integer + $integer; // => 2
+
+$string = '1';
+echo $string + $string; // => 2 (строка превращается в число)
+
+// Выводится 0 по той причине, что оператор + не может привести строку 'one' к
+// числовому типу
+$string = 'one';
+echo $string + $string; // => 0
+
+// Приведение типов (type casting) может быть использовано для преобразование
+// переменной в другой тип
+$boolean = (boolean) 1; // => true
+
+$zero = 0;
+$boolean = (boolean) $zero; // => false
+
+// Также существуют функции выполняющие приведение типов
+$integer = 5;
+$string = strval($integer);
+$float = floatval($integer);
+
+$var = null; // Null
+
+// И похожая по действию функция
+$integer = 10;
+$boolen = settype($integer, "string") // теперь $integer имеет строковый тип
+
+// settype возвращает true - если преобразование удалось и false в противном случае
+
+/********************************
+ * Управляющие структуры
+ */
+
+if (true) {
+    print 'I get printed';
+}
+
+if (false) {
+    print 'I don\'t';
+} else {
+    print 'I get printed';
+}
+
+if (false) {
+    print 'Does not get printed';
+} elseif(true) {
+    print 'Does';
+}
+
+// Тернарный оператор
+print (false ? 'Does not get printed' : 'Does');
+
+$x = 0;
+if ($x === '0') {
+    print 'Does not print';
+} elseif($x == '1') {
+    print 'Does not print';
+} else {
+    print 'Does print';
+}
+
+// Альтернативный синтаксис полезный для шаблонов
+?>
+
+<?php if ($x): ?>
+This is displayed if the test is truthy.
+<?php else: ?>
+This is displayed otherwise.
+<?php endif; ?>
+
+<?php
+
+// Использование switch.
+switch ($x) {
+    case '0':
+        print 'Switch does type coercion';
+        break; // You must include a break, or you will fall through
+               // to cases 'two' and 'three'
+    case 'two':
+    case 'three':
+        // Do something if $variable is either 'two' or 'three'
+        break;
+    default:
+        // Do something by default
+}
+
+// Циклы: while, do...while и for
+$i = 0;
+while ($i < 5) {
+    echo $i++;
+}; // Prints "01234"
+
+echo "\n";
+
+$i = 0;
+do {
+    echo $i++;
+} while ($i < 5); // Prints "01234"
+
+echo "\n";
+
+for ($x = 0; $x < 10; $x++) {
+    echo $x;
+} // Prints "0123456789"
+
+echo "\n";
+
+$wheels = ['bicycle' => 2, 'car' => 4];
+
+// Циклы foreach могут обходить массивы
+foreach ($wheels as $wheel_count) {
+    echo $wheel_count;
+} // Prints "24"
+
+echo "\n";
+
+// Вы можете обходить как ключи, так и их значения
+foreach ($wheels as $vehicle => $wheel_count) {
+    echo "A $vehicle has $wheel_count wheels";
+}
+
+echo "\n";
+
+$i = 0;
+while ($i < 5) {
+    if ($i === 3) {
+        break; // Exit out of the while loop
+    }
+    echo $i++;
+} // Prints "012"
+
+for ($i = 0; $i < 5; $i++) {
+    if ($i === 3) {
+        continue; // Skip this iteration of the loop
+    }
+    echo $i;
+} // Prints "0124"
+
+
+/********************************
+ * Функции
+ */
+
+// Определение функции:
+function my_function () {
+  return 'Hello';
+}
+
+echo my_function(); // => "Hello"
+
+// Правильное имя функции начинается с буквы или символа подчеркивания
+// и состоит из букв, цифр или знаков подчеркивания.
+
+function add ($x, $y = 1) { // $y по умолчанию равно 1
+  $result = $x + $y;
+  return $result;
+}
+
+echo add(4); // => 5
+echo add(4, 2); // => 6
+
+// $result недоступна за пределами функции
+// print $result; // Выдает предупреждение
+
+// Начиная с PHP 5.3 вы можете объявлять анонимные функции:
+$inc = function ($x) {
+  return $x + 1;
+};
+
+echo $inc(2); // => 3
+
+function foo ($x, $y, $z) {
+  echo "$x - $y - $z";
+}
+
+// Функции могут возвращать функции
+function bar ($x, $y) {
+  // Используйте 'use' для передачи внешних переменных
+  return function ($z) use ($x, $y) {
+    foo($x, $y, $z);
+  };
+}
+
+$bar = bar('A', 'B');
+$bar('C'); // Prints "A - B - C"
+
+// Вы можете вызывать именованные функции используя строки
+$function_name = 'add';
+echo $function_name(1, 2); // => 3
+// Полезно для программного определения запущенной функции.
+// Или используйте call_user_func(callable $callback [, $parameter [, ... ]]);
+
+
+/********************************
+ * Includes
+ */
+
+<?php
+// PHP код внутри включаемого файла должен начинаться с тега PHP.
+
+include 'my-file.php';
+// Код в файле my-file.php теперь доступен в текущем в текущем пространстве имен.
+// Если файл не удалось включить, будет выдано предупреждение.
+
+include_once 'my-file.php';
+// Если код в файле my-file.php уже был включен, он не будет включен повторно.
+// Это предотвращает ошибку повторного включения файла.
+
+require 'my-file.php';
+require_once 'my-file.php';
+
+// Same as include(), except require() will cause a fatal error if the
+// file cannot be included.
+// Действует также как и include(), но если файл не удалось подключить,
+// функция выдает неисправимую ошибку
+
+// Содержимое файла my-include.php:
+<?php
+
+return 'Anything you like.';
+// Конец файла
+
+// Эти функции могут также возвращать значения.
+$value = include 'my-include.php';
+
+// Имена файлов содержат их путь в файловой системе, или если передано просто
+// имя файла, PHP обращается к директиве include_path. Если файл не найден в
+// include_path, предпринимается попытка поиска в папке, где выполняется скрипт
+// или в текущей рабочей директории. Если не в одном из этих мест файл не
+// найден - выдается ошибка
+/* */
+
+/********************************
+ * Классы
+ */
+
+// Классы определяются при помощи ключевого слова "class"
+
+class MyClass
+{
+    const MY_CONST      = 'value'; // A constant
+
+    static $staticVar   = 'static';
+
+    // Properties must declare their visibility
+    public $property    = 'public';
+    public $instanceProp;
+    protected $prot = 'protected'; // Accessible from the class and subclasses
+    private $priv   = 'private';   // Accessible within the class only
+
+    // Create a constructor with __construct
+    public function __construct($instanceProp) {
+        // Access instance variables with $this
+        $this->instanceProp = $instanceProp;
+    }
+
+    // Methods are declared as functions inside a class
+    public function myMethod()
+    {
+        print 'MyClass';
+    }
+
+    final function youCannotOverrideMe()
+    {
+    }
+
+    public static function myStaticMethod()
+    {
+        print 'I am static';
+    }
+}
+
+echo MyClass::MY_CONST;    // Выведет 'value';
+echo MyClass::$staticVar;  // Выведет 'static';
+MyClass::myStaticMethod(); // Выведет 'I am static';
+
+// Новый экземпляр класса используя new
+$my_class = new MyClass('An instance property');
+
+// Если аргументы отсутствуют, можно не ставить круглые скобки
+
+// Доступ к членам класса используя ->
+echo $my_class->property;     // => "public"
+echo $my_class->instanceProp; // => "An instance property"
+$my_class->myMethod();        // => "MyClass"
+
+// Наследование классов используя "extends"
+class MyOtherClass extends MyClass
+{
+    function printProtectedProperty()
+    {
+        echo $this->prot;
+    }
+
+    // Override a method
+    function myMethod()
+    {
+        parent::myMethod();
+        print ' > MyOtherClass';
+    }
+}
+
+$my_other_class = new MyOtherClass('Instance prop');
+$my_other_class->printProtectedProperty(); // => Выведет "protected"
+$my_other_class->myMethod();               // Выведет "MyClass > MyOtherClass"
+
+final class YouCannotExtendMe
+{
+}
+
+// Вы можете использовать "магические методы" для создания геттеров и сеттеров
+class MyMapClass
+{
+    private $property;
+
+    public function __get($key)
+    {
+        return $this->$key;
+    }
+
+    public function __set($key, $value)
+    {
+        $this->$key = $value;
+    }
+}
+
+$x = new MyMapClass();
+echo $x->property; // Будет использован метод __get()
+$x->property = 'Something'; // Будет использован метод __set()
+
+// Классы могут быть абстрактными (используя ключевое слово abstract)
+// или реализовывать интерфейсы (используя ключевое слово implements).
+// Интерфейсы определяются при помощи ключевого слова interface
+
+interface InterfaceOne
+{
+    public function doSomething();
+}
+
+interface InterfaceTwo
+{
+    public function doSomethingElse();
+}
+
+// Интерфейсы могут быть расширены
+interface InterfaceThree extends InterfaceTwo
+{
+    public function doAnotherContract();
+}
+
+abstract class MyAbstractClass implements InterfaceOne
+{
+    public $x = 'doSomething';
+}
+
+class MyConcreteClass extends MyAbstractClass implements InterfaceTwo
+{
+    public function doSomething()
+    {
+        echo $x;
+    }
+
+    public function doSomethingElse()
+    {
+        echo 'doSomethingElse';
+    }
+}
+
+// Классы могут реализовывать более одного интерфейса
+class SomeOtherClass implements InterfaceOne, InterfaceTwo
+{
+    public function doSomething()
+    {
+        echo 'doSomething';
+    }
+
+    public function doSomethingElse()
+    {
+        echo 'doSomethingElse';
+    }
+}
+
+
+/********************************
+ * Трейты
+ */
+
+// Трейты появились в PHP 5.4.0 и объявляются при помощи ключевого слова trait
+
+trait MyTrait
+{
+    public function myTraitMethod()
+    {
+        print 'I have MyTrait';
+    }
+}
+
+class MyTraitfulClass
+{
+    use MyTrait;
+}
+
+$cls = new MyTraitfulClass();
+$cls->myTraitMethod(); // Prints "I have MyTrait"
+
+
+/********************************
+ * Пространства имен
+ */
+
+// Это секция особая, ведь объявление пространства имен
+// должно быть самым первым в файле. Позвольте сделать вид, что это не так
+
+<?php
+
+// По умолчанию, классы существуют в глобальном пространстве имен и могут быть
+// вызваны с обратным слешем.
+
+$cls = new \MyClass();
+
+// Задание пространства имен файла
+namespace My\Namespace;
+
+class MyClass
+{
+}
+
+// (из другого файла)
+$cls = new My\Namespace\MyClass;
+
+// Или внутри другого пространства имен.
+namespace My\Other\Namespace;
+
+use My\Namespace\MyClass;
+
+$cls = new MyClass();
+
+// Или вы можете создать псевдоним для пространства имен:
+namespace My\Other\Namespace;
+
+use My\Namespace as SomeOtherNamespace;
+
+$cls = new SomeOtherNamespace\MyClass();
+
+*/
+
+```
+
+## Смотрите также:
+Посетите страницу [официальной документации PHP](http://www.php.net/manual/) для справки. 
+Если вас интересуют полезные приемы использования PHP посетите [PHP The Right Way](http://www.phptherightway.com/).
+Если вы раньше пользовались языком с хорошей организацией пакетов, посмотрите [Composer](http://getcomposer.org/).
+Для изучения стандартов использования языка посетите PHP Framework Interoperability Group's [PSR standards](https://github.com/php-fig/fig-standards). 
diff --git a/ru-ru/python-ru.html.markdown b/ru-ru/python-ru.html.markdown
new file mode 100644
index 00000000..a0e2b474
--- /dev/null
+++ b/ru-ru/python-ru.html.markdown
@@ -0,0 +1,640 @@
+---
+language: python
+lang: ru-ru
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+translators:
+    - ["Yury Timofeev", "http://twitter.com/gagar1n"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+filename: learnpython-ru.py
+---
+
+Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из
+самых популярных языков. Я влюбился в Python за понятный и доходчивый синтаксис  — это
+почти исполняемый псевдокод.
+
+С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh)
+или louiedinh [at] [почтовый сервис Google]
+
+Замечание: Эта статья относится к Python 2.7, но должно работать и в других версиях Python 2.x.
+Чтобы изучить Python 3.x, обратитесь к статье по Python 3.
+
+```python
+# Однострочные комментарии начинаются с символа решётки.
+""" Многострочный текст может быть 
+    записан, используя 3 знака " и обычно используется
+    в качестве встроенной документации
+"""
+
+####################################################
+## 1. Примитивные типы данных и операторы
+####################################################
+
+# У вас есть числа
+3 #=> 3
+
+# Математика работает вполне ожидаемо
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# А вот деление немного сложнее. В этом случае происходит деление 
+# целых чисел, и результат автоматически округляется в меньшую сторону.
+5 / 2 #=> 2
+
+# Чтобы делить правильно, сначала нужно немного узнать о числах
+# с плавающей запятой.
+2.0     # Это число с плавающей запятой
+11.0 / 4.0 #=> 2.75 Вооот... Так гораздо лучше
+
+# Результат целочисленного деления округляется в меньшую сторону
+# как для положительных, так и для отрицательных чисел.
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # работает и для чисел с плавающей запятой
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
+
+# Остаток от деления
+7 % 3 # => 1
+
+# Возведение в степень
+2**4 # => 16
+
+# Приоритет операций указывается скобками
+(1 + 3) * 2 #=> 8
+
+# Логические операторы
+# Обратите внимание: ключевые слова «and» и «or» чувствительны к регистру букв
+True and False #=> False
+False or True #=> True
+
+# Обратите внимание, что логические операторы используются и с целыми числами
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
+
+# Для отрицания используется ключевое слово not
+not True #=> False
+not False #=> True
+
+# Равенство — это ==
+1 == 1 #=> True
+2 == 1 #=> False
+
+# Неравенство — это !=
+1 != 1 #=> False
+2 != 1 #=> True
+
+# Ещё немного сравнений
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
+
+# Сравнения могут быть записаны цепочкой!
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
+
+# Строки определяются символом " или '
+"Это строка."
+'Это тоже строка.'
+
+# И строки тоже можно складывать!
+"Привет " + "мир!" #=> "Привет мир!"
+
+# ... или умножать
+"Привет" * 3  # => "ПриветПриветПривет"
+
+# Со строкой можно работать, как со списком символов
+"Это строка"[0] #=> 'Э'
+
+# Символ % используется для форматирования строк, например:
+"%s могут быть %s" % ("строки", "интерполированы")
+
+# Новый способ форматирования строк — использование метода format.
+# Это предпочитаемый способ.
+"{0} могут быть {1}".format("строки", "форматированы")
+
+# Если вы не хотите считать, можете использовать ключевые слова.
+"{name} хочет есть {food}".format(name="Боб", food="лазанью")
+
+# None является объектом
+None #=> None
+
+# Не используйте оператор равенства '=='' для сравнения 
+# объектов с None. Используйте для этого «is»
+"etc" is None #=> False
+None is None  #=> True
+
+# Оператор 'is' проверяет идентичность объектов. Он не 
+# очень полезен при работе с примитивными типами, но 
+# зато просто незаменим при работе с объектами.
+
+# None, 0 и пустые строки/списки равны False.
+# Все остальные значения равны True
+0 == False  #=> True
+"" == False #=> True
+
+
+####################################################
+## 2. Переменные и коллекции
+####################################################
+
+# В Python есть оператор print, доступный в версиях 2.x, но удалённый в версии 3
+print "Я Python. Приятно познакомиться!"
+# В Python также есть функция print(), доступная в версиях 2.7 и 3,
+# Но для версии 2.7 нужно добавить следующий импорт модуля (раскомментируйте)):
+# from __future__ import print_function
+print("Я тоже Python! ")
+
+# Объявлять переменные перед инициализацией не нужно.
+some_var = 5    # По соглашению используется нижний_регистр_с_подчёркиваниями
+some_var #=> 5
+
+# При попытке доступа к неинициализированной переменной
+# выбрасывается исключение.
+# См. раздел «Поток управления» для информации об исключениях.
+some_other_var  # Выбрасывает ошибку именования
+
+# if может быть использован как выражение
+"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
+
+# Списки хранят последовательности
+li = []
+# Можно сразу начать с заполненного списка
+other_li = [4, 5, 6]
+
+# Объекты добавляются в конец списка методом append
+li.append(1)    # [1]
+li.append(2)    # [1, 2]
+li.append(4)    # [1, 2, 4]
+li.append(3)    # [1, 2, 4, 3]
+# И удаляются с конца методом pop
+li.pop()        #=> возвращает 3 и li становится равен [1, 2, 4]
+# Положим элемент обратно
+li.append(3)    # [1, 2, 4, 3].
+
+# Обращайтесь со списком, как с обычным массивом
+li[0] #=> 1
+# Присваивайте новые значения уже инициализированным индексам с помощью =
+li[0] = 42
+li[0]  # => 42
+li[0] = 1  # Обратите внимание: возвращаемся на исходное значение
+# Обратимся к последнему элементу
+li[-1] #=> 3
+
+# Попытка выйти за границы массива приведёт к ошибке индекса
+li[4] # Выдаёт IndexError
+
+# Можно обращаться к диапазону, используя так называемые срезы
+# (Для тех, кто любит математику, это называется замкнуто-открытый интервал).
+li[1:3] #=> [2, 4]
+# Опускаем начало
+li[2:] #=> [4, 3]
+# Опускаем конец
+li[:3] #=> [1, 2, 4]
+# Выбираем каждый второй элемент
+li[::2]   # =>[1, 4]
+# Переворачиваем список
+li[::-1]   # => [3, 4, 2, 1]
+# Используйте сочетания всего вышеназванного для выделения более сложных срезов
+# li[начало:конец:шаг]
+
+# Удаляем произвольные элементы из списка оператором del
+del li[2] # li теперь [1, 2, 3]
+
+# Вы можете складывать, или, как ещё говорят, конкатенировать списки
+li + other_li #=> [1, 2, 3, 4, 5, 6]  — Замечание: li и other_li не изменяются
+# Обратите внимание: значения li и other_li при этом не изменились.
+
+# Объединять списки можно методом extend
+li.extend(other_li) # Теперь li содержит [1, 2, 3, 4, 5, 6]
+
+# Проверить элемент на вхождение в список можно оператором in
+1 in li #=> True
+
+# Длина списка вычисляется функцией len
+len(li) #=> 6
+
+
+# Кортежи — это такие списки, только неизменяемые
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3  # Выдаёт TypeError
+
+# Всё то же самое можно делать и с кортежами
+len(tup) #=> 3
+tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tup[:2] #=> (1, 2)
+2 in tup #=> True
+
+# Вы можете распаковывать кортежи (или списки) в переменные
+a, b, c = (1, 2, 3)     # a == 1, b == 2 и c == 3
+# Кортежи создаются по умолчанию, если опущены скобки
+d, e, f = 4, 5, 6
+# Обратите внимание, как легко поменять местами значения двух переменных
+e, d = d, e     # теперь d == 5, а e == 4
+
+
+#  Словари содержат ассоциативные массивы
+empty_dict = {}
+# Вот так описывается предзаполненный словарь
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Значения извлекаются так же, как из списка, с той лишь разницей,
+# что индекс — у словарей он называется ключом — не обязан быть числом
+filled_dict["one"] #=> 1
+
+# Можно получить все ключи в виде списка с помощью метода keys
+filled_dict.keys() #=> ["three", "two", "one"]
+# Замечание: сохранение порядка ключей в словаре не гарантируется
+# Ваши результаты могут не совпадать с этими.
+
+# Можно получить и все значения в виде списка, используйте метод values
+filled_dict.values() #=> [3, 2, 1]
+# То же самое замечание насчёт порядка ключей справедливо и здесь
+
+# При помощи оператора in можно проверять ключи на вхождение в словарь
+"one" in filled_dict #=> True
+1 in filled_dict #=> False
+
+# Попытка получить значение по несуществующему ключу выбросит ошибку ключа
+filled_dict["four"] # KeyError
+
+# Чтобы избежать этого, используйте метод get()
+filled_dict.get("one") #=> 1
+filled_dict.get("four") #=> None
+# Метод get также принимает аргумент по умолчанию, значение которого будет
+# возвращено при отсутствии указанного ключа
+filled_dict.get("one", 4) #=> 1
+filled_dict.get("four", 4) #=> 4
+# Обратите внимание, что filled_dict.get("four") всё ещё => None
+# (get не устанавливает значение элемента словаря)
+
+# Присваивайте значение ключам так же, как и в списках
+filled_dict["four"] = 4  # теперь filled_dict["four"] => 4
+
+# Метод setdefault вставляет() пару ключ-значение, только если такого ключа нет
+filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5
+filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5
+
+
+# Множества содержат... ну, в общем, множества
+# (которые похожи на списки, только в них не может быть дублирующихся элементов)
+empty_set = set()
+# Инициализация множества набором значений
+some_set = set([1,2,2,3,4]) # some_set теперь равно set([1, 2, 3, 4])
+
+# Порядок сортировки не гарантируется, хотя иногда они выглядят отсортированными
+another_set = set([4, 3, 2, 2, 1])  # another_set теперь set([1, 2, 3, 4])
+
+# Начиная с Python 2.7, вы можете использовать {}, чтобы объявить множество
+filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
+
+# Добавление новых элементов в множество
+filled_set.add(5) # filled_set равно {1, 2, 3, 4, 5}
+
+# Пересечение множеств: &
+other_set = {3, 4, 5, 6}
+filled_set & other_set #=> {3, 4, 5}
+
+# Объединение множеств: |
+filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
+
+# Разность множеств: -
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# Проверка на вхождение во множество: in
+2 in filled_set #=> True
+10 in filled_set #=> False
+
+
+####################################################
+## 3. Поток управления
+####################################################
+
+# Для начала заведём переменную
+some_var = 5
+
+# Так выглядит выражение if. Отступы в python очень важны!
+# результат: «some_var меньше, чем 10»
+if some_var > 10:
+    print("some_var намного больше, чем 10.")
+elif some_var < 10:    # Выражение elif необязательно.
+    print("some_var меньше, чем 10.")
+else:           # Это тоже необязательно.
+    print("some_var равно 10.")
+
+
+"""
+Циклы For проходят по спискам
+
+Результат:
+    собака — это млекопитающее
+    кошка — это млекопитающее
+    мышь — это млекопитающее
+"""
+for animal in ["собака", "кошка", "мышь"]:
+    # Можете использовать оператор % для интерполяции форматированных строк
+    print("%s — это млекопитающее" % animal)
+    
+"""
+«range(число)» возвращает список чисел
+от нуля до заданного числа
+Результат:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+Циклы while продолжаются до тех пор, пока указанное условие не станет ложным.
+Результат:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Краткая запись для x = x + 1
+
+# Обрабатывайте исключения блоками try/except
+
+# Работает в Python 2.6 и выше:
+try:
+    # Чтобы выбросить ошибку, используется raise
+    raise IndexError("Это ошибка индекса")
+except IndexError as e:
+    # pass — это просто отсутствие оператора. Обычно здесь происходит
+    # восстановление после ошибки.
+    pass
+except (TypeError, NameError):
+    pass    # Несколько исключений можно обработать вместе, если нужно.
+else:   # Необязательное выражение. Должно следовать за последним блоком except
+    print("Всё хорошо!")   # Выполнится, только если не было никаких исключений
+
+
+
+####################################################
+## 4. Функции
+####################################################
+
+# Используйте def для создания новых функций
+def add(x, y):
+    print("x равен %s, а y равен %s" % (x, y))
+    return x + y    # Возвращайте результат с помощью ключевого слова return
+
+# Вызов функции с аргументами
+add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвращает 11
+
+# Другой способ вызова функции — вызов с именованными аргументами
+add(y=6, x=5)   # Именованные аргументы можно указывать в любом порядке.
+
+# Вы можете определить функцию, принимающую переменное число аргументов,
+# которые будут интерпретированы как кортеж, если вы не используете *
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+
+# А также можете определить функцию, принимающую переменное число
+# именованных аргументов, которые будут интерпретированы как словарь,
+# если вы не используете **
+def keyword_args(**kwargs):
+    return kwargs
+
+# Вызовем эту функцию и посмотрим, что из этого получится
+keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
+
+# Если хотите, можете использовать оба способа одновременно
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) выводит:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Вызывая функции, можете сделать наоборот!
+# Используйте символ * для распаковки кортежей и ** для распаковки словарей
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args) # эквивалентно foo(1, 2, 3, 4)
+all_the_args(**kwargs) # эквивалентно foo(a=3, b=4)
+all_the_args(*args, **kwargs) # эквивалентно foo(1, 2, 3, 4, a=3, b=4)
+
+# вы можете передавать переменное число позиционных или именованных аргументов
+# другим функциям, которые их принимают, распаковывая их с помощью
+# * или ** соответственно
+def pass_all_the_args(*args, **kwargs):
+    all_the_args(*args, **kwargs)
+    print varargs(*args)
+    print keyword_args(**kwargs)
+
+# Область определения функций
+x = 5
+
+def setX(num):
+    # Локальная переменная x — это не то же самое, что глобальная переменная x
+    x = num # => 43
+    print (x) # => 43
+    
+def setGlobalX(num):
+    global x
+    print (x) # => 5
+    x = num # Глобальная переменная x теперь равна 6
+    print (x) # => 6
+
+setX(43)
+setGlobalX(6)
+
+# В Python функции — «объекты первого класса»
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3) #=> 13
+
+# Также есть и анонимные функции
+(lambda x: x > 2)(3) #=> True
+
+# Есть встроенные функции высшего порядка
+map(add_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+
+# Для удобного отображения и фильтрации можно использовать списочные включения
+[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+####################################################
+## 5. Классы
+####################################################
+
+# Чтобы получить класс, мы наследуемся от object.
+class Human(object):
+
+    # Атрибут класса. Он разделяется всеми экземплярами этого класса
+    species = "H. sapiens"
+
+    # Обычный конструктор, вызывается при инициализации экземпляра класса
+    # Обратите внимание, что двойное подчёркивание в начале и в конце имени
+    # означает объекты и атрибуты, которые используются Python, но находятся
+    # в пространствах имён, управляемых пользователем.
+    # Не придумывайте им имена самостоятельно.
+    def __init__(self, name):
+        # Присваивание значения аргумента атрибуту класса name
+        self.name = name
+
+    # Метод экземпляра. Все методы принимают self в качестве первого аргумента
+    def say(self, msg):
+       return "%s: %s" % (self.name, msg)
+
+    # Метод класса разделяется между всеми экземплярами
+    # Они вызываются с указыванием вызывающего класса в качестве первого аргумента
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Статический метод вызывается без ссылки на класс или экземпляр
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Инициализация экземпляра класса
+i = Human(name="Иван")
+print(i.say("привет"))     # Выводит: «Иван: привет»
+
+j = Human("Пётр")
+print(j.say("Привет"))  # Выводит: «Пётр: привет»
+
+# Вызов метода класса
+i.get_species() #=> "H. sapiens"
+
+# Изменение разделяемого атрибута
+Human.species = "H. neanderthalensis"
+i.get_species() #=> "H. neanderthalensis"
+j.get_species() #=> "H. neanderthalensis"
+
+# Вызов статического метода
+Human.grunt() #=> "*grunt*"
+
+
+####################################################
+## 6. Модули
+####################################################
+
+# Вы можете импортировать модули
+import math
+print(math.sqrt(16)) #=> 4
+
+# Вы можете импортировать отдельные функции модуля
+from math import ceil, floor
+print(ceil(3.7))  #=> 4.0
+print(floor(3.7)) #=> 3.0
+
+# Можете импортировать все функции модуля.
+# (Хотя это и не рекомендуется)
+from math import *
+
+# Можете сокращать имена модулей
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+# Вы также можете убедиться, что функции эквивалентны
+from math import sqrt
+math.sqrt == m.sqrt == sqrt  # => True
+
+# Модули в Python — это обычные Python-файлы. Вы
+# можете писать свои модули и импортировать их. Название
+# модуля совпадает с названием файла.
+
+# Вы можете узнать, какие функции и атрибуты определены 
+# в модуле
+import math
+dir(math)
+
+####################################################
+## 7. Дополнительно
+####################################################
+
+# Генераторы помогут выполнить ленивые вычисления
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# Генератор создаёт значения на лету.
+# Он не возвращает все значения разом, а создаёт каждое из них при каждой
+# итерации.  Это значит, что значения больше 15 в double_numbers
+# обработаны не будут.
+# Обратите внимание: xrange — это генератор, который делает то же, что и range.
+# Создание списка чисел от 1 до 900000000 требует много места и времени.
+# xrange создаёт объект генератора, а не список сразу, как это делает range.
+# Если нам нужно имя переменной, совпадающее с ключевым словом Python,
+# мы используем подчёркивание в конце
+xrange_ = xrange(1, 900000000)
+
+# Будет удваивать все числа, пока результат не превысит 30
+for i in double_numbers(xrange_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Декораторы
+# В этом примере beg оборачивает say
+# Метод beg вызовет say. Если say_please равно True,
+# он изменит возвращаемое сообщение
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, " Пожалуйста! У меня нет денег :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Вы не купите мне пива?"
+    return msg, say_please
+
+
+print(say())  # Вы не купите мне пива?
+print(say(say_please=True)) # Вы не купите мне пива? Пожалуйста! У меня нет денег :(
+
+```
+
+## Хотите ещё?
+
+### Бесплатные онлайн-материалы
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Официальная документация](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+
+### Платные
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
diff --git a/ru-ru/python3-ru.html.markdown b/ru-ru/python3-ru.html.markdown
new file mode 100644
index 00000000..2a7b3f7b
--- /dev/null
+++ b/ru-ru/python3-ru.html.markdown
@@ -0,0 +1,648 @@
+---
+language: python3
+lang: ru-ru
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+translators:
+    - ["Andre Polykanine", "https://github.com/Oire"]
+filename: learnpython3-ru.py
+---
+
+Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из
+самых популярных языков. Я влюбился в Python за понятный и доходчивый синтаксис  — это
+почти что исполняемый псевдокод.
+
+С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh)
+или louiedinh [at] [почтовый сервис Google]
+
+Замечание: Эта статья относится только к Python 3.
+Если вы хотите изучить Python 2.7, обратитесь к другой статье.
+
+```python
+# Однострочные комментарии начинаются с символа решётки.
+""" Многострочный текст может быть 
+    записан, используя 3 знака " и обычно используется
+    в качестве встроенной документации
+"""
+
+####################################################
+## 1. Примитивные типы данных и операторы
+####################################################
+
+# У вас есть числа
+3 #=> 3
+
+# Математика работает вполне ожидаемо
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+
+# Кроме деления, которое по умолчанию возвращает число с плавающей запятой
+35 / 5  # => 7.0
+
+# Результат целочисленного деления округляется в меньшую сторону
+# как для положительных, так и для отрицательных чисел.
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # работает и для чисел с плавающей запятой
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
+
+# Когда вы используете числа с плавающей запятой, 
+# результатом будет также число с плавающей запятой
+3 * 2.0 # => 6.0
+
+# Остаток от деления
+7 % 3 # => 1
+
+# Возведение в степень
+2**4 # => 16
+
+# Приоритет операций указывается скобками
+(1 + 3) * 2 #=> 8
+
+# Для логических (булевых) значений существует отдельный примитивный тип
+True
+False
+
+# Для отрицания используется ключевое слово not
+not True #=> False
+not False #=> True
+
+# Логические операторы
+# Обратите внимание: ключевые слова «and» и «or» чувствительны к регистру букв
+True and False #=> False
+False or True #=> True
+
+# Обратите внимание, что логические операторы используются и с целыми числами
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
+
+# Равенство — это ==
+1 == 1 #=> True
+2 == 1 #=> False
+
+# Неравенство — это !=
+1 != 1 #=> False
+2 != 1 #=> True
+
+# Ещё немного сравнений
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
+
+# Сравнения могут быть записаны цепочкой:
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
+
+# Строки определяются символом " или '
+"Это строка."
+'Это тоже строка.'
+
+# И строки тоже могут складываться! Хотя лучше не злоупотребляйте этим.
+"Привет " + "мир!" #=> "Привет мир!"
+
+# Со строкой можно работать, как со списком символов
+"Это строка"[0] #=> 'Э'
+
+# Метод format используется для форматирования строк:
+"{0} могут быть {1}".format("строки", "форматированы")
+
+# Вы можете повторять аргументы форматирования, чтобы меньше печатать.
+"Ехал {0} через реку, видит {0} - в реке {1}! Сунул {0} руку в реку, {1} за руку греку цап!".format("грека", "рак")
+#=> "Ехал грека через реку, видит грека - в реке рак! Сунул грека руку в реку, рак за руку греку цап!"
+# Если вы не хотите считать, можете использовать ключевые слова.
+"{name} хочет есть {food}".format(name="Боб", food="лазанью")
+
+# Если ваш код на Python 3 нужно запускать также и под Python 2.5 и ниже,
+# вы также можете использовать старый способ форматирования:
+"%s можно %s %s способом" % ("строки", "интерполировать", "старым")
+
+# None является объектом
+None #=> None
+
+# Не используйте оператор равенства '==' для сравнения 
+# объектов с None. Используйте для этого 'is'
+"etc" is None #=> False
+None is None  #=> True
+
+# Оператор «is» проверяет идентичность объектов. Он не 
+# очень полезен при работе с примитивными типами, но 
+# зато просто незаменим при работе с объектами.
+
+# None, 0 и пустые строки/списки/словари приводятся к False.
+# Все остальные значения равны True
+bool(0)  # => False
+bool("")  # => False
+bool([]) #=> False
+bool({}) #=> False
+
+
+####################################################
+## 2. Переменные и коллекции
+####################################################
+
+# В Python есть функция Print
+print("Я Python. Приятно познакомиться!")
+
+# Объявлять переменные перед инициализацией не нужно.
+# По соглашению используется нижний_регистр_с_подчёркиваниями
+some_var = 5
+some_var #=> 5
+
+# При попытке доступа к неинициализированной переменной
+# выбрасывается исключение.
+# Об исключениях см. раздел «Поток управления и итерируемые объекты».
+some_unknown_var  # Выбрасывает ошибку именования
+
+# Списки хранят последовательности
+li = []
+# Можно сразу начать с заполненного списка
+other_li = [4, 5, 6]
+
+# Объекты добавляются в конец списка методом append
+li.append(1)    # [1]
+li.append(2)    # [1, 2]
+li.append(4)    # [1, 2, 4]
+li.append(3)    # [1, 2, 4, 3]
+# И удаляются с конца методом pop
+li.pop()        #=> возвращает 3 и li становится равен [1, 2, 4]
+# Положим элемент обратно
+li.append(3)    # [1, 2, 4, 3].
+
+# Обращайтесь со списком, как с обычным массивом
+li[0] #=> 1
+# Обратимся к последнему элементу
+li[-1] #=> 3
+
+# Попытка выйти за границы массива приведёт к ошибке индекса
+li[4] # Выдаёт IndexError
+
+# Можно обращаться к диапазону, используя так называемые срезы
+# (Для тех, кто любит математику, это называется замкнуто-открытый интервал).
+li[1:3] #=> [2, 4]
+# Опускаем начало
+li[2:] #=> [4, 3]
+# Опускаем конец
+li[:3] #=> [1, 2, 4]
+# Выбираем каждый второй элемент
+li[::2]   # =>[1, 4]
+# Переворачиваем список
+li[::-1]   # => [3, 4, 2, 1]
+# Используйте сочетания всего вышеназванного для выделения более сложных срезов
+# li[начало:конец:шаг]
+
+# Удаляем произвольные элементы из списка оператором del
+del li[2] # [1, 2, 3]
+
+# Вы можете складывать, или, как ещё говорят, конкатенировать списки
+# Обратите внимание: значения li и other_li при этом не изменились.
+li + other_li #=> [1, 2, 3, 4, 5, 6]  — Замечание: li и other_li не изменяются
+
+# Объединять списки можно методом extend
+li.extend(other_li) # Теперь li содержит [1, 2, 3, 4, 5, 6]
+
+# Проверить элемент на вхождение в список можно оператором in
+1 in li #=> True
+
+# Длина списка вычисляется функцией len
+len(li) #=> 6
+
+
+# Кортежи — это такие списки, только неизменяемые
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3  # Выдаёт TypeError
+
+# Всё то же самое можно делать и с кортежами
+len(tup) #=> 3
+tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tup[:2] #=> (1, 2)
+2 in tup #=> True
+
+# Вы можете распаковывать кортежи (или списки) в переменные
+a, b, c = (1, 2, 3)     # a == 1, b == 2 и c == 3
+# Кортежи создаются по умолчанию, если опущены скобки
+d, e, f = 4, 5, 6
+# Обратите внимание, как легко поменять местами значения двух переменных
+e, d = d, e     # теперь d == 5, а e == 4
+
+
+#  Словари содержат ассоциативные массивы
+empty_dict = {}
+# Вот так описывается предзаполненный словарь
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Значения извлекаются так же, как из списка, с той лишь разницей,
+# что индекс — у словарей он называется ключом — не обязан быть числом
+filled_dict["one"] #=> 1
+
+# Все ключи в виде списка получаются с помощью метода keys(). 
+# Его вызов нужно обернуть в list(), так как обратно мы получаем
+# итерируемый объект, о которых поговорим позднее.
+list(filled_dict.keys())   # => ["three", "two", "one"]
+# Замечание: сохранение порядка ключей в словаре не гарантируется
+# Ваши результаты могут не совпадать с этими.
+
+# Все значения в виде списка можно получить с помощью values().
+# И снова нам нужно обернуть вызов в list(), чтобы превратить
+# итерируемый объект в список.
+list(filled_dict.values())   # => [3, 2, 1]
+# То же самое замечание насчёт порядка ключей справедливо и здесь
+
+# При помощи оператора in можно проверять ключи на вхождение в словарь
+"one" in filled_dict #=> True
+1 in filled_dict #=> False
+
+# Попытка получить значение по несуществующему ключу выбросит ошибку ключа
+filled_dict["four"] # KeyError
+
+# Чтобы избежать этого, используйте метод get()
+filled_dict.get("one") #=> 1
+filled_dict.get("four") #=> None
+# Метод get также принимает аргумент по умолчанию, значение которого будет
+# возвращено при отсутствии указанного ключа
+filled_dict.get("one", 4) #=> 1
+filled_dict.get("four", 4) #=> 4
+
+# Метод setdefault вставляет пару ключ-значение, только если такого ключа нет
+filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5
+filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5
+
+# Добавление элементов в словарь
+filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
+#filled_dict["four"] = 4  # Другой способ добавления элементов
+
+# Удаляйте ключи из словаря с помощью оператора del
+del filled_dict["one"]  # Удаляет ключ «one» из словаря
+
+
+# Множества содержат... ну, в общем, множества
+empty_set = set()
+# Инициализация множества набором значений.
+# Да, оно выглядит примерно как словарь… ну извините, так уж вышло.
+filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
+
+# Множеству можно назначать новую переменную
+filled_set = some_set
+
+# Добавление новых элементов в множество
+filled_set.add(5) # filled_set равно {1, 2, 3, 4, 5}
+
+# Пересечение множеств: &
+other_set = {3, 4, 5, 6}
+filled_set & other_set #=> {3, 4, 5}
+
+# Объединение множеств: |
+filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
+
+# Разность множеств: -
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# Проверка на вхождение во множество: in
+2 in filled_set #=> True
+10 in filled_set #=> False
+
+
+####################################################
+## 3. Поток управления и итерируемые объекты
+####################################################
+
+# Для начала заведём переменную
+some_var = 5
+
+# Так выглядит выражение if. Отступы в python очень важны!
+# результат: «some_var меньше, чем 10»
+if some_var > 10:
+    print("some_var намного больше, чем 10.")
+elif some_var < 10:    # Выражение elif необязательно.
+    print("some_var меньше, чем 10.")
+else:           # Это тоже необязательно.
+    print("some_var равно 10.")
+
+
+# Циклы For проходят по спискам. Результат:
+    # собака — это млекопитающее
+    # кошка — это млекопитающее
+    # мышь — это млекопитающее
+for animal in ["собака", "кошка", "мышь"]:
+    # Можете использовать format() для интерполяции форматированных строк
+    print("{} — это млекопитающее".format(animal))
+    
+"""
+«range(число)» возвращает список чисел
+от нуля до заданного числа
+Результат:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+Циклы while продолжаются до тех пор, пока указанное условие не станет ложным.
+Результат:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Краткая запись для x = x + 1
+
+# Обрабатывайте исключения блоками try/except
+try:
+    # Чтобы выбросить ошибку, используется raise
+    raise IndexError("Это ошибка индекса")
+except IndexError as e:
+    # pass — это просто отсутствие оператора. Обычно здесь происходит
+    # восстановление после ошибки.
+    pass
+except (TypeError, NameError):
+    pass    # Несколько исключений можно обработать вместе, если нужно.
+else:   # Необязательное выражение. Должно следовать за последним блоком except
+    print("Всё хорошо!")   # Выполнится, только если не было никаких исключений
+
+# Python предоставляет фундаментальную абстракцию,
+# которая называется итерируемым объектом (an iterable).
+# Итерируемый объект — это объект, который воспринимается как последовательность.
+# Объект, который возвратила функция range(), итерируемый.
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable) #=> range(1,10). Это объект, реализующий интерфейс iterable
+
+# Мы можем проходить по нему циклом.
+for i in our_iterable:
+    print(i)    # Выводит one, two, three
+
+# Но мы не можем обращаться к элементу по индексу.
+our_iterable[1]  # Выбрасывает ошибку типа
+
+# Итерируемый объект знает, как создавать итератор.
+our_iterator = iter(our_iterable)
+
+# Итератор может запоминать состояние при проходе по объекту.
+# Мы получаем следующий объект, вызывая функцию __next__.
+our_iterator.__next__()  #=> "one"
+
+# Он сохраняет состояние при вызове __next__.
+our_iterator.__next__()  #=> "two"
+our_iterator.__next__()  #=> "three"
+
+# Возвратив все данные, итератор выбрасывает исключение StopIterator
+our_iterator.__next__() # Выбрасывает исключение остановки итератора
+
+# Вы можете получить сразу все элементы итератора, вызвав на нём функцию list().
+list(filled_dict.keys())  #=> Возвращает ["one", "two", "three"]
+
+
+####################################################
+## 4. Функции
+####################################################
+
+# Используйте def для создания новых функций
+def add(x, y):
+    print("x равен %s, а y равен %s" % (x, y))
+    return x + y    # Возвращайте результат с помощью ключевого слова return
+
+# Вызов функции с аргументами
+add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвращает 11
+
+# Другой способ вызова функции — вызов с именованными аргументами
+add(y=6, x=5)   # Именованные аргументы можно указывать в любом порядке.
+
+# Вы можете определить функцию, принимающую переменное число аргументов
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+
+# А также можете определить функцию, принимающую переменное число
+# именованных аргументов
+def keyword_args(**kwargs):
+    return kwargs
+
+# Вызовем эту функцию и посмотрим, что из этого получится
+keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
+
+# Если хотите, можете использовать оба способа одновременно
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) выводит:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Вызывая функции, можете сделать наоборот!
+# Используйте символ * для распаковки кортежей и ** для распаковки словарей
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args) # эквивалентно foo(1, 2, 3, 4)
+all_the_args(**kwargs) # эквивалентно foo(a=3, b=4)
+all_the_args(*args, **kwargs) # эквивалентно foo(1, 2, 3, 4, a=3, b=4)
+
+# Область определения функций
+x = 5
+
+def setX(num):
+    # Локальная переменная x — это не то же самое, что глобальная переменная x
+    x = num # => 43
+    print (x) # => 43
+    
+def setGlobalX(num):
+    global x
+    print (x) # => 5
+    x = num # Глобальная переменная x теперь равна 6
+    print (x) # => 6
+
+setX(43)
+setGlobalX(6)
+
+# В Python функции — «объекты первого класса»
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3) #=> 13
+
+# Также есть и анонимные функции
+(lambda x: x > 2)(3) #=> True
+
+# Есть встроенные функции высшего порядка
+map(add_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+
+# Для удобного отображения и фильтрации можно использовать списочные включения
+[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+####################################################
+## 5. Классы
+####################################################
+
+# Чтобы получить класс, мы наследуемся от object.
+class Human(object):
+
+    # Атрибут класса. Он разделяется всеми экземплярами этого класса
+    species = "H. sapiens"
+
+    # Обычный конструктор, вызывается при инициализации экземпляра класса
+    # Обратите внимание, что двойное подчёркивание в начале и в конце имени
+    # означает объекты и атрибуты, которые используются Python, но находятся
+    # в пространствах имён, управляемых пользователем.
+    # Не придумывайте им имена самостоятельно.
+    def __init__(self, name):
+        # Присваивание значения аргумента атрибуту класса name
+        self.name = name
+
+    # Метод экземпляра. Все методы принимают self в качестве первого аргумента
+    def say(self, msg):
+        return "{name}: {message}".format(name=self.name, message=msg)
+
+    # Метод класса разделяется между всеми экземплярами
+    # Они вызываются с указыванием вызывающего класса в качестве первого аргумента
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Статический метод вызывается без ссылки на класс или экземпляр
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Инициализация экземпляра класса
+i = Human(name="Иван")
+print(i.say("привет"))     # Выводит: «Иван: привет»
+
+j = Human("Пётр")
+print(j.say("Привет"))  # Выводит: «Пётр: привет»
+
+# Вызов метода класса
+i.get_species() #=> "H. sapiens"
+
+# Изменение разделяемого атрибута
+Human.species = "H. neanderthalensis"
+i.get_species() #=> "H. neanderthalensis"
+j.get_species() #=> "H. neanderthalensis"
+
+# Вызов статического метода
+Human.grunt() #=> "*grunt*"
+
+
+####################################################
+## 6. Модули
+####################################################
+
+# Вы можете импортировать модули
+import math
+print(math.sqrt(16)) #=> 4
+
+# Вы можете импортировать отдельные функции модуля
+from math import ceil, floor
+print(ceil(3.7))  #=> 4.0
+print(floor(3.7)) #=> 3.0
+
+# Можете импортировать все функции модуля.
+# (Хотя это и не рекомендуется)
+from math import *
+
+# Можете сокращать имена модулей
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Модули в Python — это обычные Python-файлы. Вы
+# можете писать свои модули и импортировать их. Название
+# модуля совпадает с названием файла.
+
+# Вы можете узнать, какие функции и атрибуты определены 
+# в модуле
+import math
+dir(math)
+
+####################################################
+## 7. Дополнительно
+####################################################
+
+# Генераторы помогут выполнить ленивые вычисления
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# Генератор создаёт значения на лету.
+# Он не возвращает все значения разом, а создаёт каждое из них при каждой
+# итерации.  Это значит, что значения больше 15 в double_numbers
+# обработаны не будут.
+# Обратите внимание: range — это тоже генератор.
+# Создание списка чисел от 1 до 900000000 требует много места и времени.
+# Если нам нужно имя переменной, совпадающее с ключевым словом Python,
+# мы используем подчёркивание в конце
+range_ = range(1, 900000000)
+
+# Будет удваивать все числа, пока результат не превысит 30
+for i in double_numbers(range_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Декораторы
+# В этом примере beg оборачивает say
+# Метод beg вызовет say. Если say_please равно True,
+# он изменит возвращаемое сообщение
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, " Пожалуйста! У меня нет денег :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Вы не купите мне пива?"
+    return msg, say_please
+
+
+print(say())  # Вы не купите мне пива?
+print(say(say_please=True)) # Вы не купите мне пива? Пожалуйста! У меня нет денег :(
+
+```
+
+## Хотите ещё?
+
+### Бесплатные онлайн-материалы
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [Официальная документация](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/3/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+
+### Платные
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
diff --git a/ru-ru/ruby-ru.html.markdown b/ru-ru/ruby-ru.html.markdown
new file mode 100644
index 00000000..69b5fb46
--- /dev/null
+++ b/ru-ru/ruby-ru.html.markdown
@@ -0,0 +1,469 @@
+---
+language: ruby
+lang: ru-ru
+filename: learnruby-ru.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"]
+translators:
+  - ["Alexey Makarov", "https://github.com/Anakros"]
+---
+
+```ruby
+# Это комментарий
+
+=begin
+Это многострочный комментарий
+Никто их не использует
+И они не рекомендуются к использованию
+=end
+
+# Первое и самое главное: Всё является объектом.
+
+# Числа это объекты
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Немного простой арифметики
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# Арифметика -- это синтаксический сахар
+# над вызовом метода для объекта
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Логические величины -- это объекты
+nil # Здесь ничего нет
+true # истина
+false # ложь
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Операция равенства
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Операция неравенства
+1 != 1 #=> false
+2 != 1 #=> true
+!true  #=> false
+!false #=> true
+
+# nil -- имеет такое же логическое значение, как и false
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Больше операций сравнения
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Строки -- это объекты
+
+'Я строка'.class #=> String
+"Я тоже строка".class #=> String
+
+placeholder = "использовать интерполяцию строк"
+"Я могу #{placeholder}, когда создаю строку с двойными кавычками"
+#=> "Я могу использовать интерполяцию строк,
+# когда создаю строку с двойными кавычками"
+
+
+# печатать в стандартный вывод
+puts "Я печатаюсь!"
+
+# Переменные
+x = 25 #=> 25
+x #=> 25
+
+# Присваивание значения возвращает то самое присвоенное значение.
+# Это позволяет делать множественные присваивания:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# По соглашению, используйте snake_case для имён переменных
+snake_case = true
+
+# Используйте подробные имена для переменных
+# Но не переборщите!
+path_to_project_root = '/good/name/'
+path = '/bad/name/'
+
+# Идентификаторы (тоже объекты)
+
+# Идентификаторы -- это неизменяемые, многоразовые константы. 
+# Для каждого идентификатора (кроме текста) сохраняется цифровой хэш.
+# При последующем использовании идентификатора, заместо создания нового объекта,
+# будет найден уже существующий по цифровому хэшу.
+# Они часто используются вместо строк для ускорения работы приложений
+
+:pending.class #=> Symbol
+
+status = :pending
+
+status == :pending #=> true
+
+status == 'pending' #=> false
+
+status == :approved #=> false
+
+# Массивы
+
+# Это массив
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Массив может содержать различные типы значений
+
+[1, "hello", false] #=> [1, "hello", false]
+
+# Значение в массиве можно получить по индексу с левой границы
+array[0] #=> 1
+array[12] #=> nil
+
+# Как и арифметика, доступ к значению в массиве
+# это синтаксический сахар над вызовом метода для объекта
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# Также, можно получить по индексу с правой границы
+array[-1] #=> 5
+
+# С заданными левой и правой границами индексов
+array[2, 4] #=> [3, 4, 5]
+
+# Или с использованием диапазона значений
+array[1..3] #=> [2, 3, 4]
+
+# Вот так можно добавить значение в массив
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+
+# Хэши -- это массив пар "ключ => значение".
+# Хэши объявляются с использованием фигурных скобок:
+hash = {'color' => 'green', 'number' => 5}
+
+hash.keys #=> ['color', 'number']
+hash.values #=> ['green', 5]
+
+# Значение в хэше легко может быть найдено по ключу:
+hash['color'] #=> 'green'
+hash['number'] #=> 5
+
+# Поиск по ключу, которого в хэше нет вернёт nil:
+hash['nothing here'] #=> nil
+
+# начиная с Ruby 1.9, существует специальный синтаксис 
+# при использовании идентификаторов как ключей хэша:
+
+new_hash = { defcon: 3, action: true}
+
+new_hash.keys #=> [:defcon, :action]
+
+# Массивы и Хэши -- перечисляемые типы данных
+# У них есть много полезных методов, например: each, map, count и другие
+
+# Управление ходом выполнения (Управляющие структуры)
+
+if true
+  "Если истина"
+elsif false
+  "Иначе, если ложь (опционально)"
+else
+  "Во всех других случаях"
+end
+
+for counter in 1..5
+  puts "итерация #{counter}"
+end
+#=> итерация 1
+#=> итерация 2
+#=> итерация 3
+#=> итерация 4
+#=> итерация 5
+
+# Однако, никто не использует "for" для циклов.
+# Вместо него Вы должны использовать метод "each" вместе с блоком кода.
+#
+# Блок кода -- это один из вариантов создания замыканий (лямбды,
+# анонимные функции).
+# Блок может только передаваться методу, сам по себе он существовать не может.
+# "for" не имеет своей области видимости и все переменные, объявленные в нём
+# будут доступны отовсюду. "each" вместе с блоком создаёт свою область видимости
+
+# Метод "each" для диапазона значений запускает блок кода один раз
+# для каждого из значений диапазона
+# Блок передаёт счётчик (counter) в качестве параметра.
+# Вызов метода "each" с блоком выглядит следующим образом:
+
+(1..5).each do |counter|
+  puts "итерация #{counter}"
+end
+#=> итерация 1
+#=> итерация 2
+#=> итерация 3
+#=> итерация 4
+#=> итерация 5
+
+# Вы также можете ограничивать блоки фигурными скобками:
+(1..5).each {|counter| puts "итерация #{counter}"}
+
+# Содержимое структурных данных также можно перебирать используя "each":
+array.each do |element|
+  puts "#{element} -- часть массива"
+end
+hash.each do |key, value|
+  puts "#{key} -- это #{value}"
+end
+
+counter = 1
+while counter <= 5 do
+  puts "итерация #{counter}"
+  counter += 1
+end
+#=> итерация 1
+#=> итерация 2
+#=> итерация 3
+#=> итерация 4
+#=> итерация 5
+
+grade = 'B'
+
+case grade
+when 'A'
+  puts "Так держать, детка!"
+when 'B'
+  puts "Тебе повезёт в следующий раз"
+when 'C'
+  puts "Ты можешь сделать лучше"
+when 'D'
+  puts "Выскоблил последнее"
+when 'F'
+  puts "Ты провалился!"
+else
+  puts "Альтернативная система оценок, да?"
+end
+
+# Функции
+
+def double(x)
+  x * 2
+end
+
+# Функции (и все блоки) неявно возвращают значение последней операции
+double(2) #=> 4
+
+# Скобки необязательны, если возвращаемый результат однозначен
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x,y)
+  x + y
+end
+
+# Аргументы метода разделены запятой
+sum 3, 4 #=> 7
+
+sum sum(3,4), 5 #=> 12
+
+# yield
+# Все методы имеют неявный, опциональный параметр,
+# который может быть вызван с помощью инструкции "yield"
+
+def surround
+  puts "{"
+  yield
+  puts "}"
+end
+
+surround { puts 'hello world' }
+
+# {
+# hello world
+# }
+
+
+# Определение класса с помощью ключевого слова "class"
+class Human
+
+  # Переменная класса, она является общей для всех экземпляров класса
+  @@species = "H. sapiens"
+
+  # Базовый метод-конструктор
+  def initialize(name, age=0)
+    # Присвоить аргумент "name" переменной "name" экземпляра класса
+    @name = name
+    # Если аргумент "age" не задан,
+    # мы используем значение по умолчанию из списка аргументов
+    @age = age
+  end
+
+  # Базовый метод установки значения для переменной (setter)
+  def name=(name)
+    @name = name
+  end
+
+  # Базовый метод получения значения переменной (getter)
+  def name
+    @name
+  end
+
+  # Метод класса определяется с ключевым словом "self",
+  # чтобы можно было отличить его от метода экземпляра класса.
+  # Он может быть вызван только на уровне класса, но не экземпляра.
+  def self.say(msg)
+    puts "#{msg}"
+  end
+
+  def species
+    @@species
+  end
+
+end
+
+
+# Создание экземпляра класса
+jim = Human.new("Jim Halpert")
+
+dwight = Human.new("Dwight K. Schrute")
+
+# Давайте вызовем несколько методов
+jim.species #=> "H. sapiens"
+jim.name #=> "Jim Halpert"
+jim.name = "Jim Halpert II" #=> "Jim Halpert II"
+jim.name #=> "Jim Halpert II"
+dwight.species #=> "H. sapiens"
+dwight.name #=> "Dwight K. Schrute"
+
+# Вызов метода класса
+Human.say("Hi") #=> "Hi"
+
+# Область видимости переменной определяется тем, как мы даём имя переменной.
+# Переменные, имя которых начинается с "$" имеют глобальную область видимости
+$var = "I'm a global var"
+defined? $var #=> "global-variable"
+
+# Переменная экземпляра класса, она видна только в экземпляре
+@var = "I'm an instance var"
+defined? @var #=> "instance-variable"
+
+# Переменная класса, видна для всех экземпляров этого класса и в самом классе
+@@var = "I'm a class var"
+defined? @@var #=> "class variable"
+
+# Имена переменных с большой буквы используются для создания констант
+Var = "I'm a constant"
+defined? Var #=> "constant"
+
+# Класс тоже объект в Ruby. Класс может иметь переменные экземпляра.
+# Переменная класса доступна в классе, его экземплярах и его потомках.
+
+# Пример класса
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+#  Производный класс (класс-потомок)
+class Worker < Human
+end
+
+Human.foo # 0
+Worker.foo # 0
+
+Human.foo = 2 # 2
+Worker.foo # 2
+
+# Переменная экземпляра класса недоступна в потомках этого класса.
+
+class Human
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Doctor < Human
+end
+
+Human.bar # 0
+Doctor.bar # nil
+
+module ModuleExample
+  def foo
+    'foo'
+  end
+end
+
+# Включение модулей в класс добавляет их методы в экземпляр класса
+# Или в сам класс, зависит только от метода подключения
+class Person
+  include ModuleExample
+end
+
+class Book
+  extend ModuleExample
+end
+
+Person.foo     # => NoMethodError: undefined method `foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => NoMethodError: undefined method `foo'
+
+# Коллбэки при подключении модуля
+
+module ConcernExample
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def bar
+      'bar'
+    end
+  end
+
+  module InstanceMethods
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Something
+  include ConcernExample
+end
+
+Something.bar     # => 'bar'
+Something.qux     # => NoMethodError: undefined method `qux'
+Something.new.bar # => NoMethodError: undefined method `bar'
+Something.new.qux # => 'qux'
+```
diff --git a/ru-ru/swift-ru.html.markdown b/ru-ru/swift-ru.html.markdown
new file mode 100644
index 00000000..77987bb3
--- /dev/null
+++ b/ru-ru/swift-ru.html.markdown
@@ -0,0 +1,589 @@
+---
+language: swift
+contributors:
+  - ["Grant Timmerman", "http://github.com/grant"]
+  - ["Christopher Bess", "http://github.com/cbess"]
+  - ["Joey Huang", "http://github.com/kamidox"]
+filename: learnswift-ru.swift
+translators:
+  - ["Dmitry Bessonov", "https://github.com/TheDmitry"]
+lang: ru-ru
+---
+
+Swift - это язык программирования, созданный компанией Apple, для приложений
+под iOS и OS X. Разработанный, чтобы сосуществовать с Objective-C и
+быть более устойчивым к ошибочному коду, Swift был представлен в 2014 году на
+конференции разработчиков Apple, WWDC. Приложения на Swift собираются
+с помощью LLVM-компилятора, включенного в Xcode 6+.
+
+Официальная книга по [языку программирования Swift](https://itunes.apple.com/us/book/swift-programming-language/id881256329) от Apple доступна в iBooks.
+
+Смотрите еще [начальное руководство](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html) Apple, которое содержит полное учебное пособие по Swift.
+
+```swift
+// импорт модуля
+import UIKit
+
+//
+// MARK: Основы
+//
+
+// Xcode поддерживает маркеры, чтобы давать примечания своему коду
+// и вносить их в список обозревателя (Jump Bar)
+// MARK: Метка раздела
+// TODO: Сделайте что-нибудь вскоре
+// FIXME: Исправьте этот код
+
+println("Привет, мир")
+
+// переменные (var), значение которых можно изменить после инициализации
+// константы (let), значение которых нельзя изменить после инициализации
+
+var myVariable = 42
+let øπΩ = "значение" // именование переменной символами unicode
+let π = 3.1415926
+let convenience = "Ключевое слово" // контекстное имя переменной
+let weak = "Ключевое слово"; let override = "еще ключевое слово" // операторы
+                                      // могут быть отделены точкой с запятой
+let `class` = "Ключевое слово" // обратные апострофы позволяют использовать
+                               // ключевые слова в именовании переменных
+let explicitDouble: Double = 70
+let intValue = 0007 // 7
+let largeIntValue = 77_000 // 77000
+let label = "некоторый текст " + String(myVariable) // Приведение типа
+let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Вставка переменных в строку
+
+// Сборка особых значений
+// используя ключ -D сборки конфигурации
+#if false
+    println("Не печатается")
+    let buildValue = 3
+#else
+    let buildValue = 7
+#endif
+println("Значение сборки: \(buildValue)") // Значение сборки: 7
+
+/*
+    Опционалы - это особенность языка Swift, которая допускает вам сохранять
+    `некоторое` или `никакое` значения.
+
+    Язык Swift требует, чтобы каждое свойство имело значение, поэтому даже nil
+    должен быть явно сохранен как опциональное значение.
+
+    Optional<T> является перечислением.
+*/
+var someOptionalString: String? = "опционал" // Может быть nil
+// как и выше, только ? - это постфиксный оператор (синтаксический сахар)
+var someOptionalString2: Optional<String> = "опционал"
+
+if someOptionalString != nil {
+    // я не nil
+    if someOptionalString!.hasPrefix("opt") {
+        println("содержит префикс")
+    }
+    
+    let empty = someOptionalString?.isEmpty
+}
+someOptionalString = nil
+
+// неявная развертка опциональной переменной
+var unwrappedString: String! = "Ожидаемое значение."
+// как и выше, только ! - постфиксный оператор (с еще одним синтаксическим сахаром)
+var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Ожидаемое значение."
+
+if let someOptionalStringConstant = someOptionalString {
+    // имеется некоторое значение, не nil
+    if !someOptionalStringConstant.hasPrefix("ok") {
+        // нет такого префикса
+    }
+}
+
+// Swift поддерживает сохранение значения любого типа
+// AnyObject == id
+// В отличие от `id` в Objective-C, AnyObject работает с любым значением (Class,
+// Int, struct и т.д.)
+var anyObjectVar: AnyObject = 7
+anyObjectVar = "Изменять значение на строку не является хорошей практикой, но возможно."
+
+/*
+    Комментируйте здесь
+    
+    /*
+        Вложенные комментарии тоже поддерживаются
+    */
+*/
+
+//
+// MARK: Коллекции
+//
+
+/*
+    Массив (Array) и словарь (Dictionary) являются структурами (struct). Так
+    `let` и `var` также означают, что они изменяются (var) или не изменяются (let)
+    при объявлении переменных этих типов.
+*/
+
+// Массив
+var shoppingList = ["сом", "вода", "лимоны"]
+shoppingList[1] = "бутылка воды"
+let emptyArray = [String]() // let == неизменный
+let emptyArray2 = Array<String>() // как и выше
+var emptyMutableArray = [String]() // var == изменяемый
+
+
+// Словарь
+var occupations = [
+    "Malcolm": "Капитан",
+    "kaylee": "Техник"
+]
+occupations["Jayne"] = "Связи с общественностью"
+let emptyDictionary = [String: Float]() // let == неизменный
+let emptyDictionary2 = Dictionary<String, Float>() // как и выше
+var emptyMutableDictionary = [String: Float]() // var == изменяемый
+
+
+//
+// MARK: Поток управления
+//
+
+// цикл for для массива
+let myArray = [1, 1, 2, 3, 5]
+for value in myArray {
+    if value == 1 {
+        println("Один!")
+    } else {
+        println("Не один!")
+    }
+}
+
+// цикл for для словаря
+var dict = ["один": 1, "два": 2]
+for (key, value) in dict {
+    println("\(key): \(value)")
+}
+
+// цикл for для диапазона чисел
+for i in -1...shoppingList.count {
+    println(i)
+}
+shoppingList[1...2] = ["бифштекс", "орехи пекан"]
+// используйте ..< для исключения последнего числа
+
+// цикл while
+var i = 1
+while i < 1000 {
+    i *= 2
+}
+
+// цикл do-while
+do {
+    println("привет")
+} while 1 == 2
+
+// Переключатель
+// Очень мощный оператор, представляйте себе операторы `if` с синтаксическим
+// сахаром
+// Они поддерживают строки, объекты и примитивы (Int, Double, etc)
+let vegetable = "красный перец"
+switch vegetable {
+case "сельдерей":
+    let vegetableComment = "Добавьте немного изюма, имитируя муравьев на бревнышке."
+case "огурец", "кресс-салат":
+    let vegetableComment = "Было бы неплохо сделать бутерброд с чаем."
+case let localScopeValue where localScopeValue.hasSuffix("перец"):
+    let vegetableComment = "Это острый \(localScopeValue)?"
+default: // обязательный (чтобы предусмотреть все возможные вхождения)
+    let vegetableComment = "В супе все овощи вкусные."
+}
+
+
+//
+// MARK: Функции
+//
+
+// Функции являются типом первого класса, т.е. они могут быть вложены в функциях
+// и могут передаваться между собой
+
+// Функция с документированным заголовком Swift (формат reStructedText)
+
+/**
+    Операция приветствия
+
+    - Маркер в документировании
+    - Еще один маркер в документации
+
+    :param: name - это имя
+    :param: day - это день
+    :returns: Строка, содержащая значения name и day.
+*/
+func greet(name: String, day: String) -> String {
+    return "Привет \(name), сегодня \(day)."
+}
+greet("Боб", "вторник")
+
+// как и выше, кроме обращения параметров функции
+func greet2(#requiredName: String, externalParamName localParamName: String) -> String {
+    return "Привет \(requiredName), сегодня \(localParamName)"
+}
+greet2(requiredName:"Иван", externalParamName: "воскресенье")
+
+// Функция, которая возвращает множество элементов в кортеже
+func getGasPrices() -> (Double, Double, Double) {
+    return (3.59, 3.69, 3.79)
+}
+let pricesTuple = getGasPrices()
+let price = pricesTuple.2 // 3.79
+// Пропускайте значения кортежей с помощью подчеркивания _
+let (_, price1, _) = pricesTuple // price1 == 3.69
+println(price1 == pricesTuple.1) // вывод: true
+println("Цена газа: \(price)")
+
+// Переменное число аргументов
+func setup(numbers: Int...) {
+    // это массив
+    let number = numbers[0]
+    let argCount = numbers.count
+}
+
+// Передача и возврат функций
+func makeIncrementer() -> (Int -> Int) {
+    func addOne(number: Int) -> Int {
+        return 1 + number
+    }
+    return addOne
+}
+var increment = makeIncrementer()
+increment(7)
+
+// передача по ссылке
+func swapTwoInts(inout a: Int, inout b: Int) {
+    let tempA = a
+    a = b
+    b = tempA
+}
+var someIntA = 7
+var someIntB = 3
+swapTwoInts(&someIntA, &someIntB)
+println(someIntB) // 7
+
+
+//
+// MARK: Замыкания
+//
+var numbers = [1, 2, 6]
+
+// Функции - это частный случай замыканий ({})
+
+// Пример замыкания.
+// `->` отделяет аргументы и возвращаемый тип
+// `in` отделяет заголовок замыкания от тела замыкания
+numbers.map({
+    (number: Int) -> Int in
+    let result = 3 * number
+    return result
+})
+
+// Когда тип известен, как и выше, мы можем сделать так
+numbers = numbers.map({ number in 3 * number })
+// Или даже так
+//numbers = numbers.map({ $0 * 3 })
+
+print(numbers) // [3, 6, 18]
+
+// Хвостовое замыкание
+numbers = sorted(numbers) { $0 > $1 }
+
+print(numbers) // [18, 6, 3]
+
+// Суперсокращение, поскольку оператор < выполняет логический вывод типов
+
+numbers = sorted(numbers, < )
+
+print(numbers) // [3, 6, 18]
+
+//
+// MARK: Структуры
+//
+
+// Структуры и классы имеют очень похожие характеристики
+struct NamesTable {
+    let names = [String]()
+    
+    // Пользовательский индекс
+    subscript(index: Int) -> String {
+        return names[index]
+    }
+}
+
+// У структур автогенерируемый (неявно) инициализатор
+let namesTable = NamesTable(names: ["Me", "Them"])
+let name = namesTable[1]
+println("Name is \(name)") // Name is Them
+
+//
+// MARK: Классы
+//
+
+// Классы, структуры и их члены имеют трехуровневый контроль доступа
+// Уровни: internal (по умолчанию), public, private
+
+public class Shape {
+    public func getArea() -> Int {
+        return 0;
+    }
+}
+
+// Все методы и свойства класса являются открытыми (public).
+// Если вам необходимо содержать только данные
+// в структурированном объекте, вы должны использовать `struct`
+
+internal class Rect: Shape {
+    var sideLength: Int = 1
+    
+    // Пользовательский сеттер и геттер
+    private var perimeter: Int {
+        get {
+            return 4 * sideLength
+        }
+        set {
+            // `newValue` - неявная переменная, доступная в сеттере
+            sideLength = newValue / 4
+        }
+    }
+    
+    // Ленивая загрузка свойства
+    // свойство subShape остается равным nil (неинициализированным),
+    // пока не вызовется геттер
+    lazy var subShape = Rect(sideLength: 4)
+    
+    // Если вам не нужны пользовательские геттеры и сеттеры,
+    // но все же хотите запустить код перед и после вызовов геттера или сеттера
+    // свойств, вы можете использовать `willSet` и `didSet`
+    var identifier: String = "defaultID" {
+        // аргумент у `willSet` будет именем переменной для нового значения
+        willSet(someIdentifier) {
+            print(someIdentifier)
+        }
+    }
+    
+    init(sideLength: Int) {
+        self.sideLength = sideLength
+        // последним всегда вызывается super.init, когда init с параметрами
+        super.init()
+    }
+    
+    func shrink() {
+        if sideLength > 0 {
+            --sideLength
+        }
+    }
+    
+    override func getArea() -> Int {
+        return sideLength * sideLength
+    }
+}
+
+// Простой класс `Square` наследует `Rect`
+class Square: Rect {
+    convenience init() {
+        self.init(sideLength: 5)
+    }
+}
+
+var mySquare = Square()
+print(mySquare.getArea()) // 25
+mySquare.shrink()
+print(mySquare.sideLength) // 4
+
+// преобразование объектов
+let aShape = mySquare as Shape
+
+// сравнение экземпляров, в отличие от ==, которая проверяет эквивалентность
+if mySquare === mySquare {
+    println("Ага, это mySquare")
+}
+
+// Опциональная инициализация (init)
+class Circle: Shape {
+    var radius: Int
+    override func getArea() -> Int {
+        return 3 * radius * radius
+    }
+    
+    // Поместите постфиксный знак вопроса после `init` - это и будет опциональная инициализация,
+    // которая может вернуть nil
+    init?(radius: Int) {
+        self.radius = radius
+        super.init()
+        
+        if radius <= 0 {
+            return nil
+        }
+    }
+}
+
+var myCircle = Circle(radius: 1)
+println(myCircle?.getArea())    // Optional(3)
+println(myCircle!.getArea())    // 3
+var myEmptyCircle = Circle(radius: -1)
+println(myEmptyCircle?.getArea())    // "nil"
+if let circle = myEmptyCircle {
+    // не будет выполняться, поскольку myEmptyCircle равен nil
+    println("circle не nil")
+}
+
+
+//
+// MARK: Перечисления
+//
+
+// Перечисления могут быть определенного или своего типа.
+// Они могут содержать методы подобно классам.
+
+enum Suit {
+    case Spades, Hearts, Diamonds, Clubs
+    func getIcon() -> String {
+        switch self {
+        case .Spades: return "♤"
+        case .Hearts: return "♡"
+        case .Diamonds: return "♢"
+        case .Clubs: return "♧"
+        }
+    }
+}
+
+// Значения перечислений допускают сокращенный синтаксис, нет необходимости
+// указывать тип перечисления, когда переменная объявляется явно
+var suitValue: Suit = .Hearts
+
+// Нецелочисленные перечисления требуют прямого указания значений
+enum BookName: String {
+    case John = "Иоанн"
+    case Luke = "Лука"
+}
+println("Имя: \(BookName.John.rawValue)")
+
+// Перечисление (enum) со связанными значениями
+enum Furniture {
+    // Связать с типом Int
+    case Desk(height: Int)
+    // Связать с типами String и Int
+    case Chair(String, Int)
+    
+    func description() -> String {
+        switch self {
+        case .Desk(let height):
+            return "Письменный стол высотой \(height) см."
+        case .Chair(let brand, let height):
+            return "Стул марки \(brand) высотой \(height) см."
+        }
+    }
+}
+
+var desk: Furniture = .Desk(height: 80)
+println(desk.description())     // "Письменный стол высотой 80 см."
+var chair = Furniture.Chair("Foo", 40)
+println(chair.description())    // "Стул марки Foo высотой 40 см."
+
+
+//
+// MARK: Протоколы
+//
+
+// `protocol` может потребовать, чтобы у соответствующих типов
+// были определенные свойства экземпляра, методы экземпляра, тип методов,
+// операторы и индексы.
+
+protocol ShapeGenerator {
+    var enabled: Bool { get set }
+    func buildShape() -> Shape
+}
+
+// Протоколы, объявленные с @objc, допускают необязательные функции,
+// которые позволяют вам проверять на соответствие
+@objc protocol TransformShape {
+    optional func reshaped()
+    optional func canReshape() -> Bool
+}
+
+class MyShape: Rect {
+    var delegate: TransformShape?
+    
+    func grow() {
+        sideLength += 2
+        // Размещайте знак вопроса перед опционным свойством, методом
+        // или индексом, чтобы не учитывать nil-значение и возвратить nil
+        // вместо выбрасывания ошибки выполнения (т.н. "опционная цепочка")
+        if let allow = self.delegate?.canReshape?() {
+            // проверка делегата на выполнение метода
+            self.delegate?.reshaped?()
+        }
+    }
+}
+
+
+//
+// MARK: Прочее
+//
+
+// `extension`s: Добавляет расширенный функционал к существующему типу
+
+// Класс Square теперь "соответствует" протоколу `Printable`
+extension Square: Printable {
+    var description: String {
+        return "Площадь: \(self.getArea()) - ID: \(self.identifier)"
+    }
+}
+
+println("Объект Square: \(mySquare)")
+
+// Вы также можете расширить встроенные типы
+extension Int {
+    var customProperty: String {
+        return "Это \(self)"
+    }
+    
+    func multiplyBy(num: Int) -> Int {
+        return num * self
+    }
+}
+
+println(7.customProperty) // "Это 7"
+println(14.multiplyBy(3)) // 42
+
+// Обобщения: Подобно языкам Java и C#. Используйте ключевое слово `where`,
+// чтобы определить условия обобщений.
+
+func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
+    for (index, value) in enumerate(array) {
+        if value == valueToFind {
+            return index
+        }
+    }
+    return nil
+}
+let foundAtIndex = findIndex([1, 2, 3, 4], 3)
+println(foundAtIndex == 2) // вывод: true
+
+// Операторы:
+// Пользовательские операторы могут начинаться с символов:
+//      / = - + * % < > ! & | ^ . ~
+// или
+// Unicode- знаков математики, символов, стрелок, декорации и линий/кубов,
+// нарисованных символов.
+prefix operator !!! {}
+
+// Префиксный оператор, который утраивает длину стороны, когда используется
+prefix func !!! (inout shape: Square) -> Square {
+    shape.sideLength *= 3
+    return shape
+}
+
+// текущее значение
+println(mySquare.sideLength) // 4
+
+// Используя пользовательский оператор !!!, изменится длина стороны
+// путем увеличения размера в 3 раза
+!!!mySquare
+println(mySquare.sideLength) // 12
+```
diff --git a/ru-ru/xml-ru.html.markdown b/ru-ru/xml-ru.html.markdown
new file mode 100644
index 00000000..b0096b75
--- /dev/null
+++ b/ru-ru/xml-ru.html.markdown
@@ -0,0 +1,130 @@
+---
+language: xml
+filename: learnxml-ru.xml
+contributors:
+  - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+  - ["Dmitry Bessonov", "https://github.com/TheDmitry"]
+lang: ru-ru
+---
+
+XML - это язык разметки, предназначенный для хранения и передачи данных.
+
+В отличие от HTML, XML не определяет, как отображать или форматировать данные, он только содержит их.
+
+* XML-Синтаксис
+
+```xml
+<!-- Комментарии в XML выглядят вот так -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<bookstore>
+  <book category="КУЛИНАРИЯ">
+    <title lang="ru">Итальянская кухня каждый день</title>
+    <author>Giada De Laurentiis</author>
+    <year>2005</year>
+    <price>30.00</price>
+  </book>
+  <book category="ДЕТИ">
+    <title lang="ru">Гарри Поттер</title>
+    <author>Дж. К. Роулинг</author>
+    <year>2005</year>
+    <price>29.99</price>
+  </book>
+  <book category="ВСЕМИРНАЯ ПАУТИНА">
+    <title lang="ru">Изучаем XML</title>
+    <author>Эрик Рэй</author>
+    <year>2003</year>
+    <price>39.95</price>
+  </book>
+</bookstore>
+
+<!-- Вышеописанный документ - типичный XML-файл.
+  Он начинается с определения, объявляющего о некоторых метаданных (необязательно).
+  
+  XML использует древовидную структуру. У вышеописанного документа
+  корневой узел - 'bookstore', который содержит три дочерних узла - все 'book'-узлы.
+  Такие узлы содержат еще дочерние узлы и т.д.
+  
+  Узлы создаются с помощью открывающих/закрывающих тегов,
+  а дочерние узлы - это узлы между открывающимися и закрывающимися тегами.-->
+
+
+<!-- XML содержит в себе два типа данных:
+  1 - Атрибуты -> Это метаданные узлов.
+      Обычно XML-парсер использует эту информацию, чтобы хранить свойства данных.
+      Атрибут изображается путем вписывания его в скобки в пределах открытого тега
+  2 - Элементы -> Это чистые данные.
+      Это то, что парсер извлечет из XML-файла.
+      Элементы идут между открытыми и закрытыми тегами без скобок. -->
+      
+  
+<!-- Ниже элемент с двумя атрибутами -->
+<file type="gif" id="4293">компьютер.gif</file>
+
+
+```
+
+* Хорошо отформатированный документ x Проверка достоверности
+
+XML-документ хорошо отформатирован, если он синтаксически верный.
+Впрочем, в документ возможно ввести больше ограничений,
+используя определения документа, вроде DTD и XML-схемы.
+
+XML-документ, который следует описанию документа, называется корректным,
+относительно этого документа. 
+
+С таким инструментом вы можете проверить XML-данные вне логики приложения.
+
+```xml
+
+<!-- Ниже вы можете увидеть упрощенную версию документа книжного магазина,
+  с дополнением DTD-определения.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE note SYSTEM "Bookstore.dtd">
+<bookstore>
+  <book category="КУЛИНАРИЯ">
+    <title >Итальянская кухня каждый день</title>
+    <price>30.00</price>
+  </book>
+</bookstore>
+
+<!-- Этот DTD может быть чем-то вроде:-->
+
+<!DOCTYPE note
+[
+<!ELEMENT bookstore (book+)>
+<!ELEMENT book (title,price)>
+<!ATTLIST book category CDATA "Литература">
+<!ELEMENT title (#PCDATA)>
+<!ELEMENT price (#PCDATA)>
+]>
+
+
+<!-- DTD начинается с объявления.
+  Затем объявляется корневой узел, требующий 1 или более дочерних узлов 'book'.
+  Каждый 'book' должен содержать точно один 'title' и 'price', и атрибут,
+  называемый 'category', со значением "Литература" по умолчанию.
+  Узлы 'title' и 'price' содержат анализируемые символьные данные.-->
+
+<!-- DTD может быть объявлен в самом XML-файле.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE note
+[
+<!ELEMENT bookstore (book+)>
+<!ELEMENT book (title,price)>
+<!ATTLIST book category CDATA "Литература">
+<!ELEMENT title (#PCDATA)>
+<!ELEMENT price (#PCDATA)>
+]>
+
+<bookstore>
+  <book category="КУЛИНАРИЯ">
+    <title >Итальянская кухня каждый день</title>
+    <price>30.00</price>
+  </book>
+</bookstore>
+```