Merge pull request #1 from adambard/master

update

10 files changed, 3424 insertions, 0 deletions

diff --git a/cs-cz/brainfuck.html.markdown b/cs-cz/brainfuck.html.markdown
new file mode 100644
index 00000000..29abc21f
--- /dev/null
+++ b/cs-cz/brainfuck.html.markdown
@@ -0,0 +1,87 @@
+---
+language: brainfuck
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
+filename: learnbrainfuck-cz.bf
+lang: cs-cz
+---
+
+Brainfuck (psaný bez kapitálek s vyjímkou začátku věty) je extrémně minimální 
+Turingovsky kompletní (ekvivalentní) programovací jazyk a má pouze 8 příkazů.
+
+Můžete si ho vyzkoušet přímo v prohlížeči s [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Jakýkoliv znak mimo "><+-.,[]" (bez uvozovek) je ignorován.
+
+Brainfuck je reprezentován jako pole, které má 30.000 buněk s počátkem v nule 
+a datovým ukazatelem na aktuální buňce.
+
+Můžeme využít těchto osm příkazů:
++ : Přičte k aktuální buňce jedničku.
+- : Odečte od aktuální buňky jedničku.
+> : Posune datový ukazatel na další buňku, která je napravo.
+< : Posune datový ukazatel na předchozí buňku, která je nalevo.
+. : Vytiskne ASCII hodnotu aktuální buňky (například 65 = 'A').
+, : Načte jeden znak do aktuální buňky.
+[ : Pokud je hodnota aktuální buňky nulová, přeskočí na buňku odpovídající ] .
+    Jinak skočí na další instrukci.
+] : Pokud je hodnota aktuální buňky nulova, přeskočí na další instrukci.
+    Jinak skočí zpět na instrukci odpovídající [ .
+
+[ a ] tak tvoří 'while' smyčku a tyto symboly musí tak být v páru.
+
+Pojďme se mrknout na některé brainfuck programy.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Tento program vypíše písmeno 'A' (v ASCII je to číslo 65). Nejdříve navýší 
+buňku #1 na hodnotu 6. Buňka #1 bude použita pro smyčku. Potom program vstoupí 
+do smyčky ([) a sníží hodnotu buňky #1 o jedničku. Ve smyčce zvýší hodnotu 
+buňky #2 desetkrát, vrátí ze zpět na buňku #1 a sníží její hodnotu o jedničku.
+Toto se stane šestkrát (je potřeba šestkrát snížit hodnotu buňky #1, aby byla 
+nulová a program přeskočil na konec cyklu označený znakem ].
+
+Na konci smyčky, kdy jsme na buňce #1 (která má hodnotu 0), tak má buňka #2 
+hodnotu 60. Přesuneme se na buňku #2 a pětkrát zvýšíme její hodnotu o jedničku 
+na hodnotu 65. Na konci vypíšeme hodnotu buňky #2 - 65, což je v ASCII znak 'A' 
+na terminálu.
+
+
+, [ > + < - ] > .
+
+Tento program přečte znak z uživatelského vstupu a zkopíruje ho do buňky #1.
+Poté začne smyčka - přesun na buňku #2, zvýšení hodnoty buňky #2 o jedničku,
+přesun zpět na buňku #1 a snížení její hodnoty o jedničku. Takto smyčka pokračuje
+do té doby, než je buňka #1 nulová a buňka #2 nabyde původní hodnotu buňky #1. 
+Protože jsme na buňce #1, přesuneme se na buňku #2 a vytiskneme její hodnotu 
+v ASCII.
+
+Je dobré vědět, že mezery jsou v programu uvedené pouze z důvodu čitelnosti. 
+Program je možné klidně zapsat i takto:
+
+,[>+<-]>.
+
+
+Nyní se podívejte na tento program a zkuste zjistit co dělá: 
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Tento program vezme dvě čísla ze vstupu a vynásobí je.
+
+Program nejdříve načte dvě vstupní hodnoty. Poté začíná smyčka řízená hodnotou
+v buňce #1 - přesun na buňku #2 a start druhé vnořené smyčky, která je řízená 
+hodnotou v buňce #2 a zvyšuje hodnotu v buňce #3. Nicméně je zde problém 
+kdy na konci vnitřní smyčky je v buňce #2 nula a smyčka by tak znovu 
+napokračovala. Vyřešíme to tak, že zvyšujeme o jedničku i buňku #4 a její 
+hodnotu poté překopírujeme do buňky #2. Na konci programu je v buňce #3 
+výsledek.
+```
+
+A to je brainbuck. Zase tak složitý není, co? Zkuste si nyní napsat nějaký
+vlastní brainfuck program a nebo interpretr v jiném jazyce, což není zase
+tak složité, ale pokud jste opravdový masochista, zkuste si naprogramovat
+interpretr jazyka brainfuck v jazyce... brainfuck :)
diff --git a/cs-cz/css.html.markdown b/cs-cz/css.html.markdown
new file mode 100644
index 00000000..54a0a08e
--- /dev/null
+++ b/cs-cz/css.html.markdown
@@ -0,0 +1,253 @@
+---
+language: css
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+    - ["Connor Shea", "https://github.com/connorshea"]
+    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+translators:
+    - ["Michal Martinek", "https://github.com/MichalMartinek"]
+lang: cs-cz
+filename: learncss-cz.css
+---
+
+V ranných dobách webu se nevyskytovaly žádné vizuální elementy, pouze čistý text, ale s vývojem webových browserů se staly stránky plné grafických prvků běžné.
+
+A právě proto vzniklo CSS, aby oddělilo obsah (HTML) od vzhledu webové stránky.
+
+Pomocí CSS můžete označit různé elementy na HTML stránce a přiřadit jim různé vzhledové vlastnosti.
+
+Tento návod byl napsán pro CSS 2, avšak CSS 3 se stalo velmi oblíbené a v dnešní době už běžné.
+
+**POZNÁMKA** Protože CSS produkuje vizuální výsledky, je nutné k jeho naučení všechno zkoušet třeba na [dabbletu](http://dabblet.com/).
+Tento článek se zaměřuje hlavně na syntaxi a poskytue také pár obecných tipů.
+
+```css
+/* komentáře jsou ohraničeny lomítkem s hvězdičkou, přesně jako tyto dva
+   řádky, v CSS není nic jako jednořádkový komentář, pouze tenhle zápis   */
+
+/* ################
+   ## SELEKTORY
+   ################ */
+
+/* Selektor se používá pro vybrání elementu na stránce:
+selektor { vlastnost: hodnota; /* více vlastností...  }*/
+
+/*
+Toto je náš element:
+<div trida='trida1 trida2' id='nejakeID' attr='hodnota' otherAttr='cs-cz co neco' />
+*/
+
+/* Můžeme vybrat tento element třeba podle jeho třídy */
+.trida1 { }
+
+/* nebo obou tříd! */
+.trida1.trida2 { }
+
+/* nebo jeho jména */
+div { }
+
+/* nebo jeho id */
+#nejakeID { }
+
+/* nebo podle toho, že má atribut! */
+[attr] { font-size:smaller; }
+
+/* nebo že argument nabývá specifické hodnoty*/
+[attr='hodnota'] { font-size:smaller; }
+
+/* začíná nějakou hodnotou (CSS 3) */
+[attr^='ho'] { font-size:smaller; }
+
+/* nebo končí něčím (CSS 3) */
+[attr$='ta'] { font-size:smaller; }
+
+/* nebo obsahuje nějakou hodnotu, která je v atributu oddělená mezerami */
+[otherAttr~='co'] { }
+[otherAttr~='neco'] { }
+
+/* nebo obsahuje hodnotu oddělenou pomlčkou - "-" (U+002D) */
+[otherAttr|='cs'] { font-size:smaller; }
+
+
+/* Můžeme spojit různé selektory, abychom získali specifičtější selektor.
+   Pozor, nedávejte mezi ně mezery! */
+div.nejaka-trida[attr$='ta'] { }
+
+/* Můžeme vybrat element, který je potomek jineho */
+div.vnejsi-element > .jmeno-tridy { }
+
+/* nebo zanořen ještě hlouběji. Potomci jsou přímo pod vnější třídou, pouze 1
+   úroveň pod rodičem. Tento selektor bude fungovat na jakékoliv úrovni pod
+   rodičem */
+div.rodic .jmeno-tridy { }
+
+/* Varování: stejný selektor bez mezery má úplně jiný význam
+   Vzpomínáte si jaký? */
+div.rodic.jmeno-tridy { }
+
+/* Možná budete chtít vybrat element, který leží přímo vedle */
+.jsem-primo-pred + .timto-elementem { }
+
+/* nebo kdekoliv na stejné úrovni stromu */
+.jsem-kdekoliv-pred ~ .timto-elementem { }
+
+/* Existují selektory nazvané pseudo třídy, kterými můžeme vybrat elementy,
+   když jsou v určitém stavu */
+
+/* na příklad, když kurzor najede na element */
+selektor:hover { }
+
+/* nebo již navštívený odkaz */
+selektor:visited { }
+
+/* nebo nebyl navštíven */
+selektor:link { }
+
+/* nebo když je vybrán, např kliknutím do inputu*/
+selektor:focus { }
+
+/* element, ktery je prvni potomek rodiče */
+selektor:first-child {}
+
+/* element, který je poslední potomek rodiče */
+selektor:last-child {}
+
+/* Stejně jako pseudo třídy, umožňují pseudo elementy stylizovat určité
+   části dokumentu */
+
+/* odpovídá virtuálnímu prvnímu potomku */
+selektor::before {}
+
+/* odpovídá virtuálnímu poslednímu potomku */
+selektor::after {}
+
+/* Na vhodném místě, může být použitá hvězdička jako žolík, který vybere každý element */
+* { } /* všechny elementy */
+.rodic * { } /* všechny vnořené elementy */
+.rodic > * { } /* všichni potomci */
+
+/* ####################
+   ## VLASTNOSTI
+   #################### */
+
+selektor {
+
+    /* Jednotky délky můžou být relativní nebo absolutní */
+
+    /* Relativní jednotky */
+    width: 50%;       /* počet procent šířky rodičovského elementu */
+    font-size: 2em;   /* násobek puvodní velikosti fontu elementu */
+    font-size: 2rem;  /* nebo kořenového elementu */
+    font-size: 2vw;   /* násobek 1% šířky zařízení (viewport) (CSS 3) */
+    font-size: 2vh;   /* nebo jeho výšky */
+    font-size: 2vmin; /* násobek 1% výšky nebo šířky, dle toho, co je menší */
+    font-size: 2vmax; /* nebo větší */
+
+    /* Absolutní jednotky */
+    width: 200px;     /* pixely */
+    font-size: 20pt;  /* body */
+    width: 5cm;       /* centimetry */
+    min-width: 50mm;  /* milimetry */
+    max-width: 5in;   /* palce */
+
+    /* Barvy */
+    color: #F6E;                 /* krátký hexadecimální formát */
+    color: #FF66EE;              /* dlouhý hexadecimální formát */
+    color: tomato;               /* pojmenovaná barva */
+    color: rgb(255, 255, 255);   /* hodnoty rgb */
+    color: rgb(10%, 20%, 50%);   /* procenta rgb */
+    color: rgba(255, 0, 0, 0.3); /* hodnoty rgba (CSS 3) Poznámka: 0 < a < 1 */
+    color: transparent;          /* ekvivalentní jako nastavení alfy 0 */
+    color: hsl(0, 100%, 50%);    /* procenta hsl (CSS 3) */
+    color: hsla(0, 100%, 50%, 0.3); /* procenta hsl s alfou */
+
+    /* Obrázky jako pozadí elementu */
+    background-image: url(/cesta/k/obrazku.jpg); /* uvozovky jsou dobrovolné */
+
+    /* Fonty */
+    font-family: Arial;
+    /* když název fontu obsahuje mezeru, tak musí být v uvozovkách */
+    font-family: "Courier New";
+    /* když se první nenaleze, použije se další atd. */
+    font-family: "Courier New", Trebuchet, Arial, sans-serif;
+}
+```
+
+## Použití
+
+Uložte CSS soubor s příponou `.css`.
+
+```xml
+<!-- Musíte vložit css soubor do hlavičky vaší stránky. Toto je
+     doporučená metoda. Viz http://stackoverflow.com/questions/8284365 -->
+<link rel='stylesheet' type='text/css' href='cesta/k/stylu.css' />
+
+<!-- Také lze vložit CSS přímo do HTML. -->
+<style>
+   a { color: purple; }
+</style>
+
+<!-- Nebo přímo nastavit vlasnost elementu -->
+<div style="border: 1px solid red;">
+</div>
+```
+
+## Priorita nebo kaskáda
+
+Element může být vybrán více selektory a jeho vlastnosti můžou být nastaveny více než jednou. V těchto případech, má jedno zadání vlastnosti prioritu před druhým. Obecně platí, že více specifické selektory mají přednost před těmi méně specifickými.
+
+Tento proces se nazývá kaskáda, proto i název kaskádové styly(Cascading Style Sheets).
+
+Máme následující CSS
+
+```css
+/* A */
+p.trida1[attr='hodnota']
+
+/* B */
+p.trida1 { }
+
+/* C */
+p.trida2 { }
+
+/* D */
+p { }
+
+/* E */
+p { vlastnost: hodnota !important; }
+```
+
+a tento element
+```xml
+<p style='/*F*/ vlastnost:hodnota;' trida='trida1 trida2' attr='hodnota' />
+```
+Priorita stylu je následující. Pamatujte, priorita pro každou **vlastnost**, ne pro celý blok.
+
+* `E` má nejvyšší prioritu kvůli slůvku `!important`. Je doporučováno se úplně vyhnout jeho použití.
+* `F` je další, kvůli stylu zadanému přimo do elementu
+* `A` je další, protože je více specifické, než cokoliv dalšího. Má 3 selektory: jméno elementu `p`, jeho třídu `trida1`, atribut `attr='hodnota'`.
+* `C` je další, i když je stejně specifický jako `B`, protože je uveden až po něm.
+* `B` je další
+* `D` je poslední
+
+## Kompatibilita
+
+Většina z možností v CSS 2 (a spousta v CSS 3) je dostupná napříč všemi browsery a zařízeními. Ale pořád je dobrá praxe, zkontrolovat dostupnost, před užitím nové vlastnosti/fičury.
+
+## Zdroje
+
+* Přehled dostupnosti [CanIUse](http://caniuse.com).
+* CSS hřiště [Dabblet](http://dabblet.com/).
+* [Mozilla Developer Network - CSS dokumentace](https://developer.mozilla.org/en-US/docs/Web/CSS)
+* [Codrops](http://tympanus.net/codrops/css_reference/)
+
+## Další čtení
+
+* [Pochopení priority v CSS: specifičnost, děditelnost a kaskáda](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+* [Vybírání elementů pomocí atributů](https://css-tricks.com/almanac/selectors/a/attribute/)
+* [QuirksMode CSS](http://www.quirksmode.org/css/)
+* [Z-Index - překrývání obsahu](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
+* [SASS](http://sass-lang.com/) a [LESS](http://lesscss.org/) pro CSS pre-processing
+* [CSS-Triky](https://css-tricks.com)
diff --git a/cs-cz/elm.html.markdown b/cs-cz/elm.html.markdown
new file mode 100644
index 00000000..f19f9e8b
--- /dev/null
+++ b/cs-cz/elm.html.markdown
@@ -0,0 +1,373 @@
+---
+language: Elm
+contributors:
+    - ["Max Goldstein", "http://maxgoldste.in/"]
+translators:
+    - ["Robin Pokorný", "http://robinpokorny.com/"]
+filename: learnelm-cz.elm
+lang: cs-cz
+---
+
+Elm je funkcionální reaktivní jazyk, který se kompiluje do (klientského) JavaScriptu.
+Elm je silně typovaný, díky tomu je překladač schopen zachytit většinu chyb okamžitě a
+vypsat snadno srozumitelná chybová hlášení.
+Elm se hodí k tvorbě webových uživatelských rozhraní a her.
+
+
+```haskell
+-- Jednořádkové komentáře začínají dvěma pomlčkami.
+{- Víceřádkové komentáře mohou být takto uzavřeny do bloku.
+{- Mohou být i zanořeny. -}
+-}
+
+{-- Základy --}
+
+-- Aritmetika
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+
+-- Každé číslo bez desetinné tečky je typu Int nebo Float.
+33 / 2 -- 16.5 s reálným dělením
+33 // 2 -- 16 s celočíselným dělením
+
+-- Umocňování
+5 ^ 2 -- 25
+
+-- Pravdivostní proměnné
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- Řetězce a znaky
+"Toto je textový řetězec, protože používá dvojité uvozovky."
+'a' -- znak v jednoduchých uvozovkách
+
+-- Řetězce lze spojovat.
+"Ahoj " ++ "světe!" -- "Ahoj světe!"
+
+{-- Seznamy (List), n-tice (Tuple) a Záznamy (Record) --}
+
+-- Každá položka seznamu musí být stejného typu.
+["příliš", "žluťoučký", "kůň", "úpěl"]
+[1, 2, 3, 4, 5]
+-- Druhý příklad lze zapsat také pomocí dvou teček.
+List.range 1 5
+
+-- Spojovat seznamy lze stejně jako řetězce.
+List.range 1 5 ++ List.range 6 10 == List.range 1 10 -- True
+
+-- K přidání položky do seznamu použijte funkci "cons".
+0 :: List.range 1 5 -- [0, 1, 2, 3, 4, 5]
+
+-- Funkce "head" pro získání první položky seznamu i funkce "tail" pro získání následujích položek
+-- vrací typ Maybe. Místo zjišťování, jestli nějaká položka není null,
+-- se s chybějcími hodnotami vypořádáme explicitně.
+List.head (List.range 1 5) -- Just 1
+List.tail (List.range 1 5) -- Just [2, 3, 4, 5]
+List.head [] -- Nothing
+-- List.nazevFunkce odkazuje na funkci, která žije v modulu List.
+
+-- Každý prvek v n-tici může být jiného typu, ale n-tice má pevný počet prvků.
+("elm", 42)
+
+-- K získání hodnot z dvojice použijte funkce first a second.
+-- (Toto je pouze zkratka. Brzy si ukážeme, jak na to "správně".)
+fst ("elm", 42) -- "elm"
+snd ("elm", 42) -- 42
+
+-- Prázná n-tice, neboli "unit", se občas používá jako zástupný symbol.
+-- Je to jediná hodnota svého typu, který se také nazývá "Unit".
+()
+
+-- Záznamy jsou podobné n-ticím, ale prvky jsou pojmenovány. Na pořadí nezáleží.
+-- Povšimněte si, že hodnoty vlastností se přiřazují rovnítky, ne dvojtečkami.
+{ x = 3, y = 7 }
+
+-- K hodnotám se přistupuje pomocí tečky a názvu vlastnosti.
+{ x = 3, y = 7 }.x -- 3
+
+-- Nebo využitím přístupové funkce, což je jen tečka a název vlastnosti.
+.y { x = 3, y = 7 } -- 7
+
+-- Změna hodnoty vlastnosti v záznamu. (Záznam tuto vlastnost už musí mít.)
+{ osoba |
+  jmeno = "Jiří" }
+
+-- Změna více vlastností s využitím aktuálních hodnot.
+{ hmotnyBod |
+  poloha = hmotnyBod.poloha + hmotnyBod.rychlost,
+  rychlost = hmotnyBod.rychlost + hmotnyBod.zrychleni }
+
+{-- Řídicí struktury --}
+
+-- Podmínky vždy musí mít větev "else" a obě větve musí být stejného typu.
+if powerLevel > 9000 then
+  "PÁNI!"
+else
+  "hmm"
+
+-- Podmínky lze skládat za sebe.
+if n < 0 then
+  "n je záporné"
+else if n > 0 then
+  "n je kladné"
+else
+  "n je nula"
+
+-- Použíjte příkaz "case" k nalezení shody vzoru a různých možností.
+case seznam of
+  [] -> "odpovídá práznému seznamu"
+  [x]-> "odpovídá seznamu o právě jedné položce, " ++ toString x
+  x::xs -> "odpovídá seznamu o alespoň jedné položce, jehož prvním prvkem je " ++ toString x
+-- Shody se vyhodnocují v zapsaném pořadí. Kdybychom umístili [x] poslední, nikdy by nenastala shoda,
+-- protože x::xs také odpovídá  (xs by byl prázdný seznam). Shody "nepropadají".
+-- Překladač vždy upozorní na chybějící nebo přebývající větve.
+
+-- Větvení typu Maybe.
+case List.head seznam of
+  Just x -> "První položka je " ++ toString x
+  Nothing -> "Seznam byl prázdný."
+
+{-- Funkce --}
+
+-- Syntaxe funkcí je v Elmu velmi úsporná, založená spíše na mezerách
+-- než na závorkách. Neexistuje tu klíčové slovo "return".
+
+-- Funkci definujeme jejím jménem, parametry, rovnítkem a tělem.
+vynasob a b =
+  a * b
+
+-- Funkci voláme předáním parametrů (bez oddělujících čárek).
+vynasob 7 6 -- 42
+
+-- Částečně aplikované funkci předáme pouze některé parametry.
+-- Poté zvolíme nové jméno.
+zdvoj =
+  vynasob 2
+
+-- Konstanty jsou podobné, ale nepřijímají žádné parametry.
+odpoved =
+  42
+
+-- Předejte funkci jako parametr jiným funkcím.
+List.map zdvoj (List.range 1 4) -- [2, 4, 6, 8]
+
+-- Nebo použijte anonymní funkci.
+List.map (\a -> a * 2) (List.range 1 4) -- [2, 4, 6, 8]
+
+-- V definici funkce lze zapsat vzor, může-li nastat pouze jeden případ.
+-- Tato funkce přijímá jednu dvojici místo dvou parametrů.
+obsah (sirka, delka) =
+  sirka * delka
+
+obsah (6, 7) -- 42
+
+-- Složenými závorkami vytvořte vzor pro názvy vlastností v záznamu.
+-- Použijte "let" k definici lokálních proměnných.
+objem {sirka, delka, hloubka} =
+  let
+    obsah = sirka * delka
+  in
+    obsah * hloubka
+
+objem { sirka = 3, delka = 2, hloubka = 7 } -- 42
+
+-- Funkce mohou být rekurzivní.
+fib n =
+  if n < 2 then
+    1
+  else
+    fib (n - 1) + fib (n - 2)
+
+List.map fib (List.range 0 8) -- [1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+-- Jiná rekurzivní funkce (v praxi použijte List.length).
+delkaSeznamu seznam =
+  case seznam of
+    [] -> 0
+    x::xs -> 1 + delkaSeznamu xs
+
+-- Funkce se volají před jakýmkoli infixovým operátorem. Závorky určují prioritu.
+cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1
+-- Nejprve se aplikuje "degrees" na číslo 30, výsledek je pak předán trigonometrickým
+-- funkcím, které jsou následně umocněny na druhou, na závěr proběhne sčítání.
+
+{-- Typy a typové anotace --}
+
+-- Překladač odvodí typ každé hodnoty ve vašem programu.
+-- Typy vždy začínají velkým písmenem. Čtete x : T jako "x je typu T".
+-- Některé běžné typy, které můžete videt v Elmovém REPLu.
+5 : Int
+6.7 : Float
+"ahoj" : String
+True : Bool
+
+-- Funkce mají také typy. Čtěte "->" jako "vrací".
+-- O typu na konci uvažujte jako návratovém typu, o ostatních jako typech argumentů.
+not : Bool -> Bool
+round : Float -> Int
+
+-- Když definujete hodnotu, je dobrým zvykem zapsat nad ni její typ.
+-- Anotace je formou dokumentace, která je ověřována překladačem.
+zdvoj : Int -> Int
+zdvoj x = x * 2
+
+-- Funkce jako parametr je uzavřena v závorkách.
+-- Typy s malým počátečním písmenem jsou typové proměnné:
+-- mohou být libovolného typu, ale v každém volání musí být stejné.
+List.map : (a -> b) -> List a -> List b
+-- "List tečka map je typu a-vrací-b, vrací seznam-položek-typu-a, vrací seznam-položek-typu-b."
+
+-- Existují tři speciální typové proměnné:
+-- číslo (number), porovnatelné (comparable), and spojitelné (appendable).
+-- Čísla dovolují použít aritmetiku na Int a Float.
+-- Porovnatelné dovolují uspořádat čísla a řetězce, např. a < b.
+-- Spojitelné lze zřetězit pomocí a ++ b.
+
+{-- Typové aliasy a výčtové typy --}
+
+-- Pro záznamy a n-tice již typy automaticky existují.
+-- (Povšimněte si, že typ vlatnosti záznamu přiřazujeme dvojtečkou a hodnotu rovnítkem.)
+pocatek : { x : Float, y : Float, z : Float }
+pocatek =
+  { x = 0, y = 0, z = 0 }
+
+-- Stávajícím typům lze dávat jména využitím aliasů.
+type alias Bod3D =
+  { x : Float, y : Float, z : Float }
+
+-- Alias pro záznam funguje také jako jeho konstruktor.
+jinyPocatek : Bod3D
+jinyPocatek =
+  Bod3D 0 0 0
+
+-- Jedná se stále o stejný typ, lze je tedy porovnat.
+pocatek == jinyPocatek -- True
+
+-- Oproti tomu výčtový (union) typ definuje zcela nový typ.
+-- Výčtový typ se takto jmenuje, protože může být jedním z několika vybraných možností.
+-- Každá možnost je reprezentována jako "tag".
+type Smer =
+  Sever | Jih | Vychod | Zapad
+
+-- Tagy mohou obsahovat další hodnoty známých typů. Lze využít i rekurze.
+type IntStrom =
+  Vrchol | Uzel Int IntStrom IntStrom
+-- "Vrchol" i "Uzel" jsou tagy. Vše, co následuje za tagem, je typ.
+
+-- Tagy lze použít jako hodnoty funkcí.
+koren : IntStrom
+koren =
+  Vrchol 7 List List
+
+-- Výčtové typy (a typové aliasy) mohou obsahovat typové proměnné.
+type Strom a =
+  Vrchol | Uzel a (Strom a) (Strom a)
+-- "Typ strom-prvků-a je vrchol, nebo uzel obsahující a, strom-prvků-a a strom-prvků-a."
+
+-- Vzory se shodují s tagy. Tagy s velkým počátečním písmenem odpovídají přesně.
+-- Proměnné malým písmem odpovídají čemukoli. Podtržítko také odpovídá čemukoli,
+-- ale určuje, že tuto hodnotu dále nechceme používat.
+nejviceVlevo : Strom a -> Maybe a
+nejviceVlevo strom =
+  case strom of
+    Vrchol -> Nothing
+    Uzel x Vrchol _ -> Just x
+    Uzel _ podstrom _ -> nejviceVlevo podstrom
+
+-- To je víceméně vše o jazyku samotném.
+-- Podívejme se nyní, jak organizovat a spouštět náš kód.
+
+{-- Moduly a importování --}
+
+-- Standardní knihovny jsou organizovány do modulů, stejně jako knihovny třetích stran,
+-- které můžete využívat. Ve větších projektech můžete definovat vlastní moduly.
+
+-- Vložte toto na začátek souboru. Pokud nic neuvedete, předpokládá se "Main".
+module Jmeno where
+
+-- Výchozím chováním je, že se exportuje vše.
+-- Případně můžete definovat exportované vlastnosti explicitně.
+module Jmeno (MujTyp, mojeHodnota) where
+
+-- Běžný návrhový vzor je expotovat pouze výčtový typ bez jeho tagů.
+-- Tento vzor je znám jako krycí typ a často se využívá v knihovnách.
+
+-- Z jiných modulů lze importovat kód a použít jej v aktuálním modulu.
+-- Nasledující umístí Dict do aktuálního scope, takže lze volat Dict.insert.
+import Dict
+
+-- Importuje modul Dict a typ Dict, takže v anotacích není nutné psát Dict.Dict.
+-- Stále lze volat Dict.insert.
+import Dict exposing (Dict)
+
+-- Přejmenování importu.
+import Graphics.Collage as C
+
+{-- Porty --}
+
+-- Port oznamuje, že budete komunikovat s vnějším světem.
+-- Porty jsou dovoleny pouze v modulu Main.
+
+-- Příchozí port je jen typová anotace.
+port idKlienta : Int
+
+-- Odchozí port má definici.
+port objednavkaKlienta : List String
+port objednavkaKlienta = ["Knihy", "Potraviny", "Nábytek"]
+
+-- Nebudeme zacházet do detailů, ale v JavaScriptu se dají nastavit
+-- callbacky pro zasílání na příchozí porty a čtení z odchozích portů.
+
+{-- Nástroje pro příkazovou řádku --}
+
+-- Kompilace souboru.
+$ elm make MujSoubor.elm
+
+-- Při prvním spuštění nainstaluje Elm standardní knihovny a vytvoří soubor
+-- elm-package.json, kde jsou uloženy informace o vašem projektu.
+
+-- Elm reactor je server, který překládá a spouští vaše soubory.
+-- Kliknutím na klíč vedle názvu souboru spustíte debugger s cestovám v čase!
+$ elm reactor
+
+-- Zkoušejte si jednoduché příkazy v Read-Eval-Print Loop.
+$ elm repl
+
+-- Balíčky jsou určeny uživatelským jménem na GitHubu a názvem repozitáře.
+-- Nainstalujte nový balíček a uložte jej v souboru elm-package.json.
+$ elm package install evancz/elm-lang/html
+
+-- Porovnejte změny mezi verzemi jednoho balíčku.
+$ elm package diff elm-lang/html 1.1.0 2.0.0
+-- Správce balíčků v Elmu vyžaduje sémantické verzování,
+-- takže minor verze nikdy nerozbije váš build.
+```
+
+Jazyk Elm je překvapivě malý. Nyní se můžete podívat do skoro jakéhokoli zdrojového kódu
+v Elmu a budete mít zběžnou představu o jeho fungování.
+Ovšem možnosti, jak psát kód, který je odolný vůči chybám a snadno se refaktoruje, jsou neomezené!
+
+Zde jsou některé užitečné zdroje (v angličtině).
+
+* [Hlavní stránka Elmu](http://elm-lang.org/). Obsahuje:
+  * Odkazy na [instalátory](http://elm-lang.org/install)
+  * [Documentaci](http://elm-lang.org/docs), včetně [popisu syntaxe](http://elm-lang.org/docs/syntax)
+  * Spoustu nápomocných [příkladů](http://elm-lang.org/examples)
+
+* Documentace pro [standardní knihovny Elmu](http://package.elm-lang.org/packages/elm-lang/core/latest/). Povšimněte si:
+  * [Základy](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics), které jsou automaticky importovány
+  * Typ [Maybe](http://package.elm-lang.org/packages/elm-lang/core/latest/Maybe) a jeho bratranec typ [Result](http://package.elm-lang.org/packages/elm-lang/core/latest/Result), které se běžně používají pro chybějící hodnoty a ošetření chyb.
+  * Datové struktury jako [List](http://package.elm-lang.org/packages/elm-lang/core/latest/List), [Array](http://package.elm-lang.org/packages/elm-lang/core/latest/Array), [Dict](http://package.elm-lang.org/packages/elm-lang/core/latest/Dict) a [Set](http://package.elm-lang.org/packages/elm-lang/core/latest/Set)
+  * JSON [enkódování](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Encode) a [dekódování](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Decode)
+
+* [Architektura Elmu](https://github.com/evancz/elm-architecture-tutorial#the-elm-architecture). Esej od tvůrce Elmu s příklady, jak organizovat kód do komponent.
+
+* [Elm mailing list](https://groups.google.com/forum/#!forum/elm-discuss). Všichni jsou přátelští a nápomocní.
+
+* [Scope v Elmu](https://github.com/elm-guides/elm-for-js/blob/master/Scope.md#scope-in-elm) a [Jak číst typové anotace](https://github.com/elm-guides/elm-for-js/blob/master/How%20to%20Read%20a%20Type%20Annotation.md#how-to-read-a-type-annotation). Další komunitní návody o základech Elmu, psáno pro JavaScriptové vývojáře.
+
+Běžte si zkusit něco napsat v Elmu!
diff --git a/cs-cz/go.html.markdown b/cs-cz/go.html.markdown
new file mode 100644
index 00000000..36217414
--- /dev/null
+++ b/cs-cz/go.html.markdown
@@ -0,0 +1,431 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo-cs.go
+lang: cs-cz
+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"]
+    - ["Jose Donizetti", "https://github.com/josedonizetti"]
+    - ["Alexej Friesen", "https://github.com/heyalexej"]
+    - ["Clayton Walker", "https://github.com/cwalk"]
+translators:
+    - ["Ondra Linek", "https://github.com/defectus/"]
+---
+
+Jazyk Go byl vytvořen, jelikož bylo potřeba dokončit práci. Není to poslední 
+trend ve světě počítačové vědy, ale je to nejrychlejší a nejnovější způsob,
+jak řešit realné problémy.
+
+Go používá známé koncepty imperativních jazyků se statickým typováním.
+Rychle se kompiluje a také rychle běží. Přidává snadno pochopitelnou
+podporu konkurenčnosti, což umožňuje využít výhody multi-core procesorů a
+jazyk také obsahuje utility, které pomáhají se škálovatelným programováním.
+
+Go má již v základu vynikající knihovnu a je s ním spojená nadšená komunita.
+
+```go
+// Jednořádkový komentář
+/* Několika
+ řádkový komentář */
+
+// Každý zdroják začíná deklarací balíčku (package)
+// Main je vyhrazené jméno, které označuje spustitelný soubor,
+// narozdíl od knihovny
+package main
+
+// Importní deklarace říkají, které knihovny budou použity v tomto souboru.
+import (
+	"fmt"       // Obsahuje formátovací funkce a tisk na konzolu
+	"io/ioutil" // Vstupně/výstupní funkce
+	m "math"    // Odkaz na knihovnu math (matematické funkce) pod zkratkou m
+	"net/http"  // Podpora http protokolu, klient i server.
+	"strconv"   // Konverze řetězců, např. na čísla a zpět.
+)
+
+// Definice funkce. Funkce main je zvláštní, je to vstupní bod do programu.
+// Ať se vám to líbí, nebo ne, Go používá složené závorky
+func main() {
+	// Println vypisuje na stdout.
+	// Musí být kvalifikováno jménem svého balíčko, ftm.
+	fmt.Println("Hello world!")
+
+	// Zavoláme další funkci
+	svetPoHello()
+}
+
+// Funkce mají své parametry v závorkách
+// Pokud funkce nemá parametry, tak musíme stejně závorky uvést.
+func svetPoHello() {
+	var x int // Deklarace proměnné. Proměnné musí být před použitím deklarované
+	x = 3     // Přiřazení hodnoty do proměnné
+	// Existuje "krátká" deklarace := kde se typ proměnné odvodí, 
+	// proměnná vytvoří a přiřadí se jí hodnota
+	y := 4
+	sum, prod := naucSeNasobit(x, y)        // Funkce mohou vracet více hodnot
+	fmt.Println("sum:", sum, "prod:", prod) // Jednoduchý výstup
+	naucSeTypy()                            // < y minut je za námi, je čas učit se víc!
+}
+
+/* <- začátek mnohořádkového komentáře
+Funkce mohou mít parametry a (několik) návratových hodnot.
+V tomto případě jsou `x`, `y` parametry a `sum`, `prod` jsou návratové hodnoty.
+Všiměte si, že `x` a `sum` jsou typu `int`.
+*/
+func naucSeNasobit(x, y int) (sum, prod int) {
+	return x + y, x * y // Vracíme dvě hodnoty
+}
+
+// zabudované typy a literáty.
+func naucSeTypy() {
+	// Krátká deklarace většinou funguje
+	str := "Learn Go!" // typ řetězec.
+
+	s2 := `"surový" literát řetězce
+může obsahovat nové řádky` // Opět typ řetězec.
+
+	// Můžeme použít ne ASCII znaky, Go používá UTF-8.
+	g := 'Σ' // type runa, což je alias na int32 a ukládá se do něj znak UTF-8
+
+	f := 3.14195 // float64, je IEEE-754 64-bit číslem s plovoucí čárkou.
+	c := 3 + 4i  // complex128, interně uložené jako dva float64.
+
+	// takhle vypadá var s inicializací
+	var u uint = 7 // Číslo bez znaménka, jehož velikost záleží na implementaci,
+	               // stejně jako int
+	var pi float32 = 22. / 7
+
+	// takto se převádí typy za pomoci krátké syntaxe
+	n := byte('\n') // byte je jiné jméno pro uint8.
+
+	// Pole mají fixní délku, které se určuje v době kompilace.
+	var a4 [4]int           // Pole 4 intů, všechny nastaveny na 0.
+	a3 := [...]int{3, 1, 5} // Pole nastaveno na tři hodnoty
+	// elementy mají hodntu 3, 1 a 5
+
+	// Slicy mají dynamickou velikost. Pole i slacy mají své výhody,
+	// ale většinou se používají slicy.
+	s3 := []int{4, 5, 9}    // Podobně jako a3, ale není tu výpustka.
+	s4 := make([]int, 4)    // Alokuj slice 4 intů, všechny nastaveny na 0.
+	var d2 [][]float64      // Deklarace slicu, nic se nealokuje.
+	bs := []byte("a slice") // Přetypování na slice
+
+	// Protože jsou dynamické, můžeme ke slicům přidávat za běhu
+	// Přidat ke slicu můžeme pomocí zabudované funkce append().
+	// Prvním parametrem je slice, návratová hodnota je aktualizovaný slice.
+	s := []int{1, 2, 3}		// Výsledkem je slice se 3 elementy.
+	s = append(s, 4, 5, 6)	// Přidány další 3 elementy. Slice má teď velikost 6.
+	fmt.Println(s) // Slice má hodnoty [1 2 3 4 5 6]
+
+	// Pokud chceme k poli přičíst jiné pole, můžeme předat referenci na slice,
+	// nebo jeho literát a přidat výpustku, čímž se slicu "rozbalí" a přidá se k
+	// původnímu slicu.
+	s = append(s, []int{7, 8, 9}...) // druhým parametrem je literát slicu.
+	fmt.Println(s)	// slice má teď hodnoty [1 2 3 4 5 6 7 8 9]
+
+	p, q := naucSePraciSPameti() // Deklarujeme p a q jako typ pointer na int.
+	fmt.Println(*p, *q)   // * dereferencuje pointer. Tím se vypíší dva inty.
+
+	// Mapy jsou dynamické rostoucí asociativní pole, jako hashmapa, nebo slovník
+	// (dictionary) v jiných jazycích
+	m := map[string]int{"tri": 3, "ctyri": 4}
+	m["jedna"] = 1
+
+	// Napoužité proměnné jsou v Go chybou.
+	// Použijte podtržítko, abychom proměnno "použili".
+	_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
+	// Výpis promenné se počítá jako použití.
+	fmt.Println(s, c, a4, s3, d2, m)
+
+	naucSeVetveníProgramu() // Zpátky do běhu.
+}
+
+// narozdíl od jiných jazyků, v Go je možné mít pojmenované návratové hodnoty.
+// Tak můžeme vracet hodnoty z mnoha míst funkce, aniž bychom uváděli hodnoty v
+// return.
+func naucSePojmenovaneNavraty(x, y int) (z int) {
+	z = x * y
+	return // z je zde implicitní, jelikož bylo pojmenováno.
+}
+
+// Go má garbage collector. Používá pointery, ale neumožňuje jejich aritmetiku.
+// Můžete tedy udělat chybu použitím nil odkazu, ale ne jeho posunutím.
+func naucSePraciSPameti() (p, q *int) {
+	// Pojmenované parametry p a q mají typ odkaz na int.
+	p = new(int) // Zabudované funkce new alokuje paměť.
+	// Alokované místo pro int má hodnotu 0 a p už není nil.
+	s := make([]int, 20) // Alokujeme paměť pro 20 intů.
+	s[3] = 7             // Jednu z nich nastavíme.
+	r := -2              // Deklarujeme další lokální proměnnou.
+	return &s[3], &r     // a vezmeme si jejich odkaz pomocí &.
+}
+
+func narocnyVypocet() float64 {
+	return m.Exp(10)
+}
+
+func naucSeVetveníProgramu() {
+	// Výraz if vyžaduje složené závorky, ale podmínka nemusí být v závorkách.
+	if true {
+		fmt.Println("říkal jsme ti to")
+	}
+	// Formátování je standardizované pomocí utility "go fmt".
+	if false {
+		// posměšek.
+	} else {
+		// úšklebek.
+	}
+	// Použij switch, když chceš zřetězit if.
+	x := 42.0
+	switch x {
+	case 0:
+	case 1:
+	case 42:
+		// jednotlivé case nepropadávají. není potřeba "break"
+	case 43:
+		// nedosažitelné, jelikož už bylo ošetřeno.
+	default:
+		// implicitní větev je nepovinná.
+	}
+	// Stejně jako if, for (smyčka) nepoužívá závorky.
+	// Proměnné definované ve for jsou lokální vůči smyčce.
+	for x := 0; x < 3; x++ { // ++ je výrazem.
+		fmt.Println("iterace", x)
+	}
+	// zde je x == 42.
+
+	// For je jediná smyčka v Go, ale má několik tvarů.
+	for { // Nekonečná smyčka
+		break    // Dělám si legraci
+		continue // Sem se nedostaneme
+	}
+
+	// Můžete použít klíčové slovo range pro iteraci nad mapami, poli, slicy,
+	// řetězci a kanály.
+	// range vrací jednu (kanál) nebo dvě hodnoty (pole, slice, řetězec a mapa).
+	for key, value := range map[string]int{"jedna": 1, "dva": 2, "tri": 3} {
+		// pro každý pár (klíč a hodnota) je vypiš
+		fmt.Printf("klíč=%s, hodnota=%d\n", key, value)
+	}
+
+	// stejně jako for, := v podmínce if přiřazuje hodnotu
+	// nejříve nastavíme y a pak otestujeme, jestli je y větší než x.
+	if y := narocnyVypocet(); y > x {
+		x = y
+	}
+	// Funkční literáty jsou tzv. uzávěry (closure)
+	xBig := func() bool {
+		return x > 10000 // odkazuje na x deklarované ve příkladu použití switch
+	}
+	x = 99999
+	fmt.Println("xBig:", xBig()) // true
+	x = 1.3e3                    // To udělá z x == 1300
+	fmt.Println("xBig:", xBig()) // teď už false.
+
+	// Dále je možné funkční literáty definovat a volat na místě jako parametr
+	// funkce, dokavaď:
+	// a) funkční literát je okamžitě volán pomocí (),
+	// b) výsledek se shoduje s očekávaným typem.
+	fmt.Println("Sečte + vynásobí dvě čísla: ",
+		func(a, b int) int {
+			return (a + b) * 2
+		}(10, 2)) // Voláno s parametry 10 a 2
+	// => Sečti a vynásob dvě čísla. 24
+
+	// Když to potřebujete, tak to milujete
+	goto miluji
+miluji:
+
+	naučteSeFunkčníFactory() // funkce vracející funkce je zábava(3)(3)
+	naučteSeDefer()      // malá zajížďka k důležitému klíčovému slovu.
+	naučteSeInterfacy() // Přichází dobré věci!
+}
+
+func naučteSeFunkčníFactory() {
+	// Následující dvě varianty jsou stejné, ale ta druhá je praktičtější
+	fmt.Println(větaFactory("létní")("Hezký", "den!"))
+
+	d := větaFactory("letní")
+	fmt.Println(d("Hezký", "den!"))
+	fmt.Println(d("Líný", "odpoledne!"))
+}
+
+// Dekorátory jsou běžné v jiných jazycích. To samé můžete udělat v Go
+// pomocí parameterizovatelných funkčních literátů.
+func větaFactory(můjŘetězec string) func(před, po string) string {
+	return func(před, po string) string {
+		return fmt.Sprintf("%s %s %s", před, můjŘetězec, po) // nový řetězec
+	}
+}
+
+func naučteSeDefer() (ok bool) {
+	// Odloží (defer) příkazy na okamžik těsně před opuštěním funkce.
+	// tedy poslední se provede první
+	defer fmt.Println("odložené příkazy jsou zpravovaná v LIFO pořadí.")
+	defer fmt.Println("\nProto je tato řádka vytištěna první")
+	// Defer se běžně používá k zavírání souborů a tím se zajistí, že soubor
+	// bude po ukončení funkce zavřen.
+	return true
+}
+
+// definuje typ interfacu s jednou metodou String()
+type Stringer interface {
+	String() string
+}
+
+// Definuje pár jako strukturu se dvěma poli typu int x a y.
+type pár struct {
+	x, y int
+}
+
+// Definuje method pár. Pár tedy implementuje interface Stringer.
+func (p pár) String() string { // p je tu nazýváno "Receiver" - přijímač
+	// Sprintf je další veřejná funkce z balíčku fmt.
+	// Pomocí tečky přistupujeme k polím proměnné p
+	return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func naučteSeInterfacy() {
+	// Složené závorky jsou "strukturální literáty. Vyhodnotí a inicializuje
+	// strukturu. Syntaxe := deklaruje a inicializuje strukturu.
+	p := pár{3, 4}
+	fmt.Println(p.String()) // Volá metodu String na p typu pár.
+	var i Stringer          // Deklaruje i jako proměnné typu Stringer.
+	i = p                   // Toto je možné, jelikož oba implementují Stringer
+	// zavolá metodu String(( typu Stringer a vytiskne to samé jako předchozí.
+	fmt.Println(i.String())
+
+	// Funkce ve balíčku fmt volají metodu String, když zjišťují, jak se má typ
+	// vytisknout.
+	fmt.Println(p) // Vytiskne to samé, jelikož Println volá String().
+	fmt.Println(i) // Ten samý výstup.
+
+	naučSeVariabilníParametry("super", "učit se", "tady!")
+}
+
+// Funcke mohou mít proměnlivé množství parametrů.
+func naučSeVariabilníParametry(mojeŘetězce ...interface{}) {
+	// Iterujeme přes všechny parametry
+	// Potržítku tu slouží k ignorování indexu v poli.
+	for _, param := range mojeŘetězce {
+		fmt.Println("parameter:", param)
+	}
+
+	// Použít variadický parametr jako variadický parametr, nikoliv pole.
+	fmt.Println("parametery:", fmt.Sprintln(mojeŘetězce...))
+
+	naučSeOšetřovatChyby()
+}
+
+func naučSeOšetřovatChyby() {
+	// ", ok" je metodou na zjištění, jestli něco fungovalo, nebo ne.
+	m := map[int]string{3: "tri", 4: "ctyri"}
+	if x, ok := m[1]; !ok { // ok bude false, jelikož 1 není v mapě.
+		fmt.Println("není tu jedna")
+	} else {
+		fmt.Print(x) // x by bylo tou hodnotou, pokud by bylo v mapě.
+	}
+	// hodnota error není jen znamením OK, ale může říct více o chybě.
+	if _, err := strconv.Atoi("ne-int"); err != nil { // _ hodnotu zahodíme
+		// vytiskne 'strconv.ParseInt: parsing "non-int": invalid syntax'
+		fmt.Println(err)
+	}
+	// Znovu si povíme o interfacech, zatím se podíváme na
+	naučSeKonkurenčnost()
+}
+
+// c je kanál, způsob, jak bezpečně komunikovat v konkurenčním prostředí.
+func zvyš(i int, c chan int) {
+	c <- i + 1 // <- znamená "pošli" a posílá data do kanálu na levé straně.
+}
+
+// Použijeme funkci zvyš a konkurečně budeme zvyšovat čísla.
+func naučSeKonkurenčnost() {
+	// funkci make jsme již použili na slicy. make alokuje a inicializuje slidy,
+	// mapy a kanály.
+	c := make(chan int)
+	// nastartuj tři konkurenční go-rutiny. Čísla se budou zvyšovat
+	// pravděpodobně paralelně pokud je počítač takto nakonfigurován.
+	// Všechny tři zapisují do toho samého kanálu.
+	go zvyš(0, c) // go je výraz pro start nové go-rutiny.
+	go zvyš(10, c)
+	go zvyš(-805, c)
+	// Přečteme si tři výsledky a vytiskeneme je..
+	// Nemůžeme říct, v jakém pořadí výsledky přijdou!
+	fmt.Println(<-c, <-c, <-c) // pokud je kanál na pravo, jedná se o "přijmi".
+
+	cs := make(chan string)       // Další kanál, tentokrát pro řetězce.
+	ccs := make(chan chan string) // Kanál kanálu řetězců.
+	go func() { c <- 84 }()       // Start nové go-rutiny na posílání hodnot.
+	go func() { cs <- "wordy" }() // To samé s cs.
+	// Select má syntaxi jako switch, ale vztahuje se k operacím nad kanály.
+	// Náhodně vybere jeden case, který je připraven na komunikaci.
+	select {
+        case i := <-c: // Přijatá hodnota může být přiřazena proměnné.
+            fmt.Printf("je to typ %T", i)
+        case <-cs: // nebo může být zahozena
+            fmt.Println("je to řetězec")
+        case <-ccs: // prázdný kanál, nepřipraven ke komunikaci.
+      		fmt.Println("to se nestane.")
+	}
+	// V tomto okamžiku máme hodnotu buď z kanálu c nabo cs. Jedna nebo druhá
+	// nastartovaná go-rutina skončila a další zůstane blokovaná.
+
+	naučSeProgramovatWeb() // Go to umí. A vy to chcete taky.
+}
+
+// jen jedna funkce z balíčku http spustí web server.
+func naučSeProgramovatWeb() {
+
+	// První parametr ListenAndServe je TCP adresa, kde poslouchat.
+	// Druhý parametr je handler, implementující interace http.Handler.
+	go func() {
+		err := http.ListenAndServe(":8080", pár{})
+		fmt.Println(err) // neignoruj chyby
+	}()
+
+	requestServer()
+}
+
+// Umožní typ pár stát se http tím, že implementuje její jedinou metodu
+// ServeHTTP.
+func (p pár) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Servíruj data metodou http.ResponseWriter
+	w.Write([]byte("Naučil ses Go za y minut!"))
+}
+
+func requestServer() {
+	resp, err := http.Get("http://localhost:8080")
+	fmt.Println(err)
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	fmt.Printf("\nWebserver řekl: `%s`", string(body))
+}
+```
+
+## Kam dále
+
+Vše hlavní o Go se nachází na [oficiálních stránkách go](http://golang.org/).
+Tam najdete tutoriály, interaktivní konzolu a mnoho materiálu ke čtení.
+Kromě úvodu, [dokumenty](https://golang.org/doc/) tam obsahují jak psát čistý kód v Go
+popis balíčků (package), dokumentaci příkazové řádky a historii releasů.
+
+Také doporučujeme přečíst si definici jazyka. Je čtivá a překvapivě krátká. Tedy alespoň proti
+jiným současným jazyků.
+
+Pokud si chcete pohrát s Go, tak navštivte [hřiště Go](https://play.golang.org/p/r46YvCu-XX).
+Můžete tam spouštět programy s prohlížeče. Také můžete [https://play.golang.org](https://play.golang.org) použít jako
+[REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop), kde si v rychlosti vyzkoušíte věci, bez instalace Go.
+
+Na vašem knižním seznamu, by neměly chybět [zdrojáky stadardní knihovny](http://golang.org/src/pkg/).
+Důkladně popisuje a dokumentuje Go, styl zápisu Go a Go idiomy. Pokud kliknete na [dokumentaci](http://golang.org/pkg/)
+tak se podíváte na dokumentaci.
+
+Dalším dobrým zdrojem informací je [Go v ukázkách](https://gobyexample.com/).
+
+Go mobile přidává podporu pro Android a iOS. Můžete s ním psát nativní mobilní aplikace nebo knihovny, které půjdou
+spustit přes Javu (pro Android), nebo Objective-C (pro iOS). Navštivte [web Go Mobile](https://github.com/golang/go/wiki/Mobile)
+pro více informací.
diff --git a/cs-cz/hack.html.markdown b/cs-cz/hack.html.markdown
new file mode 100644
index 00000000..736ad7e0
--- /dev/null
+++ b/cs-cz/hack.html.markdown
@@ -0,0 +1,309 @@
+---
+language: Hack
+filename: learnhack-cs.hh
+contributors:
+    - ["Stephen Holdaway", "https://github.com/stecman"]
+translators:
+    - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
+lang: cs-cz
+---
+
+Hack je nadmnožinou PHP a běží v rámci virtuálního stroje zvaného HHVM. Hack 
+dokáže skoro plně spolupracovat s existujícím PHP a přidává několik vylepšení, 
+které známe ze staticky typovaných jazyků.
+
+Níže jsou popsané pouze vlastnosti jazyka Hack. Detaily ohledně jazyka PHP a jeho
+syntaxe pak najdete na těchto stránkách v samostatném 
+[článku o PHP](http://learnxinyminutes.com/docs/php/).
+
+```php
+<?hh
+
+// Hack je aktivní pouze pro soubory, které začínají <?hh.
+// TODO <?hh soubory nemohou být jendoduše přeloženy v HTML tak jako <?php.
+// Použitím značky <?hh //strict zapnete striktní mód typové kontroly.
+
+
+// Typování skalární parametrů
+function repeat(string $word, int $count)
+{
+    $word = trim($word);
+    return str_repeat($word . ' ', $count);
+}
+
+// Typování návratových hodnot
+function add(...$numbers) : int
+{
+    return array_sum($numbers);
+}
+
+// Funkce které nic nevrací jsou typované jako "void"
+function truncate(resource $handle) : void
+{
+    // ...
+}
+
+// U typování musíme explicitně povolit prázdné (null) hodnoty
+function identity(?string $stringOrNull) : ?string
+{
+    return $stringOrNull;
+}
+
+// Typování může být použito i na proměnné třídy
+class TypeHintedProperties
+{
+    public ?string $name;
+    
+    protected int $id;
+
+    private float $score = 100.0;
+
+    // Typ proměnné si můžeme zadat přímo u definice proměnné v rámci třídy,
+    // ale pak ho snadně přetížit v konstruktoru metody.
+    public function __construct(int $id)
+    {
+        $this->id = $id;
+    }
+}
+
+
+// Stručné anonymní funkce (lambda funkce)
+$multiplier = 5;
+array_map($y ==> $y * $multiplier, [1, 2, 3]);
+
+
+// Generika (generické funkce)
+class Box<T>
+{
+    protected T $data;
+
+    public function __construct(T $data) {
+        $this->data = $data;
+    }
+
+    public function getData(): T {
+        return $this->data;
+    }
+}
+
+function openBox(Box<int> $box) : int
+{
+    return $box->getData();
+}
+
+
+// Tvary
+// 
+// Hack zavádí koncept tvaru pro definování strukturovaných polí s garantovanou
+// typovou kontrolou pro klíče.
+type Point2D = shape('x' => int, 'y' => int);
+
+function distance(Point2D $a, Point2D $b) : float
+{
+    return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
+}
+
+distance(
+    shape('x' => -1, 'y' => 5),
+    shape('x' => 2, 'y' => 50)
+);
+
+
+// Type aliasing
+// 
+// Hack přidává několik vylepšení pro lepší čitelnost komplexních typů
+newtype VectorArray = array<int, Vector<int>>;
+
+// Množina obsahující čísla
+newtype Point = (int, int);
+
+function addPoints(Point $p1, Point $p2) : Point
+{
+    return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
+}
+
+addPoints(
+    tuple(1, 2),
+    tuple(5, 6)
+);
+
+
+// Výčtový typ
+enum RoadType : int
+{
+    Road = 0;
+    Street = 1;
+    Avenue = 2;
+    Boulevard = 3;
+}
+
+function getRoadType() : RoadType
+{
+    return RoadType::Avenue;
+}
+
+
+// Automatické nastavení proměnných třídy
+// 
+// Aby se nemuseli definovat proměnné třídy a její konstruktor,
+// který pouze nastavuje třídní proměnné, můžeme v Hacku vše 
+// definovat najednou.
+class ArgumentPromotion
+{
+    public function __construct(public string $name,
+                                protected int $age,
+                                private bool $isAwesome) {}
+}
+
+// Takto by to vypadalo bez automatického nastavení proměnných
+class WithoutArugmentPromotion
+{
+    public string $name;
+
+    protected int $age;
+
+    private bool $isAwesome;
+
+    public function __construct(string $name, int $age, bool $isAwesome)
+    {
+        $this->name = $name;
+        $this->age = $age;
+        $this->isAwesome = $isAwesome;
+    }
+}
+
+
+// Ko-operativní multi-tasking
+// 
+// Nová klíčová slova "async" and "await" mohou být použité pro spuštění mutli-taskingu
+// Tato vlastnost ovšem zahrnuje vícevláknové zpracování, pouze povolí řízení přenosu
+async function cooperativePrint(int $start, int $end) : Awaitable<void>
+{
+    for ($i = $start; $i <= $end; $i++) { 
+        echo "$i ";
+
+        // Dává ostatním úlohám šanci něco udělat
+        await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+    }
+}
+
+// Toto vypíše "1 4 7 2 5 8 3 6 9"
+AwaitAllWaitHandle::fromArray([
+    cooperativePrint(1, 3),
+    cooperativePrint(4, 6),
+    cooperativePrint(7, 9)
+])->getWaitHandle()->join();
+
+
+// Atributy
+// 
+// Atributy jsou určitou formou metadat pro funkce. Hack přidává některé vestavěné 
+// atributy které aktivnují uživatečné chování funkcí.
+
+// Speciální atribut __Memoize způsobí, že výsledek funkce je uložen do cache
+<<__Memoize>>
+function doExpensiveTask() : ?string
+{
+    return file_get_contents('http://example.com');
+}
+
+// Tělo funkce je v tomto případě vykonáno pouze jednou:
+doExpensiveTask();
+doExpensiveTask();
+
+
+// Speciální atribut __ConsistentConstruct signalizuje typové kontrole Hacku, že
+// zápis __construct bude stejný pro všechny podtřídy.
+<<__ConsistentConstruct>>
+class ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+        // ...
+    }
+
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class ConsistentBar extends ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+        // Typová kontrola Hacku zajistí volání konstruktoru rodičovské třídy
+        parent::__construct($x, $y);
+
+        // ...
+    }
+
+    // Anotace __Override je volitelný signál pro typovou kontrolu Hacku, že
+    // tato metoda přetěžuje metodu rodičovské třídy, nebo traitu. Bez uvedení
+    // této anotace vyhodí typová kontrola chybu.
+    <<__Override>>
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class InvalidFooSubclass extends ConsistentFoo
+{
+    // Nedodržení zápisu dle rodičovského konstruktoru způsobí syntaktickou chybu:
+    //  
+    //  "Tento objekt je typu ConsistentBaz a není kompatibilní v tímto objektem,
+    //   který je typu ConsistentFoo protože některé jeho metody nejsou kompatibilní."
+    //
+    public function __construct(float $x)
+    {
+        // ...
+    }
+
+    // Použitím anotace __Override na nepřetíženou metodu způsobí chybu typové kontroly:
+    //  
+    //  "InvalidFooSubclass::otherMethod() je označená jako přetížená, ale nebyla nalezena
+    //   taková rodičovská metoda, nebo rodič kterého přetěžujete není zapsán v <?hh kódu"
+    //
+    <<__Override>>
+    public function otherMethod()
+    {
+        // ...
+    }
+}
+
+
+// Traity mohou implementovat rozhraní, což standardní PHP neumí
+interface KittenInterface
+{
+    public function play() : void;
+}
+
+trait CatTrait implements KittenInterface
+{
+    public function play() : void
+    {
+        // ...
+    }
+}
+
+class Samuel
+{
+    use CatTrait;
+}
+
+
+$cat = new Samuel();
+$cat instanceof KittenInterface === true; // True
+
+```
+
+## Více informací
+
+Pro více informací navštivte [referenční příručku jazyka Hack](http://docs.hhvm.com/manual/en/hacklangref.php), 
+kde se dozvíte více detailu a vylepšení, které jazyk Hack přidává do PHP, a nebo navštivte [oficiální stránky jazyka Hack](http://hacklang.org/)
+pro obecné informace.
+
+Pro instrukce k instalaci jazyka Hack navštivte [oficiální HHVM stránky](http://hhvm.com/).
+
+Pro více informací ohledně zpětné kompatibility s PHP navštivte článek o [nepodporovaných PHP vlastnostech Hacku](http://docs.hhvm.com/manual/en/hack.unsupported.php).
diff --git a/cs-cz/javascript.html.markdown b/cs-cz/javascript.html.markdown
new file mode 100644
index 00000000..cbf7687e
--- /dev/null
+++ b/cs-cz/javascript.html.markdown
@@ -0,0 +1,574 @@
+---
+language: javascript
+contributors:
+    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Ariel Krakowski", "http://www.learneroo.com"]
+translators:
+    - ["Michal Martinek", "https://github.com/MichalMartinek"]
+lang: cs-cz
+filename: javascript-cz.js
+---
+
+JavaScript byl vytvořen Brendan Eichem v roce 1995 pro Netscape. Byl původně
+zamýšlen jako jednoduchý skriptovací jazyk pro webové stránky, jako doplněk Javy,
+která byla zamýšlena pro více komplexní webové aplikace, ale jeho úzké propojení
+s webovými stránkami a vestavěná podpora v prohlížečích způsobila, že se stala
+více běžná ve webovém frontendu než Java.
+
+
+JavaScript není omezen pouze na webové prohlížeče, např. projekt Node.js,
+který zprostředkovává samostatně běžící prostředí V8 JavaScriptového enginu z
+Google Chrome se stává více a více oblíbený pro serverovou část webových aplikací.
+
+Zpětná vazba je velmi ceněná. Autora článku můžete kontaktovat (anglicky) na
+[@adambrenecki](https://twitter.com/adambrenecki), nebo
+[adam@brenecki.id.au](mailto:adam@brenecki.id.au), nebo mě, jakožto překladatele,
+na [martinek@ludis.me](mailto:martinek@ludis.me).
+
+```js
+// Komentáře jsou jako v zayku C. Jednořádkové komentáře začínájí dvojitým lomítkem,
+/* a víceřádkové komentáře začínají lomítkem s hvězdičkou
+   a končí hvězdičkou s lomítkem */
+
+// Vyrazu můžou být spuštěny pomocí ;
+delejNeco();
+
+// ... ale nemusí, středníky jsou automaticky vloženy kdekoliv,
+// kde končí řádka, kromě pár speciálních případů
+delejNeco()
+
+// Protože tyto případy můžou způsobit neočekávané výsledky, budeme
+// středníky v našem návodu používat.
+
+/////////////////////////////////
+// 1. Čísla, řetězce a operátory
+
+// JavaScript má jeden číselný typ (čímž je 64-bitový IEEE 754 double).
+// Double má 52-bit přesnost, což je dostatečně přesné pro ukládání celých čísel
+// do 9✕10¹⁵.
+3; // = 3
+1.5; // = 1.5
+
+// Základní matematické operace fungují, jak byste očekávali
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Včetně dělení
+5 / 2; // = 2.5
+
+// A také dělení modulo
+10 % 2; // = 0
+30 % 4; // = 2
+18.5 % 7; // = 4.5
+
+// Bitové operace také fungují; když provádíte bitové operace, desetinné číslo  
+// (float) se převede na celé číslo (int) se znaménkem *do* 32 bitů
+1 << 2; // = 4
+
+// Přednost se vynucuje závorkami.
+(1 + 3) * 2; // = 8
+
+// Existují 3 hodnoty mimo obor reálných čísel
+Infinity; // + nekonečno; výsledek např. 1/0
+-Infinity; // - nekonečno; výsledek např. -1/0
+NaN; // výsledek např. 0/0, znamená, že výsledek není číslo ('Not a Number')
+
+// Také existují hodnoty typu bool
+true; // pravda
+false; // nepravda
+
+// Řetězce znaků jsou obaleny  ' nebo ".
+'abc';
+"Ahoj světe!";
+
+// Negace se tvoří pomocí !
+!true; // = false
+!false; // = true
+
+// Rovnost se porovnává ===
+1 === 1; // = true
+2 === 1; // = false
+
+// Nerovnost zase pomocí !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Další srovnávání
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Řetězce znaků se spojují pomocí +
+"Ahoj " + "světe!"; // = "Ahoj světe!"
+
+// ... což funguje nejenom s řetězci
+"1, 2, " + 3; // = "1, 2, 3"
+"Ahoj " + ["světe", "!"] // = "Ahoj světe,!"
+
+// a porovnávají se pomocí < nebo >
+"a" < "b"; // = true
+
+// Rovnost s převodem typů se dělá pomocí == ...
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...dokud nepoužijete ===
+"5" === 5; // = false
+null === undefined; // = false
+
+// ...což může občas způsobit divné chování...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// Můžeme přistupovat k jednotlivým znakům v řetězci pomocí charAt`
+"Toto je řetězec".charAt(0);  // = 'T'
+
+// ...nebo použít `substring` k získání podřetězce
+"Ahoj světe".substring(0, 4); // = "Ahoj"
+
+// `length` znamená délka a je to vlastnost, takže nepoužívejte ()
+"Ahoj".length; // = 4
+
+// Existují také typy `null` a `undefined`.
+null;      // značí, že žádnou hodnotu
+undefined; // značí, že hodnota nebyla definovaná (ikdyž
+           // `undefined` je hodnota sama o sobě)
+
+// false, null, undefined, NaN, 0 and "" vrací nepravdu (false). Všechno ostatní
+// vrací pravdu (true)..
+// Všimněte si, že 0 vrací nepravdu, ale "0" vrací pravdu, ikdyž 0 == "0"
+// vrací pravdu
+
+///////////////////////////////////
+// 2. Proměnné, pole a objekty
+
+// Proměnné jsou deklarovány pomocí slůvka `var`. JavaScript je dynamicky
+// typovaný, takže nemusíme specifikovat typ. K přiřazení hodnoty se používá
+// znak `=`.
+var promenna = 5;
+
+// když vynecháte slůvko 'var' nedostanete chybovou hlášku...
+jinaPromenna = 10;
+
+// ...ale vaše proměnná bude vytvořena globálně, bude vytvořena  v globálním
+// oblasti působnosti, ne jenom v lokálním tam, kde jste ji vytvořili
+
+// Proměnné vytvořené bez přiřazení obsahují hodnotu undefined.
+var dalsiPromenna; // = undefined
+
+// Pokud chcete vytvořit několik proměnných najednou, můžete je oddělit čárkou
+var someFourthVar = 2, someFifthVar = 4;
+
+// Existuje kratší forma pro matematické operace na proměnné
+promenna += 5; // se provede stejně jako promenna = promenna + 5;
+// promenna je ted 10
+promenna *= 10; // teď je promenna rovna 100
+
+// a tohle je způsob, jak přičítat a odečítat 1
+promenna++; // teď je promenna 101
+promenna--; // zpět na 100
+
+// Pole jsou uspořádané seznamy hodnot jakéhokoliv typu
+var mojePole = ["Ahoj", 45, true];
+
+// Jednotlivé hodnoty jsou přístupné přes hranaté závorky.
+// Členové pole se začínají počítat na nule.
+myArray[1]; // = 45
+
+// Pole je proměnlivé délky a členové se můžou měnit
+myArray.push("Světe");
+myArray.length; // = 4
+
+// Přidání/změna na specifickém indexu
+myArray[3] = "Hello";
+
+// JavaScriptové objekty jsou stejné jako asociativní pole v jinných programovacích
+// jazycích: je to neuspořádaná množina páru hodnot - klíč:hodnota.
+var mujObjekt = {klic1: "Ahoj", klic2: "světe"};
+
+// Klíče jsou řetězce, ale nejsou povinné uvozovky, pokud jsou validní
+// JavaScriptové identifikátory. Hodnoty můžou být jakéhokoliv typu-
+var mujObjekt = {klic: "mojeHodnota", "muj jiny klic": 4};
+
+// K hodnotám můžeme přistupovat opět pomocí hranatých závorek
+myObj["muj jiny klic"]; // = 4
+
+// ... nebo pokud je klíč platným identifikátorem, můžeme přistupovat k
+// hodnotám i přes tečku
+mujObjekt.klic; // = "mojeHodnota"
+
+// Objekty jsou měnitelné, můžeme upravit hodnoty, nebo přidat nové klíče.
+myObj.mujDalsiKlic = true;
+
+// Pokud se snažíte přistoupit ke klíči, který není nastaven, dostanete undefined
+myObj.dalsiKlic; // = undefined
+
+///////////////////////////////////
+// 3. Řízení toku programu
+
+// Syntaxe pro tuto sekci je prakticky stejná jako pro Javu
+
+// `if` (když) funguje, jak byste čekali.
+var pocet = 1;
+if (pocet == 3){
+    // provede, když se pocet rovná 3
+} else if (pocet == 4){
+    // provede, když se pocet rovná 4
+} else {
+    // provede, když je pocet cokoliv jinného
+}
+
+// Stejně tak cyklus while
+while (true){
+    // nekonečný cyklus
+}
+
+// Do-while cyklus je stejný jako while, akorát se vždy provede aspoň jednou
+var vstup;
+do {
+    vstup = nactiVstup();
+} while (!jeValidni(vstup))
+
+// Cyklus for je stejný jako v Javě nebo jazyku C
+// inicializace; podmínka pro pokračování; iterace.
+for (var i = 0; i < 3; i++){
+    // provede třikrát
+}
+
+// Cyklus For-in iteruje přes každo vlastnost prototypu
+var popis = "";
+var osoba = {prijmeni:"Paul", jmeno:"Ken", vek:18};
+for (var x in osoba){
+    popis += osoba[x] + " ";
+}
+
+//Když chcete iterovat přes vlastnosti, které jsou přímo na objektu a nejsou
+//zděněné z prototypů, kontrolujte vlastnosti přes hasOwnProperty()
+var popis = "";
+var osoba = {prijmeni:"Jan", jmeno:"Novák", vek:18};
+for (var x in osoba){
+    if (osoba.hasOwnProperty(x)){
+        popis += osoba[x] + " ";
+    }
+}
+
+// for-in by neměl být použit pro pole, pokud záleží na pořadí indexů.
+// Neexistuje jistota, že for-in je vrátí ve správném pořadí.
+
+// && je logické a, || je logické nebo
+if (dum.velikost == "velký" && dum.barva == "modrá"){
+    dum.obsahuje = "medvěd";
+}
+if (barva == "červená" || barva == "modrá"){
+    // barva je červená nebo modtrá
+}
+
+// && a || jsou praktické i pro nastavení základních hodnot
+var jmeno = nejakeJmeno || "default";
+
+
+// `switch` zkoumá přesnou rovnost (===)
+// Používejte 'break;' po každé možnosti, jinak se provede i možnost za ní.
+znamka = 'B';
+switch (znamka) {
+  case 'A':
+    console.log("Výborná práce");
+    break;
+  case 'B':
+    console.log("Dobrá práce");
+    break;
+  case 'C':
+    console.log("Dokážeš to i lépe");
+    break;
+  default:
+    console.log("Ale ne");
+    break;
+}
+
+////////////////////////////////////////////////////////
+// 4. Funckce, Oblast platnosti (scope) a Vnitřní funkce
+
+// JavaScriptové funkce jsou definovány slůvkem `function`.
+function funkce(text){
+    return text.toUpperCase();
+}
+funkce("něco"); // = "NĚCO"
+
+// Dávejte si pozor na to, že hodnota k vrácení musí začínat na stejné řádce
+// jako slůvko return, jinak se vrátí 'undefined', kvůli automatickému vkládání
+// středníků. Platí to zejména pro Allmanův styl zápisu.
+
+function funkce()
+{
+    return // <- zde je automaticky vložen středník
+    {
+        tohleJe: "vlastnost objektu"
+    }
+}
+funkce(); // = undefined
+
+// JavaScriptové funkce jsou objekty, takže můžou být přiřazeny různým proměnným
+// a předány dalším funkcím jako argumenty, na příklad:
+function funkce(){
+    // tento kód bude zavolán za 5 vteřin
+}
+setTimeout(funkce, 5000);
+// Poznámka: setTimeout není část JS jazyka, ale funkce poskytována
+// prohlížeči a NodeJS
+
+// Další funkce poskytovaná prohlížeči je je setInterval
+function myFunction(){
+    // tento kód bude volán každých 5 vteřin
+}
+setInterval(myFunction, 5000);
+
+// Objekty funkcí nemusíme ani deklarovat pomocí jména, můžeme je napsat jako
+// ananymní funkci přímo vloženou jako argument
+setTimeout(function(){
+  // tento kód bude zavolán za 5 vteřin    
+}, 5000);
+
+// JavaScript má oblast platnosti funkce, funkce ho mají, ale jiné bloky ne
+if (true){
+    var i = 5;
+}
+i; // = 5 - ne undefined, jak byste očekávali v jazyku, kde mají bloky svůj
+// rámec působnosti
+
+// Toto je běžný model,který chrání před únikem dočasných proměnných do
+//globální oblasti
+(function(){
+    var docasna = 5;
+    // Můžeme přistupovat k globálního oblasti přes přiřazování globalním
+    // objektům. Ve webovém prohlížeči je to vždy 'window`. Globální objekt
+    // může mít v jiných prostředích jako Node.js jinné jméno.
+    window.trvala = 10;
+})();
+docasna; // způsobí ReferenceError
+trvala; // = 10
+
+// Jedna z nejvice mocných vlastnosti JavaScriptu je vnitřní funkce. Je to funkce
+// definovaná v jinné funkci, vnitřní funkce má přístup ke všem proměnným ve
+// vnější funkci, dokonce i poté, co funkce skončí
+function ahojPoPetiVterinach(jmeno){
+    var prompt = "Ahoj, " + jmeno + "!";
+    // Vnitřní funkce je dána do lokální oblasti platnosti, jako kdyby byla
+    // deklarovaná slůvkem 'var'
+    function vnitrni(){
+        alert(prompt);
+    }
+    setTimeout(vnitrni, 5000);
+    // setTimeout je asynchronní, takže funkce ahojPoPetiVterinach se ukončí
+    // okamžitě, ale setTimeout zavolá funkci vnitrni až poté. Avšak protože
+    // vnitrni je definována přes ahojPoPetiVterinach, má pořád přístup k
+    // proměnné prompt, když je konečně zavolána.
+}
+ahojPoPetiVterinach("Adam"); // otevře popup s  "Ahoj, Adam!" za 5s
+
+///////////////////////////////////////////////////
+// 5. Více o objektech, konstuktorech a prototypech
+
+// Objekty můžou obsahovat funkce
+var mujObjekt = {
+    mojeFunkce: function(){
+        return "Ahoj světe!";
+    }
+};
+mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+
+// Když jsou funkce z objektu zavolány, můžou přistupovat k objektu přes slůvko
+// 'this''
+var mujObjekt = {
+    text: "Ahoj světe!",
+    mojeFunkce: function(){
+        return this.text;
+    }
+};
+mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+
+// Slůvko this je nastaveno k tomu, kde je voláno, ne k tomu, kde je definováno
+// Takže naše funkce nebude fungovat, když nebude v kontextu objektu.
+var mojeFunkce = mujObjekt.mojeFunkce;
+mojeFunkce(); // = undefined
+
+// Opačně, funkce může být přiřazena objektu a může přistupovat k objektu přes
+// this, i když nebyla přímo v definici-
+var mojeDalsiFunkce = function(){
+    return this.text.toUpperCase();
+}
+mujObjekt.mojeDalsiFunkce = mojeDalsiFunkce;
+mujObjekt.mojeDalsiFunkce(); // = "AHOJ SVĚTE!"
+
+// Můžeme také specifikovat, v jakém kontextu má být funkce volána pomocí
+// `call` nebo `apply`.
+
+var dalsiFunkce = function(s){
+    return this.text + s;
+}
+dalsiFunkce.call(mujObjekt, " A ahoj měsíci!"); // = "Ahoj světe! A ahoj měsíci!"
+
+// Funkce `apply`je velmi podobná, akorát bere jako druhý argument pole argumentů
+dalsiFunkce.apply(mujObjekt, [" A ahoj slunce!"]); // = "Ahoj světe! A ahoj slunce!"
+
+// To je praktické, když pracujete s funkcí, která bere sekvenci argumentů a
+// chcete předat pole.
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Ale `call` a `apply` jsou pouze dočasné. Pokud je chcete připojit trvale
+// použijte `bind`.
+
+var pripojenaFunkce = dalsiFunkce.bind(mujObjekt);
+pripojenaFunkce(" A ahoj Saturne!"); // = "Ahoj světe! A ahoj Saturne!"
+
+// `bind` může být použito čatečně částečně i k používání
+
+var nasobeni = function(a, b){ return a * b; }
+var zdvojeni = nasobeni.bind(this, 2);
+zdvojeni(8); // = 16
+
+// Když zavoláte funkci se slůvkem 'new', vytvoří se nový objekt a
+// a udělá se dostupný funkcím skrz slůvko 'this'. Funkcím volaným takto se říká
+// konstruktory
+
+var MujKonstruktor = function(){
+    this.mojeCislo = 5;
+}
+mujObjekt = new MujKonstruktor(); // = {mojeCislo: 5}
+mujObjekt.mojeCislo; // = 5
+
+// Každý JsavaScriptový objekt má prototyp. Když budete přistupovat k vlasnosti
+// objektu, který neexistuje na objektu, tak se JS koukne do prototypu.
+
+// Některé JS implementace vám umožní přistupovat k prototypu přes magickou
+// vlastnost '__proto__'. I když je toto užitečné k vysvětlování prototypů, není
+// to součást standardu, ke standartní způsobu k používání prototypu se dostaneme
+// později.
+var mujObjekt = {
+    mujText: "Ahoj svete!"
+};
+var mujPrototyp = {
+    smyslZivota: 42,
+    mojeFunkce: function(){
+        return this.mujText.toLowerCase()
+    }
+};
+
+mujObjekt.__proto__ = mujPrototyp;
+mujObjekt.smyslZivota; // = 42
+
+// Toto funguje i pro funkce
+mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+
+// Samozřejmě, pokud není vlastnost na vašem prototypu, tak se hledá na
+// prototypu od prototypu atd.
+mujPrototyp.__proto__ = {
+    mujBoolean: true
+};
+mujObjekt.mujBoolean; // = true
+
+
+// Zde neni žádné kopírování; každý objekt ukládá referenci na svůj prototyp
+// Toto znamená, že můžeme měnit prototyp a změny se projeví všude
+mujPrototyp.smyslZivota = 43;
+mujObjekt.smyslZivota // = 43
+
+// Zmínili jsme již předtím, že '__proto__' není ve standardu a není cesta, jak
+// měnit prototyp existujícího objektu. Avšak existují možnosti, jak vytvořit
+// nový objekt s daným prototypem
+
+// První je Object.create, což je nedávný přídavek do JS a není dostupný zatím
+// ve všech implementacích.
+var mujObjekt = Object.create(mujPrototyp);
+mujObjekt.smyslZivota // = 43
+
+// Druhý způsob, který funguje všude je pomocí konstuktoru. Konstruktor má
+// vlastnost jménem prototype. Toto *není* prototyp samotného konstruktoru, ale
+// prototyp nového objektu.
+MujKonstruktor.prototype = {
+    mojeCislo: 5,
+    ziskejMojeCislo: function(){
+        return this.mojeCislo;
+    }
+};
+var mujObjekt2 = new MujKonstruktor();
+mujObjekt2.ziskejMojeCislo(); // = 5
+mujObjekt2.mojeCislo = 6
+mujObjekt2.ziskejMojeCislo(); // = 6
+
+// Vestavěnné typy jako čísla nebo řetězce mají také konstruktory, které vytváří
+// ekvivalentní obalovací objekty (wrappery).
+var mojeCislo = 12;
+var mojeCisloObj = new Number(12);
+mojeCislo == mojeCisloObj; // = true
+
+// Avšak nejsou úplně přesně stejné
+typeof mojeCislo; // = 'number'
+typeof mojeCisloObj; // = 'object'
+mojeCislo === mojeCisloObj; // = false
+if (0){
+    // Tento kód se nespustí, protože 0 je nepravdivá (false)
+}
+
+if (new Number(0)){
+   // Tento kód se spustí, protože obalená čísla jsou objekty,
+   // a objekty jsou vždy pravdivé
+}
+
+// Avšak, obalovací objekty a normální vestavěnné typy sdílejí prototyp, takže
+// můžete přidat funkcionalitu k řetězci
+String.prototype.prvniZnak = function(){
+    return this.charAt(0);
+}
+"abc".prvniZnak(); // = "a"
+
+// Tento fakt je často používán v polyfillech, což je implementace novějších
+// vlastností JavaScriptu do starších variant, takže je můžete používat třeba
+// ve starých prohlížečích
+
+// Pro příkklad, zmínili jsme, že Object.create není dostupný ve všech
+// implementacích, můžeme si avšak přidat pomocí polyfillu
+if (Object.create === undefined){ // nebudeme ho přepisovat, když existuje
+    Object.create = function(proto){
+        // vytvoříme dočasný konstruktor
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // ten použijeme k vytvoření nového s prototypem
+        return new Constructor();
+    }
+}
+```
+
+## Kam dál
+
+[Mozilla Developer
+Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) obsahuje
+perfektní dokumentaci pro JavaScript, který je používaný v prohlížečích. Navíc
+je to i wiki, takže jakmile se naučíte více, můžete pomoci ostatním, tím, že
+přispějete svými znalostmi.
+
+MDN's [A re-introduction to
+JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+pojednává o konceptech vysvětlených zde v mnohem větší hloubce. Tento návod
+pokrývá hlavně JavaScript sám o sobě. Pokud se chcete naučit více, jak se používá
+na webových stránkách, začněte tím, že se kouknete na [DOM](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+
+[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) je varianta tohoto
+návodu i s úkoly-
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) je sbírka
+příkladů těch nejvíce nepředvídatelných částí tohoto jazyka.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/)
+je klasická výuková kniha.
+
+Jako dodatek k přímým autorům tohoto článku, některý obsah byl přizpůsoben z
+Pythoního tutoriálu od Louie Dinh na této stráce, a z [JS
+Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+z Mozilla Developer Network.
diff --git a/cs-cz/json.html.markdown b/cs-cz/json.html.markdown
new file mode 100644
index 00000000..5972da5e
--- /dev/null
+++ b/cs-cz/json.html.markdown
@@ -0,0 +1,62 @@
+---
+language: json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+    - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
+filename: learnjson-cz.json
+lang: cs-cz
+---
+
+JSON je exterémně jednoduchý datově nezávislý formát a bude asi jeden z 
+nejjednodušších 'Learn X in Y Minutes' ze všech.
+
+JSON nemá ve své nejzákladnější podobě žádné komentáře, ale většina parserů 
+umí pracovat s komentáři ve stylu jazyka C (`//`, `/* */`). Pro tyto účely 
+však budeme používat 100% validní JSON bez komentářů. Pojďme se podívat na 
+syntaxi formátu JSON:
+
+```json
+{
+  "klic": "value",
+  
+  "hodnoty": "Musí být vždy uvozený v dvojitých uvozovkách",
+  "cisla": 0,
+  "retezce": "Hellø, wørld. Všechny unicode znaky jsou povolené, společně s \"escapováním\".",
+  "pravdivostni_hodnota": true,
+  "prazdna_hodnota": null,
+
+  "velke_cislo": 1.2e+100,
+
+  "objekt": {
+    "komentar": "Most of your structure will come from objects.",
+
+    "pole": [0, 1, 2, 3, "Pole nemusí být pouze homogenní.", 5],
+
+    "jiny_objekt": {
+      "comment": "Je povolené jakkoli hluboké zanoření."
+    }
+  },
+
+  "cokoli": [
+    {
+      "zdroje_drasliku": ["banány"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+  
+  "alternativni_styl_zapisu": {
+    "komentar": "Mrkni se na toto!"
+  , "pozice_carky": "Na pozici čárky nezáleží - pokud je před hodnotou, ať už je kdekoli, tak je validní."
+  , "dalsi_komentar": "To je skvělé."
+  },
+
+  "to_bylo_rychle": "A tím jsme hotový. Nyní již víte vše, co může formát JSON nabídnout!"
+}
+```
diff --git a/cs-cz/markdown.html.markdown b/cs-cz/markdown.html.markdown
new file mode 100644
index 00000000..568e4343
--- /dev/null
+++ b/cs-cz/markdown.html.markdown
@@ -0,0 +1,260 @@
+---
+language: markdown
+lang: cs-cz
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+    - ["Michal Martinek", "https://github.com/MichalMartinek"]
+filename: markdown-cz.md
+lang: cs-cz
+---
+
+Markdown byl vytvořen Johnem Gruberem v roce 2004. Je zamýšlen jako lehce čitelná
+a psatelná syntaxe, která je jednoduše převeditelná do HTML (a dnes i do mnoha
+dalších formátů)
+
+```markdown
+<!-- Markdown je nadstavba nad HTML, takže jakýkoliv kód HTML je validní
+Markdown, to znamená, že můžeme používat HTML elementy, třeba jako komentář, a
+nebudou ovlivněny parserem Markdownu. Avšak, pokud vytvoříte HTML element v
+Markdownu, tak nemůžete používat syntaxi Markdownu uvnitř tohoto elementu. -->
+
+<!-- Markdown se také mírně liší v jednotlivých interpretacích parseru. Tento
+návod vás bude upozorňovat, které vlastnosti jsou obecné a které specifické pro
+konkrétní parser. -->
+
+<!-- Nadpisy -->
+<!-- Můžete vytvořit HTML elementy <h1> až <h6> jednoduše tak, že text předsadíte
+počtem křížků (#), podle toho jaké úrovně to má být nadpis -->
+# Toto je <h1>
+## Toto je <h2>
+### Toto je <h3>
+#### Toto je <h4>
+##### Toto je <h5>
+###### Toto je <h6>
+
+<!-- Markdown obsahuje taky dvě další cesty, jak udělat h1 a h2 -->
+Toto je h1
+==========
+
+Toto je h2
+----------
+
+<!-- Jednoduché stylování textu -->
+<!-- Pomocí markdownu můžete text jednoduše označit jako kurzívu či tučný -->
+
+*Tento text je kurzívou;*
+_Stejně jako tento._
+
+**Tento text je tučně**
+__Stejně jako tento.__
+
+***Tento text je obojí***
+**_Jako tento!_**
+*__A tento!__*
+
+<!-- Ve verzi Markdownu od GitHubu, máme k dispozici taky prošktrnutí: -->
+
+~~Tento text je prošktrnutý.~~
+
+<!-- Odstavce jsou jedna nebo více řádek textu, oddělených jednou nebo více prázdnými řádky. -->
+
+Toto je odstavec. Píši odstavec, není to zábava?
+
+Teď jsem v odstavci 2.
+Jsem pořád v odstavci 2!
+
+
+Toto je odstavec 3.
+
+<!-- Chtěli jste někdy vložit znak <br /> tag? Můžete napsat na konec odstavce
+dvě nebo více mezer a potom začít nový odstavec. -->
+
+Tento odstavec končí dvěma mezerami.  
+
+Nad tímto odstavcem je  <br />!
+
+<!-- Blokové citace se dělají jednoduše pomocí znaku >. -->
+
+> Toto je bloková citace. Můžete dokonce
+> manuálně rozdělit řádky, a před každý vložit >, nebo nechat vaše řádky jakkoliv dlouhé, ať se zarovnají sami.
+> Nedělá to rozdíl, dokud začínáte vždy znakem >.
+
+> Můžu použít více než jednu
+>> odsazení?
+> Jak je to úhledné, že?
+
+<!-- Seznamy -->
+<!-- Nečíslovaný seznam můžete jednoduše udělat pomocí hvězdiček, plusů, nebo
+ pomlček -->
+
+* Položka
+* Položka
+* Jinná položka
+
+nebo
+
++ Položka
++ Položka
++ Další položka
+
+nebo
+
+- Položka
+- Položka
+- Další položka
+
+<!-- Číslovaný seznam se dělají pomocí čísla a . -->
+
+1. Položka jedna
+2. Položka dvě
+3. Položka tři
+
+<!-- Nemusíte dokonce psát čísla správně a markdown je zobrazi správně,
+     ale nemusí to být vždy dobrý nápad -->
+
+1. Položka jedna
+1. Položka dvě
+1. Položka tři
+<!-- (Toto zobrazí to samě, jako příklad nadtím.) -->
+
+<!-- Můžete také tvořit podseznamy -->
+
+1. Položka jedna
+2. Položka dvě
+3. Položka tři
+    * Podpoložka
+    * Podpoložka
+4. Položka čtyři
+
+<!-- Existují i zašktávací seznamy. Toto vytvoří HTML checkboxy. -->
+
+Boxy níže bez 'x' jsou nezašktrnuté checkboxy.
+- [ ] První úkol
+- [ ] Druhý úkol
+Tento box bude zašktrnutý
+- [x] Tento úkol byl dokončen
+
+<!-- Bloky ködu -->
+<!-- Můžete označit kód bloku (který používá <code> element) odsazením pomocí 4
+     mezer, nebo tabu -->
+
+    Toto je kód
+    Stejně jako toto
+
+<!-- Můžete dokonce přidat další 4 mezery nebo tab pro další odsazení -->
+
+    moje_pole.each do |i|
+        puts i
+    end
+
+<!-- Kód na řádku může být označen pomocí zpětných apostrofů ` -->
+
+Jan nevědel, jak se dělá `go_to()` funkce!
+
+<!-- V Markdownu od GitHubu , můžete použít speciální syntaxi pro kód -->
+
+\`\`\`ruby <!-- vyjma zpětných lomítek, jenom ```ruby ! -->
+def neco
+    puts "Ahoj světe!"
+end
+\`\`\` <!-- zde taky, žádné zpětná lomítka, pouze ``` -->
+
+<!-- Text výše nepotřebuje odsazení a navíc GitHub použije zvýraznění označeného
+ jazyka. -->
+
+<!-- Horizontální čára (<hr />) -->
+<!-- Horizontální čára se jednoduše přidá pomocí 3 nebo více hvězdiček nebo pomlček
+s nebo bez mezer. -->
+
+***
+---
+- - -
+****************
+
+<!-- Odkazy -->
+<!-- Jedna z nejlepších věcí na Markdownu je, jak jednoduše se dělají odkazy.
+Dejte text, který chcete zobrazit, do [] následovaný url v závorkách () a je to. -->
+
+[Klikni na mě!](http://test.com/)
+
+<!-- Můžete také přidat jméno linku pomocí uvozovek -->
+
+[Klikni na mě!](http://test.com/ "Odkaz na Test.com")
+
+<!-- Relativní cesty fungují taky -->
+
+[Jdi na hudbu](/hudba/).
+
+<!-- Markdown taktéž podporuje reference odkazů. -->
+
+[Klikni na tento odkaz][link1] pro více informací!
+[Taky zkontrolujte tento odkaz][neco], když chcete.
+
+[link1]: http://test.com/ "Cool!"
+[neco]: http://neco.czz/ "Dobře!"
+
+<!-- Titulek může být v apostrofech nebo závorkách, nebo vyjmutý úplně. Reference
+ může být kdekoliv ve vašem dokumentu a identifikátor může být jakýkoliv, dokud
+ je unikátní.-->
+
+<!-- Také existuje "implicitní pojmenování", které použije text jako id -->
+
+[Toto][] je odkaz..
+
+[toto]: http://totojelink.cz/
+
+<!-- Ale toto není zrovna běžné užívané. -->
+
+<!-- Obrázky -->
+<!-- Obrázky se dělají stejně jako odkazy, ale s vykřičníkem na začátku -->
+
+![Toto je atribut alt pro obrázek](http://imgur.com/myimage.jpg "Nepovinný titulek")
+
+<!-- Reference fungují, jak bychom čekali-->
+
+![Toto je atribut alt][mujobrazek]
+
+[mujobrazek]: relativni/cesta/obrazek.jpg "a toto by byl titulek"
+
+<!-- Ostatní -->
+<!-- Automatické odkazy -->
+
+<http://stranka.cz/> je stejná jako
+[http://stranka.cz/](http://stranka.cz/)
+
+<!-- Automatické odkazy pro emaily-->
+
+<jmeno@prijmeni.cz>
+
+<!-- Escapování znaků -->
+
+Chci napsat *tento text obklopený hvězdičkami*, ale nechci aby to bylo kurzívou, tak udělám: \*tento text obklopený hvězdičkami\*.
+
+<!-- Klávesové zkratky -->
+<!-- V Markdownu od GitHubu, můžete použít tag <kbd> k reprezentování klaves na počítači -->
+
+Váš počítač přestal pracovat? Zkuste
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+
+<!-- Tabulky -->
+<!-- Tabulky jsou povolené pouze v Markdownu od GitHubu a jsou trochu podivně,
+     ale když je opravdu chcete: -->
+
+| Sloupec1     | Sloupec2 | Sloupec3      |
+| :----------- | :------: | ------------: |
+| Vlevo zarovn.| Na střed | Vpravo zarovn.|
+| blah         | blah     | blah          |
+
+<!-- nebo, to jde i taky: -->
+
+Sloupec 1 | Sloupec2 | Sloupec3
+:-- | :-: | --:
+Ohh toto je tak ošklivé | radši to | nedělejte
+
+<!-- Konec -->
+
+```
+
+Pro více informací, prozkoumejte oficiální článek o syntaxi od Johna Grubera
+ [zde](http://daringfireball.net/projects/markdown/syntax) a skvělý tahák od Adama Pritcharda [zde](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
new file mode 100644
index 00000000..581ed3a3
--- /dev/null
+++ b/cs-cz/python3.html.markdown
@@ -0,0 +1,636 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Tomáš Bedřich", "http://tbedrich.cz"]
+translators:
+    - ["Tomáš Bedřich", "http://tbedrich.cz"]
+filename: learnpython3-cz.py
+lang: cs-cz
+---
+
+Python byl vytvořen Guidem Van Rossum v raných 90. letech. Nyní je jedním z nejpopulárnějších jazyků.
+Zamiloval jsem si Python pro jeho syntaktickou čistotu - je to vlastně spustitelný pseudokód.
+
+Vaše zpětná vazba je vítána! Můžete mě zastihnout na [@louiedinh](http://twitter.com/louiedinh) nebo louiedinh [at] [email od googlu] anglicky,
+autora českého překladu pak na [@tbedrich](http://twitter.com/tbedrich) nebo ja [at] tbedrich.cz
+
+Poznámka: Tento článek je zaměřen na Python 3. Zde se můžete [naučit starší Python 2.7](http://learnxinyminutes.com/docs/python/).
+
+```python
+
+# Jednořádkový komentář začíná křížkem
+
+""" Víceřádkové komentáře používají tři uvozovky nebo apostrofy
+    a jsou často využívány jako dokumentační komentáře k metodám
+"""
+
+####################################################
+## 1. Primitivní datové typy a operátory
+####################################################
+
+# Čísla
+3  # => 3
+
+# Aritmetické operace se chovají běžným způsobem
+1 + 1   # =>  2
+8 - 1   # =>  7
+10 * 2  # => 20
+
+# Až na dělení, které vrací desetinné číslo
+35 / 5  # => 7.0
+
+# Při celočíselném dělení je desetinná část oříznuta (pro kladná i záporná čísla)
+5 // 3       # => 1
+5.0 // 3.0   # => 1.0  #  celočíselně dělit lze i desetinným číslem
+-5 // 3      # => -2
+-5.0 // 3.0  # => -2.0
+
+# Pokud použijete desetinné číslo, výsledek je jím také
+3 * 2.0  # => 6.0
+
+# Modulo
+7 % 3  # => 1
+
+# Mocnění (x na y-tou)
+2**4  # => 16
+
+# Pro vynucení priority použijte závorky
+(1 + 3) * 2  # => 8
+
+# Logické hodnoty
+True
+False
+
+# Negace se provádí pomocí not
+not True   # => False
+not False  # => True
+
+# Logické operátory
+# U operátorů záleží na velikosti písmen
+True and False  # => False
+False or True   # => True
+
+# Používání logických operátorů s čísly
+0 and 2     # => 0
+-5 or 0     # => -5
+0 == False  # => True
+2 == True   # => False
+1 == True   # => True
+
+# Rovnost je ==
+1 == 1  # => True
+2 == 1  # => False
+
+# Nerovnost je !=
+1 != 1  # => False
+2 != 1  # => True
+
+# Další porovnání
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# Porovnání se dají řetězit!
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+
+# Řetězce používají " nebo ' a mohou obsahovat UTF8 znaky
+"Toto je řetězec."
+'Toto je také řetězec.'
+
+# Řetězce se také dají sčítat, ale nepoužívejte to
+"Hello " + "world!"  # => "Hello world!"
+# Dají se spojovat i bez '+'
+"Hello " "world!"  # => "Hello world!"
+
+# Řetězec lze považovat za seznam znaků
+"Toto je řetězec"[0]  # => 'T'
+
+# .format lze použít ke skládání řetězců
+"{} mohou být {}".format("řetězce", "skládány")
+
+# Formátovací argumenty můžete opakovat
+"{0} {1} stříkaček stříkalo přes {0} {1} střech".format("tři sta třicet tři", "stříbrných")
+# => "tři sta třicet tři stříbrných stříkaček stříkalo přes tři sta třicet tři stříbrných střech"
+
+# Pokud nechcete počítat, můžete použít pojmenované argumenty
+"{jmeno} si dal {jidlo}".format(jmeno="Franta", jidlo="guláš")  # => "Franta si dal guláš"
+
+# Pokud zároveň potřebujete podporovat Python 2.5 a nižší, můžete použít starší způsob formátování
+"%s se dají %s jako v %s" % ("řetězce", "skládat", "jazyce C")
+
+
+# None je objekt (jinde NULL, nil, ...)
+None  # => None
+
+# Pokud porovnáváte něco s None, nepoužívejte operátor rovnosti "==",
+# použijte raději operátor "is", který testuje identitu.
+"něco" is None  # => False
+None is None    # => True
+
+# None, 0, a prázdný řetězec/seznam/slovník se vyhodnotí jako False
+# Vše ostatní se vyhodnotí jako True
+bool(0)   # => False
+bool("")  # => False
+bool([])  # => False
+bool({})  # => False
+
+
+####################################################
+## 2. Proměnné a kolekce
+####################################################
+
+# Python má funkci print
+print("Jsem 3. Python 3.")
+
+# Proměnné není třeba deklarovat před přiřazením
+# Konvence je používat male_pismo_s_podtrzitky
+nazev_promenne = 5
+nazev_promenne  # => 5
+# Názvy proměnných mohou obsahovat i UTF8 znaky
+název_proměnné = 5
+
+# Přístup k předtím nepoužité proměnné vyvolá výjimku
+# Odchytávání vyjímek - viz další kapitola
+neznama_promenna  # Vyhodí NameError
+
+# Seznam se používá pro ukládání sekvencí
+sez = []
+# Lze ho rovnou naplnit
+jiny_seznam = [4, 5, 6]
+
+# Na konec seznamu se přidává pomocí append
+sez.append(1)    # sez je nyní [1]
+sez.append(2)    # sez je nyní [1, 2]
+sez.append(4)    # sez je nyní [1, 2, 4]
+sez.append(3)    # sez je nyní [1, 2, 4, 3]
+# Z konce se odebírá se pomocí pop
+sez.pop()        # => 3 a sez je nyní [1, 2, 4]
+# Vložme trojku zpátky
+sez.append(3)    # sez je nyní znovu [1, 2, 4, 3]
+
+# Přístup k prvkům funguje jako v poli
+sez[0]  # => 1
+# Mínus počítá odzadu (-1 je poslední prvek)
+sez[-1]  # => 3
+
+# Přístup mimo seznam vyhodí IndexError
+sez[4]  # Vyhodí IndexError
+
+# Pomocí řezů lze ze seznamu vybírat různé intervaly
+# (pro matematiky: jedná se o uzavřený/otevřený interval)
+sez[1:3]  # => [2, 4]
+# Odříznutí začátku
+sez[2:]  # => [4, 3]
+# Odříznutí konce
+sez[:3]  # => [1, 2, 4]
+# Vybrání každého druhého prvku
+sez[::2]  # =>[1, 4]
+# Vrácení seznamu v opačném pořadí
+sez[::-1]  # => [3, 4, 2, 1]
+# Lze použít jakoukoliv kombinaci parametrů pro vytvoření složitějšího řezu
+# sez[zacatek:konec:krok]
+
+# Odebírat prvky ze seznamu lze pomocí del
+del sez[2]   # sez je nyní [1, 2, 3]
+
+# Seznamy můžete sčítat
+# Hodnoty sez a jiny_seznam přitom nejsou změněny
+sez + jiny_seznam   # => [1, 2, 3, 4, 5, 6]
+
+# Spojit seznamy lze pomocí extend
+sez.extend(jiny_seznam)   # sez je nyní [1, 2, 3, 4, 5, 6]
+
+# Kontrola, jestli prvek v seznamu existuje, se provádí pomocí in
+1 in sez  # => True
+
+# Délku seznamu lze zjistit pomocí len
+len(sez)  # => 6
+
+
+# N-tice je jako seznam, ale je neměnná
+ntice = (1, 2, 3)
+ntice[0]      # => 1
+ntice[0] = 3  # Vyhodí TypeError
+
+# S n-ticemi lze dělat většinu operací, jako se seznamy
+len(ntice)         # => 3
+ntice + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+ntice[:2]          # => (1, 2)
+2 in ntice         # => True
+
+# N-tice (nebo seznamy) lze rozbalit do proměnných jedním přiřazením
+a, b, c = (1, 2, 3)  # a je nyní 1, b je nyní 2 a c je nyní 3
+# N-tice jsou vytvářeny automaticky, když vynecháte závorky
+d, e, f = 4, 5, 6
+# Prohození proměnných je tak velmi snadné
+e, d = d, e  # d je nyní 5, e je nyní 4
+
+
+# Slovníky ukládají klíče a hodnoty
+prazdny_slovnik = {}
+# Lze je také rovnou naplnit
+slovnik = {"jedna": 1, "dva": 2, "tři": 3}
+
+# Přistupovat k hodnotám lze pomocí []
+slovnik["jedna"]  # => 1
+
+# Všechny klíče dostaneme pomocí keys() jako iterovatelný objekt. Nyní ještě
+# potřebujeme obalit volání v list(), abychom dostali seznam. To rozebereme
+# později. Pozor, že jakékoliv pořadí klíčů není garantováno - může být různé.
+list(slovnik.keys())  # => ["dva", "jedna", "tři"]
+
+# Všechny hodnoty opět jako iterovatelný objekt získáme pomocí values(). Opět
+# tedy potřebujeme použít list(), abychom dostali seznam. Stejně jako
+# v předchozím případě, pořadí není garantováno a může být různé
+list(slovnik.values())  # => [3, 2, 1]
+
+# Operátorem in se lze dotázat na přítomnost klíče
+"jedna" in slovnik  # => True
+1 in slovnik        # => False
+
+# Přístup k neexistujícímu klíči vyhodí KeyError
+slovnik["čtyři"]  # Vyhodí KeyError
+
+# Metoda get() funguje podobně jako [], ale vrátí None místo vyhození KeyError
+slovnik.get("jedna")   # => 1
+slovnik.get("čtyři")   # => None
+# Metodě get() lze předat i výchozí hodnotu místo None
+slovnik.get("jedna", 4)   # => 1
+slovnik.get("čtyři", 4)   # => 4
+
+# metoda setdefault() vloží prvek do slovníku pouze pokud tam takový klíč není
+slovnik.setdefault("pět", 5)  # slovnik["pět"] je nastaven na 5
+slovnik.setdefault("pět", 6)  # slovnik["pět"] je pořád 5
+
+# Přidání nové hodnoty do slovníku
+slovnik["čtyři"] = 4
+# Hromadně aktualizovat nebo přidat data lze pomocí update(), parametrem je opět slovník
+slovnik.update({"čtyři": 4})  # slovnik je nyní {"jedna": 1, "dva": 2, "tři": 3, "čtyři": 4, "pět": 5}
+
+# Odebírat ze slovníku dle klíče lze pomocí del
+del slovnik["jedna"]  # odebere klíč "jedna" ze slovnik
+
+
+# Množiny ukládají ... překvapivě množiny
+prazdna_mnozina = set()
+# Také je lze rovnou naplnit. A ano, budou se vám plést se slovníky. Bohužel.
+mnozina = {1, 1, 2, 2, 3, 4}  # mnozina je nyní {1, 2, 3, 4}
+
+# Přidání položky do množiny
+mnozina.add(5)  # mnozina je nyní {1, 2, 3, 4, 5}
+
+# Průnik lze udělat pomocí operátoru &
+jina_mnozina = {3, 4, 5, 6}
+mnozina & jina_mnozina  # => {3, 4, 5}
+
+# Sjednocení pomocí operátoru |
+mnozina | jina_mnozina  # => {1, 2, 3, 4, 5, 6}
+
+# Rozdíl pomocí operátoru -
+{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
+
+# Operátorem in se lze dotázat na přítomnost prvku v množině
+2 in mnozina  # => True
+9 in mnozina  # => False
+
+
+####################################################
+## 3. Řízení toku programu, cykly
+####################################################
+
+# Vytvořme si proměnnou
+promenna = 5
+
+# Takto vypadá podmínka. Na odsazení v Pythonu záleží!
+# Vypíše "proměnná je menší než 10".
+if promenna > 10:
+    print("proměnná je velká jak Rusko")
+elif promenna < 10:  # Část elif je nepovinná
+    print("proměnná je menší než 10")
+else:                # Část else je také nepovinná
+    print("proměnná je právě 10")
+
+
+"""
+Smyčka for umí iterovat (nejen) přes seznamy
+vypíše:
+    pes je savec
+    kočka je savec
+    myš je savec
+"""
+for zvire in ["pes", "kočka", "myš"]:
+    # Můžete použít formát pro složení řetězce
+    print("{} je savec".format(zvire))
+
+"""
+range(cislo) vrací iterovatelný objekt čísel od 0 do cislo
+vypíše:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+range(spodni_limit, horni_limit) vrací iterovatelný objekt čísel mezi limity
+vypíše:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+Smyčka while se opakuje, dokud je podmínka splněna.
+vypíše:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Zkrácený zápis x = x + 1. Pozor, žádné x++ neexisuje.
+
+
+# Výjimky lze ošetřit pomocí bloku try/except(/else/finally)
+try:
+    # Pro vyhození výjimky použijte raise
+    raise IndexError("Přistoupil jste k neexistujícímu prvku v seznamu.")
+except IndexError as e:
+    print("Nastala chyba: {}".format(e))
+    # Vypíše: Nastala chyba: Přistoupil jste k neexistujícímu prvku v seznamu.
+except (TypeError, NameError):  # Více výjimek lze zachytit najednou
+    pass  # Pass znamená nedělej nic - nepříliš vhodný způsob ošetření chyb
+else:  # Volitelný blok else musí být až za bloky except
+    print("OK!")  # Vypíše OK! v případě, že nenastala žádná výjimka
+finally:  # Blok finally se spustí nakonec za všech okolností
+    print("Uvolníme zdroje, uzavřeme soubory...")
+
+# Místo try/finally lze použít with pro automatické uvolnění zdrojů
+with open("soubor.txt") as soubor:
+    for radka in soubor:
+        print(radka)
+
+# Python běžně používá iterovatelné objekty, což je prakticky cokoliv,
+# co lze považovat za sekvenci. Například to, co vrací metoda range(),
+# nebo otevřený soubor, jsou iterovatelné objekty.
+
+slovnik = {"jedna": 1, "dva": 2, "tři": 3}
+iterovatelny_objekt = slovnik.keys()
+print(iterovatelny_objekt)  # => dict_keys(["jedna", "dva", "tři"]). Toto je iterovatelný objekt.
+
+# Můžeme použít cyklus for na jeho projití
+for klic in iterovatelny_objekt:
+    print(klic)    # vypíše postupně: jedna, dva, tři
+
+# Ale nelze přistupovat k prvkům pod jejich indexem
+iterovatelny_objekt[1]  # Vyhodí TypeError
+
+# Všechny položky iterovatelného objektu lze získat jako seznam pomocí list()
+list(slovnik.keys())  # => ["jedna", "dva", "tři"]
+
+# Z iterovatelného objektu lze vytvořit iterátor
+iterator = iter(iterovatelny_objekt)
+
+# Iterátor je objekt, který si pamatuje stav v rámci svého iterovatelného objektu
+# Další hodnotu dostaneme voláním next()
+next(iterator)  # => "jedna"
+
+# Iterátor si udržuje svůj stav v mezi jednotlivými voláními next()
+next(iterator)  # => "dva"
+next(iterator)  # => "tři"
+
+# Jakmile interátor vrátí všechna svá data, vyhodí výjimku StopIteration
+next(iterator)  # Vyhodí StopIteration
+
+
+####################################################
+## 4. Funkce
+####################################################
+
+# Pro vytvoření nové funkce použijte klíčové slovo def
+def secist(x, y):
+    print("x je {} a y je {}".format(x, y))
+    return x + y  # Hodnoty se vrací pomocí return
+
+# Volání funkce s parametry
+secist(5, 6)  # => Vypíše "x je 5 a y je 6" a vrátí 11
+
+# Jiný způsob, jak volat funkci, je použít pojmenované argumenty
+secist(y=6, x=5)  # Pojmenované argumenty můžete předat v libovolném pořadí
+
+# Lze definovat funkce s proměnným počtem (pozičních) argumentů
+def vrat_argumenty(*argumenty):
+    return argumenty
+
+vrat_argumenty(1, 2, 3)  # => (1, 2, 3)
+
+# Lze definovat také funkce s proměnným počtem pojmenovaných argumentů
+def vrat_pojmenovane_argumenty(**pojmenovane_argumenty):
+    return pojmenovane_argumenty
+
+vrat_pojmenovane_argumenty(kdo="se bojí", nesmi="do lesa")
+# => {"kdo": "se bojí", "nesmi": "do lesa"}
+
+
+# Pokud chcete, lze použít obojí najednou
+# Konvence je používat pro tyto účely názvy *args a **kwargs
+def vypis_vse(*args, **kwargs):
+    print(args, kwargs)  # print() vypíše všechny své parametry oddělené mezerou
+
+vypis_vse(1, 2, a=3, b=4)  # Vypíše: (1, 2) {"a": 3, "b": 4}
+
+# * nebo ** lze použít k rozbalení N-tic nebo slovníků!
+ntice = (1, 2, 3, 4)
+slovnik = {"a": 3, "b": 4}
+vypis_vse(ntice)  # Vyhodnotí se jako vypis_vse((1, 2, 3, 4)) – jeden parametr, N-tice
+vypis_vse(*ntice)  # Vyhodnotí se jako vypis_vse(1, 2, 3, 4)
+vypis_vse(**slovnik)  # Vyhodnotí se jako vypis_vse(a=3, b=4)
+vypis_vse(*ntice, **slovnik)  # Vyhodnotí se jako vypis_vse(1, 2, 3, 4, a=3, b=4)
+
+
+# Viditelnost proměnných - vytvořme si globální proměnnou x
+x = 5
+
+def nastavX(cislo):
+    # Lokální proměnná x překryje globální x
+    x = cislo  # => 43
+    print(x)  # => 43
+
+def nastavGlobalniX(cislo):
+    global x
+    print(x)  # => 5
+    x = cislo  # Nastaví globální proměnnou x na 6
+    print(x)  # => 6
+
+nastavX(43)
+nastavGlobalniX(6)
+
+
+# Funkce jsou first-class objekty
+def vyrobit_scitacku(pricitane_cislo):
+    def scitacka(x):
+        return x + pricitane_cislo
+    return scitacka
+
+pricist_10 = vyrobit_scitacku(10)
+pricist_10(3)  # => 13
+
+# Klíčové slovo lambda vytvoří anonymní funkci
+(lambda parametr: parametr > 2)(3)  # => True
+
+# Lze použít funkce map() a filter() z funkcionálního programování
+map(pricist_10, [1, 2, 3])
+# => <map object at 0x0123467> - iterovatelný objekt s obsahem: [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])
+# => <filter object at 0x0123467> - iterovatelný objekt s obsahem: [6, 7]
+
+# S generátorovou notací lze dosáhnout podobných výsledků, ale vrací seznam
+[pricist_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]
+# Generátorová notace funguje i pro slovníky
+{x: x**2 for x in range(1, 5)}  # => {1: 1, 2: 4, 3: 9, 4: 16}
+# A také pro množiny
+{pismeno for pismeno in "abeceda"}  # => {"d", "a", "c", "e", "b"}
+
+
+####################################################
+## 5. Třídy
+####################################################
+
+# Třída Clovek je potomkem (dědí od) třídy object
+class Clovek(object):
+
+    # Atribut třídy - je sdílený všemi instancemi
+    druh = "H. sapiens"
+
+    # Toto je kostruktor. Je volán, když vytváříme instanci třídy. Dvě
+    # podtržítka na začátku a na konci značí, že se jedná o atribut nebo
+    # objekt využívaný Pythonem ke speciálním účelům, ale můžete sami
+    # definovat jeho chování. Metody jako __init__, __str__, __repr__
+    # a další se nazývají "magické metody". Nikdy nepoužívejte toto
+    # speciální pojmenování pro běžné metody.
+    def __init__(self, jmeno):
+        # Přiřazení parametru do atributu instance jmeno
+        self.jmeno = jmeno
+
+    # Metoda instance - všechny metody instance mají "self" jako první parametr
+    def rekni(self, hlaska):
+        return "{jmeno}: {hlaska}".format(jmeno=self.jmeno, hlaska=hlaska)
+
+    # Metoda třídy - sdílená všemi instancemi
+    # Dostává jako první parametr třídu, na které je volána
+    @classmethod
+    def vrat_druh(cls):
+        return cls.druh
+
+    # Statická metoda je volána bez reference na třídu nebo instanci
+    @staticmethod
+    def odkaslej_si():
+        return "*ehm*"
+
+
+# Vytvoření instance
+d = Clovek(jmeno="David")
+a = Clovek("Adéla")
+print(d.rekni("ahoj"))    # Vypíše: "David: ahoj"
+print(a.rekni("nazdar"))  # Vypíše: "Adéla: nazdar"
+
+# Volání třídní metody
+d.vrat_druh()  # => "H. sapiens"
+
+# Změna atributu třídy
+Clovek.druh = "H. neanderthalensis"
+d.vrat_druh()  # => "H. neanderthalensis"
+a.vrat_druh()  # => "H. neanderthalensis"
+
+# Volání statické metody
+Clovek.odkaslej_si()  # => "*ehm*"
+
+
+####################################################
+## 6. Moduly
+####################################################
+
+# Lze importovat moduly
+import math
+print(math.sqrt(16.0))  # => 4
+
+# Lze také importovat pouze vybrané funkce z modulu
+from math import ceil, floor
+print(ceil(3.7))   # => 4.0
+print(floor(3.7))  # => 3.0
+
+# Můžete také importovat všechny funkce z modulu, ale radši to nedělejte
+from math import *
+
+# Můžete si přejmenovat modul při jeho importu
+import math as m
+math.sqrt(16) == m.sqrt(16)  # => True
+
+# Modul v Pythonu není nic jiného, než obyčejný soubor .py
+# Můžete si napsat vlastní a prostě ho importovat podle jména
+from muj_modul import moje_funkce  # Nyní vyhodí ImportError - muj_modul neexistuje
+
+# Funkcí dir() lze zjistit, co modul obsahuje
+import math
+dir(math)
+
+
+####################################################
+## 7. Pokročilé
+####################################################
+
+# Generátory jsou funkce, které místo return obsahují yield
+def nasobicka_2(sekvence):
+    for i in sekvence:
+        yield 2 * i
+
+# Generátor generuje hodnoty postupně, jak jsou potřeba. Místo toho, aby vrátil
+# celou sekvenci s prvky vynásobenými dvěma, provádí jeden výpočet v každé iteraci.
+# To znamená, že čísla větší než 15 se v metodě nasobicka_2 vůbec nezpracují.
+
+# Funkce range() je také generátor - vytváření seznamu 900000000 prvků by zabralo
+# hodně času i paměti, proto se místo toho čísla generují postupně.
+
+for i in nasobicka_2(range(900000000)):
+    print(i)  # Vypíše čísla 0, 2, 4, 6, 8, ... 30
+    if i >= 30:
+        break
+
+
+# Dekorátory jsou funkce, které se používají pro obalení jiné funkce, čímž mohou
+# přidávat nebo měnit její stávající chování. Funkci dostávají jako parametr
+# a typicky místo ní vrací jinou, která uvnitř volá tu původní.
+
+def nekolikrat(puvodni_funkce):
+    def opakovaci_funkce(*args, **kwargs):
+        for i in range(3):
+            puvodni_funkce(*args, **kwargs)
+
+    return opakovaci_funkce
+
+
+@nekolikrat
+def pozdrav(jmeno):
+    print("Měj se {}!".format(jmeno))
+
+pozdrav("Pepo")  # Vypíše 3x: Měj se Pepo!
+```
+
+## Co dál?
+
+Spoustu odkazů na české i anglické materiály najdete na [webu české Python komunity]
+(http://python.cz/). Můžete také přijít na Pyvo, kde to společně probereme.
diff --git a/cs-cz/sass.html.markdown b/cs-cz/sass.html.markdown
new file mode 100644
index 00000000..0d2fca64
--- /dev/null
+++ b/cs-cz/sass.html.markdown
@@ -0,0 +1,439 @@
+---
+language: sass
+filename: learnsass-cz.scss
+contributors:
+  - ["Laura Kyle", "https://github.com/LauraNK"]
+  - ["Sean Corrales", "https://github.com/droidenator"]
+translators:
+  - ["Michal Martinek", "https://github.com/MichalMartinek"]
+lang: cs-cz
+---
+
+Sass je rozšíření jazyka CSS, který přidává nové vlastnosti jako proměnné, zanořování, mixiny a další.
+Sass (a další preprocesory, jako  [Less](http://lesscss.org/)) pomáhají vývojářům psát udržovatelný a neopakující (DRY) kód.
+
+Sass nabízí dvě možnosti syntaxe. SCSS, které je stejná jako CSS, akorát obsahuje nové vlastnosti Sassu. Nebo Sass, který používá odsazení místo složených závorek a středníků.
+Tento tutoriál bude používat syntaxi CSS.
+
+
+Pokud jste již obeznámeni s CSS3, budete schopni používat Sass relativně rychle. Nezprostředkovává nějaké úplně nové stylové možnosti, spíše nátroje, jak psát Vás CSS kód více efektivně, udržitelně a jednoduše.
+
+```scss
+
+
+//Jednořádkové komentáře jsou ze Sassu při kompilaci vymazány
+
+/*Víceřádkové komentáře jsou naopak zachovány */
+
+
+
+/*Proměnné
+==============================*/
+
+
+
+/* Můžete uložit CSS hodnotu (jako třeba barvu) do proměnné.
+Použijte symbol '$' k jejímu vytvoření. */
+
+$hlavni-barva: #A3A4FF;
+$sekundarni-barva: #51527F;
+$body-font: 'Roboto', sans-serif;
+
+/* Můžete používat proměnné napříč vaším souborem.
+Teď, když chcete změnit barvu, stačí ji změnit pouze jednou.*/
+
+body {
+	background-color: $hlavni-barva;
+	color: $sekundarni-barva;
+	font-family: $body-font;
+}
+
+/* Toto se zkompiluje do: */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+
+/* Toto je o hodně více praktické, než měnit každý výskyt barvy.  */
+
+
+
+/*Mixiny
+==============================*/
+
+
+
+/* Pokud zjistíte, že píšete kód pro více než jeden element, můžete jej uložit do mixinu.
+
+Použijte '@mixin' direktivu, plus jméno vašeho mixinu.*/
+
+@mixin na-stred {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* Mixin vložíte pomocí '@include' a jména mixinu */
+
+div {
+	@include na-stred;
+	background-color: $hlavni-barva;
+}
+
+/*Což se zkompiluje do: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+
+/* Můžete využít mixiny i třeba pro takovéto ušetření práce: */
+
+@mixin velikost($sirka, $vyska) {
+	width: $sirka;
+	height: $vyska;
+}
+
+/*Stačí vložit argumenty: */
+
+.obdelnik {
+	@include velikost(100px, 60px);
+}
+
+.ctverec {
+	@include velikost(40px, 40px);
+}
+
+/* Toto se zkompiluje do: */
+.obdelnik {
+  width: 100px;
+  height: 60px;
+}
+
+.ctverec {
+  width: 40px;
+  height: 40px;
+}
+
+
+
+/*Funkce
+==============================*/   
+
+
+
+/* Sass obsahuje funkce, které vám pomůžou splnit různé úkoly. */
+
+/* Funkce se spouštějí pomocí jejich jména, které následuje seznam argumentů uzavřený v kulatých závorkách. */
+body {
+  width: round(10.25px);    
+}
+
+.footer {
+  background-color: fade_out(#000000, 0.25)
+}
+
+/* Se zkompiluje do: */
+
+body {
+  width: 10px;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}   
+
+/* Můžete také definovat vlastní funkce. Funkce jsou velmi podobné mixinům.
+   Když se snažíte vybrat mezi funkcí a mixinem, mějte na paměti, že mixiny
+   jsou lepší pro generování CSS kódu, zatímco funkce jsou lepší pro logiku.
+   Příklady ze sekce Matematické operátory jsou skvělí kandidáti na
+   znovupoužitelné funkce. */
+
+/* Tato funkce vrací poměr k velikosti rodiče v procentech.
+@function vypocitat-pomer($velikost, $velikost-rodice) {
+  @return $velikost / $velikost-rodice * 100%;
+}
+
+$hlavni obsah: vypocitat-pomer(600px, 960px);
+
+.hlavni-obsah {
+  width: $hlavni-obsah;
+}
+
+.sloupec {
+  width: vypocitat-pomer(300px, 960px);
+}
+
+/* Zkompiluje do: */
+
+.hlavni-obsah {
+  width: 62.5%;
+}
+
+.sloupec {
+  width: 31.25%;
+}
+
+
+
+/*Dědění
+==============================*/
+
+
+
+/*Dědění je způsob jak používat vlastnosti pro jeden selektor ve druhém. */
+
+.oznameni {
+	@include velikost(5em, 5em);
+	border: 5px solid $sekundarni-barva;
+}
+
+.oznameni-uspech {
+	@extend .oznameni;
+	border-color: #22df56;
+}
+
+/* Zkompiluje do: */
+.oznameni, .oznameni-uspech {
+  width: 5em;
+  height: 5em;
+  border: 5px solid #51527F;
+}
+
+.oznameni-uspech {
+  border-color: #22df56;
+}
+
+
+/* Dědění CSS výrazů je preferováno před vytvořením mixinu kvůli způsobu,
+   jakým způsobem Sass dává dohromady třídy, které sdílejí stejný kód.
+   Kdyby to bylo udělané pomocí mixinu, tak výška, šířka, rámeček by byl v
+   každém výrazu, který by volal mixin. I když tohle neovlivní vaše workflow,
+   přidá to kód navíc do souborů. */
+
+
+/*Zanořování
+==============================*/
+
+
+
+/*Sass vám umožňuje zanořovat selektory do selektorů */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #FF0000;
+	}
+}
+
+/* '&' nahradí rodičovský element. */
+/* Můžete také zanořovat pseudo třídy. */
+/* Pamatujte, že moc velké zanoření do hloubky snižuje čitelnost.
+   Doporučuje se používat maximálně trojité zanoření.
+   Na příklad: */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: red;
+
+		&:hover {
+		  background-color: blue;
+		}
+
+		a {
+		  color: white;
+		}
+	}
+}
+
+/* Zkompiluje do: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/*Částečné soubory a importy
+==============================*/   
+
+
+
+/* Sass umožňuje vytvářet částečné soubory. Tyto soubory pomahájí udržovat váš
+   kód modulární. Tyto soubory by měli začínat vždy '_', např. _reset.css.
+   Částečné soubory se nepřevádí do CSS. */
+
+/* Toto je kód, který si uložíme do souboru _reset.css */
+
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+
+/* Sass obsahuje @import, které může být použit pro import částečných souborů.
+   Toto se liší od klasického CSS @import, který dělá HTTP požadavek na stáhnutí
+   souboru. Sass vezme importovaný soubor a vloží ho do kompilovaného kódu. */
+
+@import 'reset';
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Zkompiluje do: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}   
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/*Zástupné selektory
+==============================*/  
+
+
+
+/* Zástupné selektory jsou užitečné, když vytváříte CSS výraz, ze kterého
+   chcete později dědit. Když chcete vytvořit výraz, ze kterého je možné pouze
+   dědit pomocí @extend, vytvořte zástupný selektor s CSS výrazem. Ten začíná
+   symbolem '%' místo '.' nebo '#'. Tyto výrazy se neobjeví ve výsledném CSS */
+
+%okno-obsahu {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.okno-zpravy {
+  @extend %okno-obsahu;
+  background-color: #0000ff;
+}
+
+/* Zkompiluje do: */
+
+.okno-zpravy {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.okno-zpravy {
+  background-color: #0000ff;
+}
+
+
+
+/*Matematické operace
+==============================*/   
+
+
+
+/* Sass obsahuje následující operátory: +, -, *, /, and %. Tyto operátory
+   můžou být velmi užitečné pro počítání hodnot přímo ve vašem souboru Sass.
+   Níže je příklad, jak udělat jednoduchý dvousloupcový layout. */
+
+$oblast-obsahu: 960px;
+$hlavni-obsah: 600px;
+$vedlejsi-sloupec: 300px;
+
+$obsah-velikost: $hlavni-obsah / $oblast-obsahu * 100%;
+$vedlejsi-sloupec-velikost: $vedlejsi-sloupec / $oblast-obsahu * 100%;
+$zbytek-velikost: 100% - ($main-size + $vedlejsi-sloupec-size);
+
+body {
+  width: 100%;
+}
+
+.hlavni-obsah {
+  width: $obsah-velikost;
+}
+
+.vedlejsi-sloupec {
+  width: $vedlejsi-sloupec-velikost;
+}
+
+.zbytek {
+  width: $zbytek-velikost;
+}
+
+/* Zkompiluje do: */
+
+body {
+  width: 100%;
+}
+
+.hlavni-obsah {
+  width: 62.5%;
+}
+
+.vedlejsi-sloupec {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+
+```
+
+
+
+## SASS nebo Sass?
+Divili jste se někdy, jestli je Sass zkratka nebo ne? Pravděpodobně ne, ale řeknu vám to stejně. Jméno tohoto jazyka je slovo, "Sass", a ne zkratka.
+Protože to lidé konstatně píší jako "SASS", nazval ho autor jazyka jako "Syntactically Awesome StyleSheets" (Syntaktický úžasně styly).
+
+
+## Procvičování Sassu
+Pokud si chcete hrát se Sassem ve vašem prohlížeči, navštivte [SassMeister](http://sassmeister.com/).
+Můžete používát oba dva způsoby zápisu, stačí si vybrat v nastavení SCSS nebo SASS.
+
+
+## Kompatibilita
+
+Sass může být použit v jakémkoliv projektu, jakmile máte program, pomocí kterého ho zkompilujete do CSS. Pokud si chcete ověřit, že CSS, které Sass produkuje je kompatibilní s prohlížeči:
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) a [CanIUse](http://caniuse.com) jsou skvělé stránky pro kontrolu kompatibility.
+
+
+## Kam dál?
+* [Oficiální dokumentace](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
+* [The Sass Way](http://thesassway.com/) obsahuje tutoriál a řadu skvělých článků