Merge remote-tracking branch 'adambard/master'

6 files changed, 1478 insertions, 208 deletions

diff --git a/sk-sk/LearnGit-sk.txt b/sk-sk/LearnGit-sk.txt
deleted file mode 100644
index 070a0489..00000000
--- a/sk-sk/LearnGit-sk.txt
+++ /dev/null
@@ -1,208 +0,0 @@
-$ git init
-
-# Zobraz a Nastav Základné Konfiguračné Premenné (Globálne)
-$ git config --global user.email "MôjEmail@Zoho.com"
-$ git config --global user.name  "Moje Meno
-
-# Rýchlo zobraz všetky dostupné príkazy
-$ git help
-
-# Zobraz všetky dostupné príkazy
-$ git help -a
-
-# Zobraz konkrétnu pomoc - použivateľský manuál
-# git help <príkaz_tu>
-$ git help add
-$ git help commit
-$ git help init
-# alebo git <príkaz_tu> --help
-$ git add --help
-$ git commit --help
-$ git init --help
-
-# Zobrazí vetvu, nesledované súbory, zmeny a ostatné rozdiely
-$ git status
-# Zistí iné vychytávky o git statuse
-$ git help status
-
-# pridá súbor z tvojho pracovného adresára
-$ git add HelloWorld.java
-
-# pridá súbor z iného adresára
-$ git add /cesta/k/súboru/HelloWorld.c
-
-# Môžeš použiť regulárne výrazy!
-$ git add ./*.java
-
-# zobraz existujúce vetvy a vzdialené repozitáre
-$ git branch -a
-
-# vytvor novú vetvu
-$ git branch myNewBranch
-
-# vymaž vetvu
-$ git branch -d myBranch
-
-# premenuj vetvu
-# git branch -m <starémeno> <novémeno>
-$ git branch -m mojaStaraVetva mojaNovaVetva
-
-# zmeň opis vetvy
-$ git branch myBranchName --edit-description
-
-# Zobrazí tagy
-$ git tag
-# Vytvorí tag so správou
-# -m špecifikuje správu, ktorá bude s tagom uložená.
-# Ak nešpeficikuješ správu pri tagu so správou,
-# Git spustí tvoj editor, aby si ju napísal.
-$ git tag -a v2.0 -m 'moja verzia 2.0'
-
-# Ukáž informácie o tagu
-# Zobrazí zadané informácie, dátum tagnutia commitu
-# a správu pred zobrazením informácií o commite.
-$ git show v2.0
-
-# Zverejní (pushne) jediný tag do vzdialeného repozitára
-$ git push origin v2.0
-
-# Zverejní viacero tagov do vzdialeného repozitára
-$ git push origin --tags
-
-# Aktualizuj strom, aby odpovedal (predvolene) 
-# hlavnej vetve repozitáru (master branch)
-$ git checkout
-
-# Aktualizuj strom, aby odpovedal konrkétnej vetve
-$ git checkout menoVetvy
-
-# Vytvor novú vetvu & prepni sa na ňu
-# ekvivalentný príkaz: "git branch <meno>; git checkout <meno>"
-$ git checkout -b nováVetva
-
-# Naklonuj learnxinyminutes-docs
-$ git clone https://github.com/adambard/learnxinyminutes-docs.git
-
-# povrchné klonovanie - rýchlejšie, uloží iba najnovšiu snímku
-$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
-
-# naklonuj iba konkrétnu vetvu
-$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
-
-# commitni so správou
-$ git commit -m "Pridal som multiplyNumbers() funkciu do HelloWorld.c"
-
-# automaticky pridaj zmenené a vymazané súbory do staging indexu,  potom ich commitni.
-$ git commit -a -m "Zmenil som foo.php a vymazal bar.php"
-
-# zmeň posledný commit (toto nahradí predchádzajúci commit novým)
-$ git commit --amend -m "Správna správa"
-
-# Ukáž rozdiel medzi pracovným repozitárom a indexom.
-$ git diff
-
-# Ukáž rozdiely medzi indexom a najnovším commitom.
-$ git diff --cached
-
-# Ukáž rozdiely medzi pracovným adresárom a najnovším commitom.
-$ git diff HEAD
-
-# Nastav, aby sa vo výsledkoch vyhľadávania zobrazovalo číslo riadku
-$ git config --global grep.lineNumber true
-
-# Urob výsledky vyhľadávania čitateľnejšie, vrátane zoskupovania
-$ git config --global alias.g "grep --break --heading --line-number"
-
-# Vďaka Travisovi Jefferymu za túto sekciu
-# Hľadaj "názovPremennej" vo všetkých java súboroch
-$ git grep 'názovPremennej' -- '*.java'
-
-# Hľadaj riadok, ktorý obsahuje "názovPoľa" a "add" alebo "remove"
-$ git grep -e 'arrayListName' --and \( -e add -e remove \)
-
-# Zobraz všetky commity
-$ git log
-
-# Zobraz iba správy a referencie commitov
-$ git log --oneline
-
-# Zobraz zlúčené (merged) commity
-$ git log --merges
-
-# Zobraz všetky commity vo forme ASCII grafu
-$ git log --graph
-
-# Zlúč vybranú vetvu do aktuálnej.
-$ git merge názovVetvy
-
-# Vždy vytvor zlučovací commit
-$ git merge --no-ff názovVetvy
-
-# Premenuj súbor
-$ git mv HelloWorld.c HelloNewWorld.c
-
-# Presuň súbor
-$ git mv HelloWorld.c ./nová/cesta/HelloWorld.c
-
-# "Nasilu" premenuj, alebo presuň
-# "existujúciSúbor" už v adresári existuje, bude prepísaný
-$ git mv -f môjSúbor existujúciSúbor
-
-# Aktualizuje tvoj lokálny repozitár zlúčením nových zmien
-# zo vzdialených "origin" a "master" vetiev.
-# git pull <alias-vzdialeného-repo> <vetva>
-$ git pull origin master
-
-# Predvolene, git pull aktualizuje tvoju aktuálnu vetvu
-# zlúčením nových zmien zo vzdialenej vetvy 
-$ git pull
-
-# Zlúč zmeny zo vzdialenej vetvy a presuň vetvu do nového základného commitu (rebase)
-# vetva commitne na tvoj lokálny repozitár, ekvivalentný príkaz: "git pull <alias-vzdialeného-repo> <vrstva>, git rebase <branch>"
-$ git pull origin master --rebase
-
-# Zverejni a zlúč zmeny z lokálneho repozitára do
-# vzdialených vetiev s názvom "origin" a "master".
-# git push <vzdialené> <vetvy>
-$ git push origin master
-
-# Predvolene git zverejní a zlúči zmeny z
-# aktuálnej vetvy do vzdialenej vetvy s ňou spojenej
-$ git push
-
-# Na spojenie lokálnej vetvy so vzdialenou pridaj -u:
-$ git push -u origin master
-# Kedykoľvek budeš chcieť zverejniť z rovnakej lokálnej vetvy, použi príkaz:
-$ git push
-
-# Aplikuj commity z experimentálnej vetvy na master
-# git rebase <základnáVetva> <ináVetva>
-$ git rebase master experimentBranch
-
-# Resetni index (vrstvu medzi pracovným stromom a Git repozitárom), aby odpovedal najnovšiemu commitu (adresár ostane nezmenený)
-$ git reset
-
-# Resetni index, aby odpovedal najnovšiemu commitu (adresár sa prepíše)
-$ git reset --hard
-
-# Presunie vrchol aktuálnuej vetvy do konkrétneho commitu (adresár ostane nezmenený)
-# všetky zmeny sú zachované v adresári.
-$ git reset 31f2bb1
-
-# Vezmi späť konkrétny commit
-$ git revert <commit>
-
-# odstráň HelloWorld.c
-$ git rm HelloWorld.c
-
-# Odstráň súbor z vnoreného adresára
-$ git rm /pather/to/the/file/HelloWorld.c
-
-
-
-
-
-
-
-
-
diff --git a/sk-sk/bash.html.markdown b/sk-sk/bash.html.markdown
new file mode 100644
index 00000000..e9d1490c
--- /dev/null
+++ b/sk-sk/bash.html.markdown
@@ -0,0 +1,286 @@
+---
+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:
+    - ["Juraj Kostolanský", "http://www.kostolansky.sk"]
+lang: sk-sk
+filename: LearnBash-sk.sh
+---
+
+Bash je pomenovanie pre unix shell (príkazový interpreter), ktorý bol
+tiež distribuovaný ako shell pre GNU operačné systémy a ako predvolený
+shell pre Linux a Mac OS X.
+Takmer všetky príklady uvedené nižšie môžu byť súčasťou shell skriptu alebo
+vykonané priamo v shelli.
+
+[Viac informácií tu.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# Prvý riadok skriptu je tzv. shebang, ktorý systému povie ako skript vykonať:
+# http://en.wikipedia.org/wiki/Shebang_(Unix)
+# Komentáre začínajú znakom #. Shebang je tiež komentár.
+
+# Jednoduchý príklad:
+echo Ahoj svet!
+
+# Každý príkaz začína na novom riadku alebo za bodkočiarkou:
+echo 'Toto je prvý riadok'; echo 'Toto je druhý riadok'
+
+# Deklarácia premenných vyzerá takto:
+Premenna="Nejaky retazec"
+
+# Ale nie takto:
+Premenna = "Nejaky retazec"
+# Bash si bude myslieť, že Premenna je príkaz, ktorý musí vykonať.
+# Výsledkom bude chyba, pretože taký príkaz nenájde.
+
+# Alebo takto:
+Premenna= 'Nejaky retazec'
+# Bash zistí, že 'Nejaky retazec' je príkaz, ktorý musí vykonať.
+# Výsledkom je opäť chyba, lebo taký príkaz neexistuje.
+
+# Používanie premenných:
+echo $Premenna
+echo "$Premenna"
+echo '$Premenna'
+# Keď je premenná použitá samostatne - priradenie, exportovanie a pod. - jej
+# meno sa píše bez znaku $. Keď sa používa hodnota premennej, pred názov sa
+# dáva znak $. Pozor však pri použití ' (apostrof), ktorý nenahradí premennú
+# hodnotou!
+
+# Nahradenie reťazca v premennej
+echo ${Premenna/Nieco/A}
+# Toto nahradí prvý výskyt reťazca "Nieco" za "A"
+
+# Podreťazec z premennej
+Dlzka=7
+echo ${Premenna:0:Dlzka}
+# Toto vráti iba prvých 7 znakov z hodnoty premennej
+
+# Predvolená hodnota premennej
+echo ${Foo:-"PredvolenaHodnotaAkFooChybaAleboJePrazdna"}
+# Toto funguje pre null (Foo=) a prázdny reťazec (Foo="");
+# nula (Foo=0) vráti 0. Všimni si, že toto iba vráti predvolenú hodnotu,
+# ale nezmení hodnotu premennej.
+
+# Štandardné premenné:
+# Existujú aj užitočné "vstavané" premenné, ako
+echo "Hodnota vrátená posledným programom: $?"
+echo "PID skriptu: $$"
+echo "Počet argumentov: $#"
+echo "Argumeny skriptu: $@"
+echo "Argumeny skriptu oddelené do rôznych premenných: $1 $2..."
+
+# Čítanie hodnoty zo vstupu:
+echo "Ako sa voláš?"
+read Meno # Premenná nemusí byť deklarovaná skôr
+echo Ahoj, $Meno!
+
+# Klasická if štruktúra:
+# použi 'man test' Pre viac informácií o podmienkach
+if [ $Meno -ne $USER ]
+then
+    echo "Meno nie je tvoje používateľské meno"
+else
+    echo "Meno je tvoje používateľské meno"
+fi
+
+# Existuje aj podmienené vykonanie
+echo "Vykonané vždy" || echo "Vykonané iba ak prvý príkaz zlyhá"
+echo "Vykonané vždy" && echo "Vykonané iba ak prvý príkaz uspeje"
+
+# Pre použitie && a || s if-podmienkou je potrebné použiť zátvorky:
+if [ $Meno == "Steve" ] && [ $Vek -eq 15 ]
+then
+    echo "Toto sa spustí ak $Meno je Steve a $Vek je 15."
+fi
+
+if [ $Meno == "Daniya" ] || [ $Meno == "Zach" ]
+then
+    echo "Toto sa spustí ak $Meno je Daniya alebo Zach."
+fi
+
+# Pre výrazy sa používa nasledovný formát:
+echo $(( 10 + 5 ))
+
+# Na rozdiel od programovacích jazykov shell pracuje v kontexte aktuálneho
+# adresára. Môžeš si prehliadať súbory a adresáre v aktuálnom adresári pomocou
+# príkazu ls:
+ls
+
+# Tieto príkazy majú aj argumenty pre úpravu ich správania:
+ls -l # Vypíše zoznam súborov a priečinkov, každý na samostatnom riadku
+
+# Výsledok predchádzajúceho príkazu môže byť využitý priamo ako vstup pre
+# ďalší príkaz.
+# Príkaz grep filtruje vstupvyužitím poskytnutého vzoru. Takto môžeme vypísať
+# iba .txt súbory:
+ls -l | grep "\.txt"
+
+# Vstup a výstup príkazu (stdin, stdout, stderr) môžu byť presmerované.
+# Toto číta stdin až po ^EOF$ a prepíše hello.py riadkami medzi "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
+
+# Spustí hello.py s rôznymi presmerovaniami pre stdin, stdout a stderr:
+python hello.py < "vstup.in"
+python hello.py > "vystup.out"
+python hello.py 2> "chyby.err"
+python hello.py > "vystup-a-chyby.log" 2>&1
+python hello.py > /dev/null 2>&1
+# Chybový výstup prepíše uvedený súbor, ak už existuje.
+# Ak chceš výstup pridať za existujúci obsah, použi ">>":
+python hello.py >> "vystup.out" 2>> "chyby.err"
+
+# Prepíše vystup.out, pripojí k chyby.err a spočíta riadky:
+info bash 'Basic Shell Features' 'Redirections' > vystup.out 2>> chyby.err
+wc -l vystup.out chyby.err
+
+# Spustí príkaz a vypíše deskriptor súboru (napr. /dev/fd/123)
+# pozri: man fd
+echo <(echo "#ahojsvet")
+
+# Prepíše vystup.out s "#ahojsvet":
+cat > vystup.out <(echo "#ahojsvet")
+echo "#ahojsvet" > vystup.out
+echo "#ahojsvet" | cat > vystup.out
+echo "#ahojsvet" | tee vystup.out >/dev/null
+
+# Potichu odstráni dočasné súbory (pridaj '-i' pre interaktivitu)
+rm -v vystup.out chyby.err vystup-a-chyby.log
+
+# Príkazy môžu byť nahradené v iných príkazoch použitím $( ):
+# Nasledujúci príkaz vypíše počet súborov a adresárov v aktuálnom adresári
+echo "Je tu $(ls | wc -l) súborov a priečinkov."
+
+# To isté sa dá spraviť pomocou spätného apostrofu ``, tie však nemôžu byť
+# vhniezdené - preferovaný spôsob je preto $( ).
+echo "Je tu `ls | wc -l` súborov a priečinkov."
+
+# Bash používa case, ktorý funguje podobne ako switch v Jave a C++:
+case "$Premenna" in
+    #Zoznam vzorov pre podmienky
+    0) echo "Je to nula.";;
+    1) echo "Je to jednotka.";;
+    *) echo "Nie je to null.";;
+esac
+
+# for-cyklus iteruje cez všetky argumenty:
+# Obsah premennej $Premenna sa vypíše trikrát.
+for Premenna in {1..3}
+do
+    echo "$Premenna"
+done
+
+# Alebo "tradičným" spôsobom:
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# Môžu sa použiť aj na súbory..
+# Toto spustí príkaz 'cat' na subor1 a subor2
+for Premenna in subor1 subor2
+do
+    cat "$Premenna"
+done
+
+# ..alebo na výstup príkazu.
+# Toto použije príkaz cat na výstup z ls.
+for Vystup in $(ls)
+do
+    cat "$Vystup"
+done
+
+# while-cykklus:
+while [ true ]
+do
+    echo "telo cyklu..."
+    break
+done
+
+# Môžeš tiež definovať funkice
+# Definícia:
+function foo ()
+{
+    echo "Argumenty fungujú rovnako ako pri skriptoch: $@"
+    echo "A: $1 $2..."
+    echo "Toto je funkcia"
+    return 0
+}
+
+# alebo jednoducho
+bar ()
+{
+    echo "Iný spôsob definície funkcií"
+    return 0
+}
+
+# Volanie funkcie
+foo "Moje meno je" $Meno
+
+# Existuje veľa užitočných príkazov, ktoré sa oplatí naučiť:
+# vypíše posledných 10 riadkov zo subor.txt
+tail -n 10 subor.txt
+# vypíše prvých 10 riadkov zo subor.txt
+head -n 10 subor.txt
+# zotriedi riadky zo subor.txt
+sort subor.txt
+# vypíše alebo vynechá opakované riadky, použitím -d ich vypíše
+uniq -d subor.txt
+# vypíše iba prvý stĺpecpred znakom ','
+cut -d ',' -f 1 subor.txt
+# nahradí každý výskyt 'oukej' za 'super' v subor.txt (možnosť použiť regex)
+sed -i 's/oukej/super/g' subor.txt
+# vypíše všetky riadky zo subor.txt ktoré vyhovujú regexu
+# ukážka vypíše riadky ktoré začínajú s "foo" a končia s "bar"
+grep "^foo.*bar$" subor.txt
+# pre výpis počtu riadkov vyhovujúcich regexu slúži "-c"
+grep -c "^foo.*bar$" subor.txt
+# pre vyhľadávanie reťazca bez regexu slúži fgrep (alebo grep -F)
+fgrep "^foo.*bar$" subor.txt
+
+
+# Prečítaj si dokumentáciu k Bash shellu použitím príkazu 'help':
+help
+help help
+help for
+help return
+help source
+help .
+
+# Prečítaj si Bash manpage dokumentáciu príkazom 'man'
+apropos bash
+man 1 bash
+man bash
+
+# Prečítaj si info dokumentáciu pomocou 'info' (? pre help)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# Prečítaj si bash info dokumentáciu:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/sk-sk/coffeescript.html.markdown b/sk-sk/coffeescript.html.markdown
new file mode 100644
index 00000000..30bbceec
--- /dev/null
+++ b/sk-sk/coffeescript.html.markdown
@@ -0,0 +1,108 @@
+---
+language: coffeescript
+contributors:
+  - ["Tenor Biel", "http://github.com/L8D"]
+  - ["Xavier Yao", "http://github.com/xavieryao"]
+translators:
+  - ["Juraj Kostolanský", "http://www.kostolansky.sk"]
+lang: sk-sk
+filename: coffeescript-fr.coffee
+---
+
+CoffeeScript je jazyk, ktorý sa kompiluje do ekvivalentného JavaScriptu,
+neexistuje peňho interpretácia počas behu programu (runtime).
+CoffeeScript sa snaží vytvárať čitateľný, pekne formátovaný a optimalizovaný
+JavaScriptový kód pracujúci pod každým JavaScriptovým prostredím.
+
+Pozri tiež [stránku CoffeeScript](http://coffeescript.org/), ktoré obsahuje kompletný tutoriál o CoffeeScripte.
+
+```coffeescript
+# CoffeeScript je jazyk hipsterov.
+# Ide s trendom mnohých moderných jazykov.
+# Komentáre sú podobné tým v Ruby a Pythone, používajú symbol #.
+
+###
+Blokové komentáre vyzerajú takto, prekladajú sa priamo do '/ * ... * /'
+pre výsledný kód JavaScriptu.
+
+Predtým, než budeš pokračovať, mal by si rozumieť sémantike JavaScriptu.
+###
+
+# Priradenia:
+cislo = 42   #=> var cislo = 42;
+opak  = true #=> var opak = true;
+
+# Podmienky:
+cislo = -42 if opak #=> if(opak) { cislo = -42; }
+
+# Funkcie:
+stvorec = (x) -> x * x #=> var stvorec = function(x) { return x * x; }
+
+vypln = (nadoba, tekutina = "káva") ->
+  "#{nadoba} sa napĺňa tekutinou #{tekutina}..."
+#=>var vypln;
+#
+#vypln = function(nadoba, tekutina) {
+#  if (tekutina == null) {
+#    tekutina = "káva";
+#  }
+#  return nadoba + " sa napĺňa tekutinou " + tekutina + "...";
+#};
+
+# Rozsahy:
+zoznam = [1..5] #=> var zoznam = [1, 2, 3, 4, 5];
+
+# Objekty:
+matika =
+  zaklad:  Math.sqrt
+  stvorec: square
+  kocka:   (x) -> x * square x
+#=> var matika = {
+#  "zaklad": Math.sqrt,
+#  "stvorec": square,
+#  "kocka": function(x) { return x * square(x); }
+#}
+
+# Splat operátor:
+zavod = (vitaz, bezci...) ->
+  print vitaz, bezci
+#=>zavod = function() {
+#  var vitaz, bezci;
+#  vitaz = arguments[0],
+#  bezci = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+#  return print(vitaz, bezci);
+#};
+
+# Existencia:
+alert "Vedel som to!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null)
+# { alert("Vedel som to!"); }
+
+# Pole:
+kocky = (matika.kocka cislo for cislo in zoznam)
+#=>kocky = (function() {
+#	var _i, _len, _results;
+#	_results = [];
+# 	for (_i = 0, _len = zoznam.length; _i < _len; _i++) {
+#		cislo = zoznam[_i];
+#		_results.push(matika.kocka(cislo));
+#	}
+#	return _results;
+#  })();
+
+jedla = ['brokolica', 'špenát', 'čokoláda']
+zjedz jedlo for jedlo in jedla when jedlo isnt 'čokoláda'
+#=>jedla = ['brokolica', 'špenát', 'čokoláda'];
+#
+#for (_k = 0, _len2 = jedla.length; _k < _len2; _k++) {
+#  jedlo = jedla[_k];
+#  if (jedlo !== 'čokoláda') {
+#    zjedz(jedlo);
+#  }
+#}
+```
+
+## Ďalšie zdroje
+
+- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/)
+- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
diff --git a/sk-sk/elixir.html.markdown b/sk-sk/elixir.html.markdown
new file mode 100644
index 00000000..2401f92e
--- /dev/null
+++ b/sk-sk/elixir.html.markdown
@@ -0,0 +1,470 @@
+---
+language: elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+    - ["Ryan Plant", "https://github.com/ryanplant-au"]
+translators:
+  - ["Peter Szatmary", "https://github.com/peterszatmary"]
+lang: sk-sk
+filename: learnelixir-sk.ex
+---
+
+Elixir je moderný funkcionálny jazyk vytvorený nad Erlang VM (virtuálnym
+strojom). Je plne kompatibilný s Erlangom, ale ponúka viac štandardnú syntax
+a množstvo funkcií.
+
+```Elixir
+
+# Jednoriadkový komentár začína symbolom #
+
+# Neexistuje viacriadkový komentár, avšak je možné vyskladať za sebou viac
+# jednoriadkových komentárov.
+
+# Pre spustenie Elixir shellu zadajte príkaz `iex`
+# Kompiláciu zdrojových kódov vykonáte príkazom `elixirc`
+
+# Obe príkazy by sa už mali nachádzať v path pokiaľ ste nainštalovali elixir
+# správne.
+
+## ---------------------------
+## -- Základné typy
+## ---------------------------
+
+# Čísla
+3    # integer
+0x1F # integer
+3.0  # float
+
+# Atómy, sú literály, konštanty s rovnakým menom. Začínajú s `:`.
+:ahoj # atom
+
+# Tzv. Tuples sú v pamäti uložené súvisle.
+{1,2,3} # tuple
+
+# Pristúpiť k tuple elementu vieme pomocou funkcie `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Zoznamy sú implementované ako linkované zoznamy.
+[1,2,3] # zoznam
+
+# Vieme pristúpiť k hlavičke (head) a chvostu (tail) zoznamu:
+[head | tail] = [1,2,3]
+head #=> 1
+tail #=> [2,3]
+
+# V Elixire, rovnako ako v Erlangu, `=` znamená pattern matching a nie
+# klasické priradenie.
+#
+# To znamená, že ľavá strana (pattern / vzor) je postavená oproti pravej
+# strane.
+#
+# Takto funguje aj príklad vyššie s čítaním hlavičky a chvosta zoznamu.
+
+# Pattern match končí chybou ak sa obe strany nezhodujú, v tomto príklade majú
+# tuples rôznu veľkosť.
+# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Binárne typy
+<<1,2,3>> # binary
+
+# Reťazce a zoznamy znakov
+"ahoj" # reťazec
+'ahoj' # zoznam znakov
+
+# Viacriadkový reťazec
+"""
+Ja som viacriadkový
+reťazec.
+"""
+#=> "Ja som viacriadkový\nreťazec.\n"
+
+# Reťazce sú kódované v UTF-8:
+"héllò" #=> "héllò"
+
+# Reťazce sú skutočne iba binárne typy, a zoznamy znakov sú iba zoznamy.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` v elixire vráti ASCII číselnú reprezentáciu pre znak `a`
+?a #=> 97
+
+# Pre spájanie zoznamov sa používa `++`, pre binárne typy `<>`
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'ahoj ' ++ 'svet'  #=> 'ahoj svet'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"Ahoj " <> "svet"  #=> "ahoj svet"
+
+# Rozsahy sú reprezentované ako `začiatok..koniec` (obe inkluzívne)
+1..10 #=> 1..10
+dolna..horna = 1..10 # Na rozsahy možno použiť rovnako pattern matching
+[dolna, horna] #=> [1, 10]
+
+# Mapy sú páry kľúč-hodnota
+pohlavia = %{"david" => "muž", "gillian" => "žena"}
+pohlavia["david"] #=> "muž"
+
+# Mapy s kľúčmi reprezentovanými atómami môžu byť použité takto
+pohlavia = %{david: "muž", gillian: "žena"}
+pohlavia.gillian #=> "žena"
+
+## ---------------------------
+## -- Operátory
+## ---------------------------
+
+# Trošku matematiky
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# V elixire operátor `/` vždy vráti float (reálne číslo).
+
+# Pre celočíselné delenie sa používa `div`
+div(10, 2) #=> 5
+
+# Pre celočíselné delenie so zvyškom `rem`
+rem(10, 3) #=> 1
+
+# Boolean operátory: `or`, `and` a `not`.
+# Tieto operátori očakávajú ako svoj prvý argument boolean.
+true and true #=> true
+false or true #=> true
+# 1 and true    #=> ** (ArgumentError) argument error
+
+# Elixir tiež poskytuje `||`, `&&` a `!` , ktoré akceptujú argumenty
+# ľubovoľného typu.
+# Všetky hodnoty okrem `false` a `nil` budú vyhodnotené ako true.
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# Pre porovnávanie máme: `==`, `!=`, `===`, `!==`, `<=`,
+`>=`, `<` a `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` a `!==` sú viac striktné pri porovnávaní celých čísel (integer) a
+# desatinných čísel (float).
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# Vieme porovnať dokonca dva rôzne údajové typy:
+1 < :ahoj #=> true
+
+# Celkové poradie triedenia:
+#
+# číslo < atom < referencia < funkcia < port < pid < tuple < zoznam < bitový
+# string
+
+# Výrok Joe Armstronga: "Aktuálne poradie nie je dôležité, ale
+# dôležité je to, že celkové poradie je dobre definované."
+
+## ---------------------------
+## -- Riadenie toku
+## ---------------------------
+
+# `if` výraz
+if false do
+  "Toto nebude nikdy videné"
+else
+  "Toto bude"
+end
+
+# Existuje aj `unless`
+unless true do
+  "Toto nebude nikdy videné"
+else
+  "Toto bude"
+end
+
+# Pamätáte sa na pattern matching? Mnoho štruktúr pre riadenie toku v
+# elixire sa spoliehajú práve na pattern matching.
+
+# `case` dovolí nám porovnať hodnotu oproti mnohým vzorom:
+case {:one, :two} do
+  {:four, :five} ->
+    "Toto nebude zhodné"
+  {:one, x} ->
+    "Toto bude zhodné a nastaví `x` na hodnotu `:two` "
+  _ ->
+    "Toto bude zhodné z ľubovoľnou hodnotou."
+end
+
+# Je zvyčajné nastaviť hodnotu do `_` ak ju nepotrebujete.
+# Napríklad, ak je pre nás potrebná iba hlavička zoznamu (head):
+[head | _] = [1,2,3]
+head #=> 1
+
+# Pre lepšiu čitateľnosť môžme urobiť nasledovné:
+[head | _tail] = [:a, :b, :c]
+head #=> :a
+
+# `cond` dovoľuje kontrolovať viac podmienok naraz.
+# Použite `cond` namiesto vnorovania mnohých `if` výrazov.
+cond do
+  1 + 1 == 3 ->
+    "Nebudem nikdy videný"
+  2 * 5 == 12 ->
+    "Ani ja"
+  1 + 2 == 3 ->
+    "Ja budem"
+end
+
+# Je bežné nastaviť poslednú podmienku rovnajúcu sa `true` , ktorá bude vždy
+# zodpovedať.
+cond do
+  1 + 1 == 3 ->
+    "Nebudem nikdy videný"
+  2 * 5 == 12 ->
+    "Ani ja"
+  true ->
+    "Ale ja budem (je to v podstate vetva else)"
+end
+
+# `try/catch` sa používa na zachytenie hodnôt, ktoré boli vyhodené, takisto
+# podporuje `after` klauzulu, ktorá je zavolaná vždy, či bola hodnota
+# zachytená alebo nie.
+try do
+  throw(:ahoj)
+catch
+  message -> "Mám #{message}."
+after
+  IO.puts("Som after klauzula.")
+end
+#=> Som after klauzula
+# "Mám :ahoj"
+
+## ---------------------------
+## -- Moduly a funkcie
+## ---------------------------
+
+# Anonymné funkcie (všimnite si bodku)
+stvorec = fn(x) -> x * x end
+stvorec.(5) #=> 25
+
+# Takisto akceptujú viax klauzúl a tzv. stráže (guards).
+# Stráže vám umožnia pattern matching ešte viac zlepšiť, tieto časti sú
+# označené kľúčovým slovom `when`:
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir tiež poskytuje množstvo vstavaných funkcií.
+# Tie sú dostupné v aktuálnom scope (viditeľnej oblasti).
+is_number(10)    #=> true
+is_list("hello") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Možno zgrupovať viac funkcií do jedného modulu. V module použite `def`
+# na definíciu funkcie.
+defmodule Matematika do
+  def sucet(a, b) do
+    a + b
+  end
+
+  def na_druhu(x) do
+    x * x
+  end
+end
+
+Matematika.sucet(1, 2)  #=> 3
+Matematika.na_druhu(3) #=> 9
+
+# Na zkompilovanie našeho Matematika modulu ho uložte ako `math.ex`  a použite
+# `elixirc` v termináli: elixirc math.ex
+
+# V module môžme definovať funkcie s `def` a privátne funkcie s `defp`.
+# Funkcia definovaná s `def` je možné volať z iných modulov, privátne funkcie
+# môžu byť volané iba lokálne.
+defmodule SukromnaMatematika do
+  def sucet(a, b) do
+    rob_sucet(a, b)
+  end
+
+  defp rob_sucet(a, b) do
+    a + b
+  end
+end
+
+SukromnaMatematika.sucet(1, 2)    #=> 3
+# SukromnaMatematika.rob_sucet(1, 2) #=> ** (UndefinedFunctionError)
+
+# Deklarácie funkcií tiež podporujú stráže (guards) a viacnásobné klauzuly:
+
+defmodule Geometria do
+  def oblast({:obdlznik, w, h}) do
+    w * h
+  end
+
+  def oblast({:kruh, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometria.oblast({:obdlznik, 2, 3}) #=> 6
+Geometria.oblast({:kruh, 3})       #=> 28.25999999999999801048
+# Geometria.oblast({:kruh, "nie_je_cislo"})
+#=> ** (FunctionClauseError) no function clause matching in Geometria.oblast/1
+
+# Vďaka nemeniteľnosti (immutability) je rekurzia významnou časťou elixiru
+defmodule Rekurzia do
+  def sumuj_zoznam([hlavicka | schvost], acc) do
+    sumuj_zoznam(chvost, acc + hlavicka)
+  end
+
+  def sumuj_zoznam([], acc) do
+    acc
+  end
+end
+
+Rekurzia.sumuj_zoznam([1,2,3], 0) #=> 6
+
+# Elixir moduly podporujú atribúty, existujú vstavané atribúty a takisto
+# môžte pridávať vlastné.
+defmodule MojModul do
+  @moduledoc """
+  Toto je vstavaný atribút v príkladovom module.
+  """
+
+  @moj_udaj 100 # Toto je vlastný atribút.
+  IO.inspect(@moj_udaj) #=> 100
+end
+
+# Pipe operátor (rúra) |> umožnuje predať výsledok výrazu ako prvý parameter
+# do ďalšej funkcie.
+
+Range.new(1,10)
+|> Enum.map(fn x -> x * x end)
+|> Enum.filter(fn x -> rem(x, 2) == 0 end)
+#=> [4, 16, 36, 64, 100]
+
+## ---------------------------
+## -- Štruktúry a výnimky
+## ---------------------------
+
+# Štruktúry sú rozšírenia postavené na mapách, ktoré prinášajú defaultné
+# hodnoty, garancie v čase kompilácie a polymorfizmus do Elixiru.
+defmodule Osoba do
+  defstruct meno: nil, vek: 0, vyska: 0
+end
+
+joe_info = %Osoba{ meno: "Joe", vek: 30, vyska: 180 }
+#=> %Osoba{vek: 30, vyska: 180, meno: "Joe"}
+
+# Prístup k hodnote mena
+joe_info.meno #=> "Joe"
+
+# Zmena hodnoty veku
+starsi_joe_info = %{ joe_info | vek: 31 }
+#=> %Osoba{vek: 31, vyska: 180, meno: "Joe"}
+
+# `try` blok s kľúčovým slovom `rescue` sa používa na riadenie výnimiek
+try do
+  raise "nejaký error"
+rescue
+  RuntimeError -> "zachytí runtime error"
+  _error -> "zachytí ľubovoľný iný error"
+end
+#=> "zachytí runtime error"
+
+# Každá výnimka má správu
+try do
+  raise "nejaký error"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+#=> "nejaký error"
+
+## ---------------------------
+## -- Konkurencia
+## ---------------------------
+
+# Elixir sa pri konkurencii spolieha na Actor model. Všetko čo je
+# potrebné na písanie konkuretných programov v elixire sú tri primitívy:
+# spawning procesy, posielanie a prijímanie správ.
+
+# Na spustnenie nového procesu použijeme `spawn` funkciu, ktorá má ako
+# parameter funkciu.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` vracia pid (identifikátor procesu), tento pid možno použiť na
+# posielanie správ procesu. Správu pošleme `send` operatorátorom.
+# Aby všetko fungovalo ako má, potrebujeme byť schopný správu prijať. To
+# dosiahneme s `receive` mechanizmom:
+
+# `receive do` blok sa používa na počúvanie správ a ich spracúvavanie v čase
+# prijatia. `receive do` blok spracuje iba jednu prijatú správu. Pre
+# spracovanie viacerých správ, musí funkcia s `receive do` blokom rekurzívne
+# volať samu seba, aby sa dostala opäť do `receive do` bloku.
+
+defmodule Geometria do
+  def slucka_oblasti do
+    receive do
+      {:obdlznik, w, h} ->
+        IO.puts("Oblast = #{w * h}")
+        slucka_oblasti()
+      {:kruh, r} ->
+        IO.puts("Oblast = #{3.14 * r * r}")
+        slucka_oblasti()
+    end
+  end
+end
+
+# Kompiluj modul a vytvor proces, ktorý vyhodnotí `slucka_oblasti` v shelli
+
+pid = spawn(fn -> Geometria.slucka_oblasti() end) #=> #PID<0.40.0>
+# Alternatívne
+pid = spawn(Geometria, :slucka_oblasti, [])
+
+# Pošli správu ku `pid`, ktorá bude v zhode so vzorom v receive časti
+send pid, {:obdlznik, 2, 3}
+#=> Oblast = 6
+#   {:obdlznik,2,3}
+
+send pid, {:kruh, 2}
+#=> Oblast = 12.56000000000000049738
+#   {:kruh,2}
+
+# Shell je takisto proces, môžete použiť `self` pre zistenie aktuálneho pid-u
+self() #=> #PID<0.27.0>
+
+## ---------------------------
+## -- Agenti
+## ---------------------------
+
+# Agent je proces, ktorý udržuje informácie o meniacej sa hodnote
+
+# Vytvor agenta s `Agent.start_link` parametrom, ktorého je funkcia
+# Iniciálny stav agenta bude čokoľvek, čo daná funkcia vráti
+{ok, moj_agent} = Agent.start_link(fn -> ["cervena, zelena"] end)
+
+# `Agent.get` vezme meno agenta a `fn` , ktorej je odovzdaný aktuálny stav
+# Čokoľvek čo `fn` vráti je to, čo dostanete späť
+Agent.get(moj_agent, fn farby -> farby end) #=> ["cervena, "zelena"]
+
+# Zmena stavu agenta rovnakým spôsobom
+Agent.update(moj_agent, fn farby -> ["modra" | farby] end)
+```
+
+## Referencie
+
+* [Začíname](http://elixir-lang.org/getting-started/introduction.html) z
+[Elixir stránky](http://elixir-lang.org)
+* [Elixir dokumentácia](http://elixir-lang.org/docs/master/)
+* [Elixir programovanie](https://pragprog.com/book/elixir/programming-elixir)
+ od Dave Thomasa
+* [Elixir ťahák](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* [Nauč sa kúsok Erlangu pre veľké dobro!](http://learnyousomeerlang.com/) od
+Freda Heberta
+* [Erlang programovanie: Softvér pre konkurentný svet](https://pragprog
+.com/book/jaerlang2/programming-erlang) od Joe Armstronga
diff --git a/sk-sk/json.html.markdown b/sk-sk/json.html.markdown
new file mode 100644
index 00000000..2b1fbb58
--- /dev/null
+++ b/sk-sk/json.html.markdown
@@ -0,0 +1,61 @@
+---
+language: json
+filename: learnjson-sk.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+  - ["Juraj Kostolanský", "http://www.kostolansky.sk"]
+lang: sk-sk
+---
+
+Nakoľko je JSON extrémne jednoduchý formát na výmenu dát, toto bude
+pravdepodobne najjednoduchšie "Learn X in Y Minutes".
+
+JSON v jeho základnej forme nemá komentáre, ale veľa parserov akceptuje
+komentáre v štýle C (`//`, `/* */`). V tomto návode však bude všetko
+100% valídny JSON.
+
+```json
+{
+  "kľúč": "hodnota",
+
+  "kľúč": "musí byť vždy uzavretý v dvojitých uvodzovkách",
+  "čísla": 0,
+  "reťazce": "Ahøj, svet. Unicode je povolený pri použití \"únikovej sekvencie (escaping)\".",
+  "boolean?": true,
+  "nič": null,
+
+  "veľké číslo": 1.2e+100,
+
+  "objekty": {
+    "komentár": "Väčšina štruktúry bude pochádzať z objektov.",
+
+    "pole": [0, 1, 2, 3, "Pole môže obsahovať čokoľvek.", 5],
+
+    "iný objekt": {
+      "komentár": "Môžu byť vhniezdené, čo môže byť užitočné."
+    }
+  },
+
+  "nezmysly": [
+    {
+      "zdroje draslíka": ["banány"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+
+  "alternatívny štýl": {
+    "komentár": "sleduj toto!"
+  , "pozícia čiarky": "nezáleží na nej - pokiaľ je pred hodnotou, všetko je ok"
+  , "iný komentár": "pekné, že?"
+  },
+
+  "to bolo rýchle": "A už sme aj na konci. Teraz ovládš všetko, čo ti JSON môže ponúknuť."
+}
+```
diff --git a/sk-sk/ruby.html.markdown b/sk-sk/ruby.html.markdown
new file mode 100644
index 00000000..799865b0
--- /dev/null
+++ b/sk-sk/ruby.html.markdown
@@ -0,0 +1,553 @@
+---
+language: ruby
+filename: learnruby-sk.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+translators:
+  - ["Juraj Kostolanský", "http://www.kostolansky.sk"]
+lang: sk-sk
+---
+
+```ruby
+# Toto je komentár
+
+=begin
+Toto je viacriadkový komentár
+Nikto ho nepoužíva
+Ani ty by si nemal
+=end
+
+# V prvom rade: Všetko je objekt.
+
+# Čísla sú objekty
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Základná aritmetika
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+
+# Aritmetika je iba syntaktickým cukrom
+# pre volanie metódy nad objektom
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Špeciálne hodnoty sú objektami
+nil # nič
+true # pravda
+false # lož
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Rovnosť
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Nerovnosť
+1 != 1 #=> false
+2 != 1 #=> true
+
+# Okrem samotného false, nil je jedinou ďalšou 'nepravdivou' hodnotou
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Ďalšie porovnania
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Logické operácie
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# Existujú aj alternatívne verzie logických operátorov s nižšou prioritou.
+# Tie sa využívajú ako konštrukcie pre riadenie toku na reťazenie výrazov
+# kým jeden z nich nevráti true alebo false.
+
+# `sprav_nieco_ine` sa vykoná ak bude `sprav_nieco` úspešné (vráti true)
+sprav_nieco() and sprav_nieco_ine()
+# `zaznamenaj_chybu` sa vykoná ak `sprav_nieco` neuspeje (vráti false)
+sprav_nieco() or zaznamenaj_chybu()
+
+
+# Reťazce sú objekty
+
+'Ja som reťazec'.class #=> String
+"Ja som tiež reťazec".class #=> String
+
+retazec = 'použiť interpoláciu reťazca'
+"Môžem #{retazec} pri použití dvojitých úvodzoviek"
+#=> "Môžem použiť interpoláciu reťazca pri použití dvojitých úvodzoviek"
+
+# Preferuj jednoduché úvodzovky pred dvojitými, ak je to možné
+# Dvojité úvodzovky totiž vyžadujú ďalšie výpočty
+
+# Kombinuj reťazce, ale nie s číslami
+'ahoj ' + 'svet'  #=> "ahoj svet"
+'ahoj ' + 3 #=> TypeError: can't convert Fixnum into String
+'ahoj ' + 3.to_s #=> "ahoj 3"
+
+# Výpis na štandardný výstup
+puts "Píšem!"
+
+
+# Premenné
+x = 25 #=> 25
+x #=> 25
+
+# Všimni si, že priradenie vracia priradenú hodnotu
+# To umožňuje viacnásobné priradenie:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Podľa konvencie sa pre mená premenných využíva snake_case
+snake_case = true
+
+# Používaj správne (opisné) mená premenných
+cesta_ku_korenovemu_adresaru = '/dobre/meno/'
+cesta = '/zle/meno/'
+
+
+# Symboly (sú objektami)
+# Symboly sú nemenné znovupoužiteľné konštanty, ktoré sú interne
+# reprezentované ako číslo. Často sa používajú namiesto reťazcov
+# pre efektívnu reprezentáciu špecifickej hodnoty.
+
+:cakajuci.class #=> Symbol
+
+status = :cakajuci
+
+status == :cakajuci #=> true
+
+status == 'cakajuci' #=> false
+
+status == :schvaleny #=> false
+
+
+# Polia
+
+# Toto je pole
+pole = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Polia môžu obsahovať rôzne typy objektov
+
+[1, 'ahoj', false] #=> [1, "ahoj", false]
+
+# Polia môžu byť indexované
+# Od začiatku
+pole[0] #=> 1
+pole[12] #=> nil
+
+# Podobne ako pri aritmetike, prístup prostredníctvom [var]
+# je iba syntaktickým cukrom pre volanie metódy [] nad objektom
+pole.[] 0 #=> 1
+pole.[] 12 #=> nil
+
+# Od konca
+pole[-1] #=> 5
+
+# Pomocou počiatočného indexu a dĺžky
+pole[2, 3] #=> [3, 4, 5]
+
+# Alebo rozsahom
+pole[1..3] #=> [2, 3, 4]
+
+# Pridanie prvku do pola
+pole << 6 #=> [1, 2, 3, 4, 5, 6]
+# Alebo takto
+pole.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Skontroluje, či už je objekt v poli
+pole.include?(1) #=> true
+
+
+# Asociatívne polia (hash) sú slovníkmi s dvojicami kľúč-hodnota.
+# Asociatívne polia sú označované kučeravými zátvorkami:
+asoc_pole = { 'farba' => 'zelena', 'cislo' => 5 }
+
+asoc_pole.keys #=> ['farba', 'cislo']
+
+# V asociatívnych poliach sa rýchlo vyhľadáva pomocou kľúča
+asoc_pole['farba'] #=> 'zelena'
+asoc_pole['cislo'] #=> 5
+
+# Asking a hash for a key that doesn't exist returns nil:
+asoc_pole['nic tu nie je'] #=> nil
+
+# Od verzie Ruby 1.9 existuje špeciálna syntax,
+# pri ktorej sa využíva symbol ako kľúč
+
+nove_asoc_pole = { defcon: 3, akcia: true }
+nove_asoc_pole.keys #=> [:defcon, :akcia]
+
+# Skontroluje existenciu kľúča a hodnoty v asociatívnom poli
+nove_asoc_pole.has_key?(:defcon) #=> true
+nove_asoc_pole.has_value?(3) #=> true
+
+# Tip: Polia aj asociatívne polia sú vypočítateľné (Enumerable)
+# Zdieľajú veľa užitočných metód ako each, map, count a ďalšie
+
+
+# Štruktúry riadenia
+
+if true
+  'if podmienka'
+elsif false
+  'else if, voliteľná vetva'
+else
+  'else, tiež voliteľná vetva'
+end
+
+for pocitadlo in 1..5
+  puts "iterácia #{pocitadlo}"
+end
+#=> iterácia 1
+#=> iterácia 2
+#=> iterácia 3
+#=> iterácia 4
+#=> iterácia 5
+
+# NIKTO však nepoužíva for cyklus
+# Aj ty by si mal preferovať metódu "each" a podať jej blok
+# Blok kus kódu, ktorý môžeš podať metódam ako "each"
+# Je podobný lambdám alebo anonymným funkciám v iných jazykoch
+#
+# Metóda "each" pre rozsah spustí blokpre každý element tohto rozsahu
+# Blok získava počítadlo ako parameter
+# Volanie metódy "each" s blokomvyzerá takto:
+
+(1..5).each do |pocitadlo|
+  puts "iterácia #{pocitadlo}"
+end
+#=> iterácia 1
+#=> iterácia 2
+#=> iterácia 3
+#=> iterácia 4
+#=> iterácia 5
+
+# Blok môže byť uzavretý aj v kučeravých záítvorkách:
+(1..5).each { |pocitadlo| puts "iterácia #{pocitadlo}" }
+
+# Obsah dátových štruktúr môže byť tiež prechádzaný pomocou metódy "each"
+pole.each do |prvok|
+  puts "#{prvok} je súčasťou pola"
+end
+asoc_pole.each do |kluc, hodnota|
+  puts "#{kluc} je #{hodnota}"
+end
+
+pocitadlo = 1
+while pocitadlo <= 5 do
+  puts "iterácia #{pocitadlo}"
+  pocitadlo += 1
+end
+#=> iterácia 1
+#=> iterácia 2
+#=> iterácia 3
+#=> iterácia 4
+#=> iterácia 5
+
+znamka = 'B'
+
+case znamka
+when 'A'
+  puts 'Len tak ďalej, chlapče'
+when 'B'
+  puts 'Viac šťastia nabudúce'
+when 'C'
+  puts 'Zvládneš to aj lepšie'
+when 'D'
+  puts 'S odratými ušami'
+when 'F'
+  puts 'Zlyhal si!'
+else
+  puts 'Iný systém známkovania, čo?'
+end
+#=> "Viac šťastia nabudúce"
+
+# prípady (cases) môžu tiež využívať rozsahy
+znamka = 82
+case znamka
+when 90..100
+  puts 'Hurá!'
+when 80...90
+  puts 'Dobrá práca'
+else
+  puts 'Zlyhal si!'
+end
+#=> "Dobrá práca"
+
+# Zaobchádzanie s výnimkami
+begin
+  # kód, ktorý môže vyhodiť výnimku
+  raise NoMemoryError, 'Došla ti pamäť.'
+rescue NoMemoryError => premenna_vynimky
+  puts 'Nastala vynimka NoMemoryError', premenna_vynimky
+rescue RuntimeError => ina_premenna_vynimky
+  puts 'Nastala vynimka RuntimeError'
+else
+  puts 'Toto sa spustí, ak nenastala žiadna výnimka'
+ensure
+  puts 'Táto časť kódu sa spustí vždy'
+end
+
+# Funkcie
+
+def zdvojnasob(x)
+  x * 2
+end
+
+# Funkcie (a bloky) implicitne vracajú hodnotu posledného výrazu
+zdvojnasob(2) #=> 4
+
+# Zátvorky sú voliteľné ak je výsledok jednoznačný
+zdvojnasob 3 #=> 6
+
+zdvojnasob zdvojnasob 3 #=> 12
+
+def suma(x, y)
+  x + y
+end
+
+# Argumenty metódy sa oddeľujú čiarkami
+suma 3, 4 #=> 7
+
+suma suma(3, 4), 5 #=> 12
+
+# yield
+# Všetky metódy majú implicitný, voliteľný parameter bloku
+# môže byť zavolaný ako kľúčové slovo 'yield'
+
+def obal
+  puts '{'
+  yield
+  puts '}'
+end
+
+obal { puts 'ahoj svet' }
+
+# {
+# ahoj svet
+# }
+
+
+# Funkcii môžeš odovzdať blok
+# "&" označuje referenciu na tento blok
+def hostia(&blok)
+  blok.call 'nejake argumenty'
+end
+
+# Tiež môžeš odovzdať zoznam argumentov, ktoré sa prevedú na pole
+# Na to sa využíva operátor "*"
+def hostia(*pole)
+  pole.each { |host| puts host }
+end
+
+
+# Trieda sa definuje kľúčovým slovom class
+class Clovek
+
+  # Premenná triedy. Je zdieľaná všetkými inštanciami tejto triedy.
+  @@druh = 'H. sapiens'
+
+  # Jednoduchý inicializátor
+  def initialize(meno, vek = 0)
+    # Priradí argument k premennej inštancie "meno"
+    @meno = meno
+    # Ak nie je uvedený vek, použije sa špecifikovaná predvolená hodnota
+    @vek = vek
+  end
+
+  # Jednoduchá metóda pre nastavenie hodnoty premennej
+  def meno=(meno)
+    @meno = meno
+  end
+
+  # Jednoduchá metóda pre získanie hodnoty premennej
+  def meno
+    @meno
+  end
+
+  # Vyššie uvedená funkcionalita môže byť zapúzdrená použitím
+  # metódy attr_accessor
+  attr_accessor :meno
+
+  # Metódy pre nastavenie a získanie hodnoty premennej môžu byť vytvorené
+  # aj individuálne
+  attr_reader :meno
+  attr_writer :meno
+
+  # Metóda triedy používa kľúčové slovo self pre odlíšenie
+  # od metód inštancií. Môže byť volaná iba nad triedou, nie inštanciou.
+  def self.povedz(sprava)
+    puts sprava
+  end
+
+  def druh
+    @@druh
+  end
+end
+
+
+# Vytvorenie inštancie triedy
+jim = Clovek.new('Jim Halpert')
+
+dwight = Clovek.new('Dwight K. Schrute')
+
+# Skúsme zavolať zopár metód
+jim.druh #=> "H. sapiens"
+jim.meno #=> "Jim Halpert"
+jim.meno = "Jim Halpert II" #=> "Jim Halpert II"
+jim.meno #=> "Jim Halpert II"
+dwight.druh #=> "H. sapiens"
+dwight.meno #=> "Dwight K. Schrute"
+
+# Volanie metódy triedy
+Clovek.povedz('Ahoj') #=> "Ahoj"
+
+# Rozsah platnosti premennej je definovaná spôsobom, akým ju nazveme.
+# Premenné začínajúce znakom $ majú globálnu platnosť.
+$premenna = "Ja som globálna premenná"
+defined? $premenna #=> "global-variable"
+
+# Premenné začínajúce znakom @ majú platnosť v rámci inštancie
+@premenna = "Ja som premenná inštancie"
+defined? @premenna #=> "instance-variable"
+
+# Premenné začínajúce znakmi @@ majú platnosť v rámci triedy
+@@premenna= "Ja som premenná triedy"
+defined? @@premenna #=> "class variable"
+
+# Premenné začínajúce veľkým písmenom sú konštanty
+Premenna = "Ja som konštanta"
+defined? Premenna #=> "constant"
+
+# Trieda je tiež objektom v ruby, takže aj ona môže mať premenné inštancie.
+# Premenná triedy je zdieľaná triedou a jej nasledovníkmi.
+
+# Základná trieda
+class Clovek
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(hodnota)
+    @@foo = hodnota
+  end
+end
+
+# Odvodená trieda
+class Pracovnik < Clovek
+end
+
+Clovek.foo # 0
+Pracovnik.foo # 0
+
+Clovek.foo = 2 # 2
+Pracovnik.foo # 2
+
+# Premenné inštancie triedy nie sú zdieľané jej nasledovníkmi.
+
+class Clovek
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(hodnota)
+    @bar = hodnota
+  end
+end
+
+class Doktor < Clovek
+end
+
+Clovek.bar # 0
+Doktor.bar # nil
+
+module PrikladModulu
+  def foo
+    'foo'
+  end
+end
+
+# Vloženie modulu (include) previaže jeho metódy s inštanciou triedy.
+# Rozšírenie modulu (extend) previaže jeho metódy so samotnou triedou.
+
+class Osoba
+  include PrikladModulu
+end
+
+class Kniha
+  extend PrikladModulu
+end
+
+Osoba.foo     # => NoMethodError: undefined method `foo' for Osoba:Class
+Osoba.new.foo # => 'foo'
+Kniha.foo       # => 'foo'
+Kniha.new.foo   # => NoMethodError: undefined method `foo'
+
+# Spätné volania sú vykonané pri vložení alebo rozšírení modulu
+
+module PrikladKoncernu
+  def self.included(zaklad)
+    zaklad.extend(MetodyTriedy)
+    zaklad.send(:include, MetodyInstancie)
+  end
+
+  module MetodyTriedy
+    def bar
+      'bar'
+    end
+  end
+
+  module MetodyInstancie
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Nieco
+  include PrikladKoncernu
+end
+
+Nieco.bar     # => 'bar'
+Nieco.qux     # => NoMethodError: undefined method `qux'
+Nieco.new.bar # => NoMethodError: undefined method `bar'
+Nieco.new.qux # => 'qux'
+```
+
+## Ďalšie zdroje
+
+- [Nauč sa ruby v príkladoch s úlohami](http://www.learneroo.com/modules/61/nodes/338) - Variácia tejto referencie s úlohami v prehliadači.
+- [Oficiálna dokumentácia](http://www.ruby-doc.org/core-2.1.1/)
+- [Ruby z iných jazykov](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Staršia [bezplatná edícia](http://ruby-doc.com/docs/ProgrammingRuby/) je dostupná online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Komunitná príručka odporúčaných štýlov programovania v Ruby.