Merge remote-tracking branch 'adambard/master'

5 files changed, 767 insertions, 2 deletions

diff --git a/pl-pl/brainfuck-pl.html.markdown b/pl-pl/bf-pl.html.markdown
index 69d814c4..801f1a9a 100644
--- a/pl-pl/brainfuck-pl.html.markdown
+++ b/pl-pl/bf-pl.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
new file mode 100644
index 00000000..3a51ade5
--- /dev/null
+++ b/pl-pl/haskell-pl.html.markdown
@@ -0,0 +1,444 @@
+---
+language: Haskell
+lang: pl-pl
+contributors:
+    - ["Remigiusz Suwalski", "https://github.com/remigiusz-suwalski"]
+---
+
+Haskell został zaprojektowany jako praktyczny, czysto funkcyjny język 
+programowania. Jest znany przede wszystkim ze względu na jego monady oraz system
+typów, ale ja lubię do niego wracać przez jego elegancję. Sprawił on, że 
+programowanie jest prawdziwą przyjemnością.
+
+```haskell
+-- Komentarze jednolinijkowe zaczynają się od dwóch myślników
+{- Komentarze wielolinijkowe należy 
+zamykać w bloki klamrami.
+-}
+
+----------------------------------------------------
+-- 1. Podstawowe typy danych oraz operatory
+----------------------------------------------------
+
+-- Mamy liczby
+3 -- 3
+
+-- Podstawowe działania działają tak, jak powinny
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- dzielenie domyślnie zwraca ,,dokładny'' wynik
+35 / 4 -- 8.75
+
+-- dzielenie całkowitoliczbowe
+35 `div` 4 -- 8
+
+-- wartości logiczne także są podstawowym typem danych:
+True
+False
+
+-- operacje logiczne: negacja oraz porównania
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- W powyższych przykładach, `not` jest funkcją przyjmującą jeden argument.
+-- Haskell nie potrzebuje nawiasów, by wywołać funkcję: argumenty są po prostu
+-- wypisywane jeden za drugim. Ogólnie wygląda to tak:
+-- funkcja arg1 arg2 arg3...
+-- Sekcja poświęcona funkcjom zawiera informacje, jak stworzyć własne.
+
+-- Łańcuchy znaków (stringi) i pojedyncze znaki:
+"To jest lancuch."
+'a' -- znak
+'Nie mozna laczyc apostrofow z lancuchami.' -- błąd!
+
+-- Łańcuchy można sklejać
+"Hello " ++ "world!" -- "Hello world!"
+
+-- Łańcuch jest listą własnych znaków
+['H', 'e', 'l', 'l', 'o'] -- "Hello"
+"To jest lancuch" !! 0 -- 'T'
+
+----------------------------------------------------
+-- 2. Listy oraz krotki
+----------------------------------------------------
+
+-- Wszystkie elementy listy muszą być tego samego typu.
+-- Poniższe dwie listy są identyczne:
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- Zakresy są uniwersalne.
+['A'..'F'] -- "ABCDEF"
+
+-- Przy tworzeniu zakresów można określić krok.
+[0,2..10] -- [0, 2, 4, 6, 8, 10]
+[5..1] -- To nie zadziała, gdyż w Haskellu zakresy tworzone są domyślnie rosnąco
+[5,4..1] -- [5, 4, 3, 2, 1]
+
+-- indeksowanie listy od zera
+[1..10] !! 3 -- 4
+
+-- Można nawet tworzyć listy nieskończone!
+[1..] -- lista wszystkich liczb naturalnych
+
+-- Nieskończone listy mają prawo działać, ponieważ Haskell cechuje się leniwym 
+-- wartościowaniem. To oznacza, że obliczane są jedynie te elementy listy, 
+-- których istotnie potrzebujemy. Możemy poprosić o tysiączny element i 
+-- dostaniemy go:
+
+[1..] !! 999 -- 1000
+
+-- Haskell wyznaczył pierwsze tysiąc elementów listy, ale cała jej reszta 
+-- jeszcze nie istnieje! Nie zostanie obliczona ich wartość, póki nie zajdzie
+-- taka potrzeba.
+
+-- łączenie dwóch list
+[1..5] ++ [6..10]
+
+-- dodawanie pojedynczego elementu na początek listy
+0:[1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- więcej operacji na listach
+head [1..5] -- 1
+tail [1..5] -- [2, 3, 4, 5]
+init [1..5] -- [1, 2, 3, 4]
+last [1..5] -- 5
+
+-- list comprehensions
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+-- z dodatkowym warunkiem
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- każdy element krotki może być innego typu, jednak sama krotka musi być stałej 
+-- długości. Przykładowo:
+("haskell", 1)
+
+-- dostęp do elementów pary (krotki długości 2):
+fst ("haskell", 1) -- "haskell"
+snd ("haskell", 1) -- 1
+
+----------------------------------------------------
+-- 3. Funkcje
+----------------------------------------------------
+-- Prosta funkcja przyjmująca dwa argumenty
+add a b = a + b
+
+-- Pamiętaj, że podczas stosowania ghci, interpretera Haskella, wszelkie 
+-- definicje muszą zostać poprzedzone słowem `let`, na przykład:
+-- let add a b = a + b
+
+-- Używanie funkcji:
+add 1 2 -- 3
+
+-- Nazwę funkcji można podać między dwoma argumentami, ale wtedy musi zostać
+-- otoczona grawisami:
+1 `add` 2 -- 3
+
+-- Nazwa funkcji nie musi zawierać żadnych liter, przykładem czego jest 
+-- operator dzielenia:
+(//) a b = a `div` b
+35 // 4 -- 8
+
+-- Strażnicy: prosty sposób na rozbijanie funkcji na przypadki
+fib x
+  | x < 2 = 1
+  | otherwise = fib (x - 1) + fib (x - 2)
+
+-- Dopasowanie wzorca jest podobne. Haskell sam automatycznie wybierze, która
+-- z poniższych definicji fib powinna zostać użyta:
+fib 1 = 1
+fib 2 = 2
+fib x = fib (x - 1) + fib (x - 2)
+
+-- Dopasowanie z krotkami:
+foo (x, y) = (x + 1, y + 2)
+
+-- Dopasowanie z listami. Tutaj `x` jest pierwszym elementem listy, 
+-- natomiast `xs` to jej reszta (ogon). Poniższa funkcja nakłada funkcję
+-- na każdy z elementów listy:
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
+
+-- Funkcje anonimowe tworzone są przy użyciu w-tył-ciachu, po którym następują
+-- wszystkie argumenty:
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+
+-- używanie zwijania z anonimowymi funkcjami: foldl1 zwija z lewej strony,
+-- przyjmując jako wartość początkową zbieracza pierwszy element listy.
+foldl1 (\acc x -> acc + x) [1..5] -- 15
+
+----------------------------------------------------
+-- 4. Więcej funkcji
+----------------------------------------------------
+
+-- częściowe nakładanie: jeśli funkcja nie otrzyma wszystkich swoich argumentów, 
+-- zostaje cześciowo nałożona - zwraca funkcję, która przyjmuje pozostałe,
+-- brakujące argumenty.
+
+add a b = a + b
+foo = add 10 -- foo jest teraz funkcją, która przyjmuje liczbę, zwiększa ją o 10
+foo 5 -- 15
+
+-- Inny sposób na zapisanie tego samego:
+foo = (10+)
+foo 5 -- 15
+
+-- składanie funkcji:
+-- operator `.` składa wiele funkcji w jedną.
+-- Dla przykładu, foo jest funkcją, która powiększa swój argument o 10, mnoży 
+-- tak uzyskaną liczbę przez 4 i zwraca wynik:
+foo = (4*) . (10+)
+
+-- 4*(10 + 5) = 60
+foo 5 -- 60
+
+-- ustalanie kolejności
+-- Haskell posiada inny operator, `$`, który nakłada funkcję do podanego
+-- parametru. W przeciwieństwie do zwykłego lewostronnie łącznego nakładania 
+-- funkcji, którego priorytet jest najwyższy (10), operator `$` posiada
+-- priorytet 0 i jest prawostronnie łączny. Tak niski priorytet oznacza, że
+-- wyrażenie po prawej traktowane jest jako parametr funkcji po lewej
+
+-- wcześniej
+even (fib 7) -- fałsz
+
+-- równoważnie
+even $ fib 7 -- fałsz
+
+-- składanie funkcji
+even . fib $ 7 -- fałsz
+
+
+----------------------------------------------------
+-- 5. Sygnatury typów
+----------------------------------------------------
+
+-- Haskell posiada wyjątkowo silny system typów, w którym każde poprawne 
+-- wyrażenie ma swój typ.
+
+-- Kilka podstawowych typów:
+5 :: Integer
+"hello" :: String
+True :: Bool
+
+-- Funkcje też są określonego typu.
+-- `not` przyjmuje wartość logiczną i taką też zwraca:
+-- not :: Bool -> Bool
+
+-- Przykład funkcji przyjmującej dwa argumenty
+-- add :: Integer -> Integer -> Integer
+
+-- Dobrą praktyką podczas definiowania wartości jest napisanie nad nią
+-- także jej typu:
+double :: Integer -> Integer
+double x = x * 2
+
+----------------------------------------------------
+-- 6. Wyrażenia warunkowe
+----------------------------------------------------
+
+-- wyrażenie warunkowe
+haskell = if 1 == 1 then "wspaniale" else "paskudnie" -- haskell = "wspaniale"
+
+-- wyrażenie warunkowe można rozbić na wiele linii, 
+-- ale trzeba uważać na wcięcia w kodzie
+haskell = if 1 == 1
+            then "wspaniale"
+            else "paskudnie"
+
+-- rozpatrywanie przypadków: oto jak można parsować argumenty z linii poleceń:
+case args of
+  "help" -> printHelp
+  "start" -> startProgram
+  _ -> putStrLn "bad args"
+
+-- Haskell zastępuje pętle (których nie ma) rekurencyjnymi wywołaniami funkcji.
+-- map aplikuje funkcję do każdego elementu listy:
+
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+-- możesz zdefiniować funkcję for przy użyciu map:
+for array func = map func array
+
+-- a następnie użyć jej:
+for [0..5] $ \i -> show i
+
+-- mogliśmy użyć krótszego zapisu bez zmiany działania funkcji for:
+for [0..5] show
+
+-- Do redukcji listy służy polecenie foldl (foldr):
+-- foldl <fn> <initial value> <list>
+foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
+
+-- Jest to równoważne z:
+(2 * (2 * (2 * 4 + 1) + 2) + 3)
+
+-- foldl składa od od lewej strony, foldr od prawej
+foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
+
+-- To zaś równoważne jest:
+(2 * 1 + (2 * 2 + (2 * 3 + 4)))
+
+----------------------------------------------------
+-- 7. Typy danych
+----------------------------------------------------
+
+-- Oto jak tworzy się nowe typy danych w Haskellu:
+
+data Color = Red | Blue | Green
+
+-- Teraz można używać ich we własnych funkcjach:
+
+say :: Color -> String
+say Red = "You are Red!"
+say Blue = "You are Blue!"
+say Green =  "You are Green!"
+
+-- Twoje typy danych mogą posiadać nawet parametry:
+
+data Maybe a = Nothing | Just a
+
+-- Wszystkie poniższe są typu Maybe
+Just "hello"    -- typu `Maybe String`
+Just 1          -- typu `Maybe Int`
+Nothing         -- typu `Maybe a` for any `a`
+
+----------------------------------------------------
+-- 8. Haskell IO
+----------------------------------------------------
+
+-- Chociaż obsługa wejścia i wyjścia nie może zostać wyjaśniona przez poznaniem
+-- monad, spróbujemy zrobić to częściowo
+
+-- Wykonanie programu napisanego w Haskellu wywołuje funkcję `main` 
+-- Musi zwrócić wartość typu `IO a` dla pewnego `a`. Przykład:
+
+main :: IO ()
+main = putStrLn $ "Hello, sky! " ++ (say Blue)
+-- putStrLn has type String -> IO ()
+
+-- Najłatwiej obsłużyć wejście i wyjście, kiedy program zostanie 
+-- zaimplementowany jako funkcja String -> String. Funkcja
+--    interact :: (String -> String) -> IO ()
+-- pobiera pewien tekst, wykonuje na nim operacje, po czym wypisuje wynik.
+
+countLines :: String -> String
+countLines = show . length . lines
+
+main' = interact countLines
+
+-- Możesz myśleć o wartości typu `IO ()` jako reprezentującej ciąg czynności,
+-- które komputer ma wykonać, zupełnie niczym program komputerowy w imperatywnym
+-- języku programowania. Akcje można łączyć przy użyciu notacji `do`:
+
+sayHello :: IO ()
+sayHello = do
+   putStrLn "What is your name?"
+   name <- getLine -- this gets a line and gives it the name "name"
+   putStrLn $ "Hello, " ++ name
+
+-- Ćwiczenie: napisz własną wersję `interact`, 
+-- która czyta tylko jedną linię wejścia.
+
+-- Kod w `sayHello` nigdy się nie wykona. Jedyną akcją, która zostanie 
+-- uruchomiona, jest wartość `main`.
+-- Aby uruchomić `sayHello`, należy zastąpić poprzednią definicję `main` przez
+--   main = sayHello
+
+-- Spróbujmy lepiej zrozumieć, jak działa funkcja `getLine`, której właśnie
+-- użyliśmy. Jej typem jest
+--    getLine :: IO String
+-- Możesz myśleć o wartości typu `IO a` jako reprezentującej program, który
+-- wygeneruje wartość typu `a`, poza wszystkim innym, co jeszcze zrobi.
+-- Możemy także tworzyć własne akcje typu `IO String`:
+
+action :: IO String
+action = do
+   putStrLn "This is a line. Duh"
+   input1 <- getLine
+   input2 <- getLine
+   -- The type of the `do` statement is that of its last line.
+   -- `return` is not a keyword, but merely a function
+   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
+
+-- Możemy użyć tego tak jak używaliśmy `getLine`:
+
+main'' = do
+    putStrLn "I will echo two lines!"
+    result <- action
+    putStrLn result
+    putStrLn "This was all, folks!"
+
+-- Typ `IO` jest przykładem monady. Sposób w jakim Haskell używa monad do 
+-- obsługi wejścia i wyjścia pozwala mu być czysto funkcyjnym językiem.
+-- Każda funkcja, która wchodzi w interakcje ze światem zewnętrznym, oznaczana
+-- jest jako `IO` w jej sygnaturze typu, co umożliwia odróżnianie funkcji
+-- czystych od zależnych od świata lub modyfikujących stan.
+
+-- To naprawdę użyteczna własność, dzięki której jesteśmy w stanie uruchamiać
+-- czyste funkcje jednocześnie.
+
+----------------------------------------------------
+-- 9. Interaktywne środowisko programowania
+----------------------------------------------------
+
+-- Aby uruchomić repl (read-eval-print loop, interaktywne środowisko), należy
+-- wpisać `ghci`. Można już programować. Do definiowania nowych wartości służy
+-- słowo kluczowe `let`:
+
+let foo = 5
+
+-- Do sprawdzania typów dowolnej wartości (wyrażenia) wykorzystuje się `:t`:
+
+> :t foo
+foo :: Integer
+
+-- Działania takie jak `+`, `:` czy `$`, są funkcjami.
+-- Przed sprawdzeniem ich typu należy otoczyć je nawiasami:
+
+> :t (:)
+(:) :: a -> [a] -> [a]
+
+-- Dodatkowych informacji dostarcza `:i`:
+
+> :i (+)
+class Num a where
+  (+) :: a -> a -> a
+  ...
+    -- Defined in ‘GHC.Num’
+infixl 6 +
+
+-- Można nawet wykonywać akcje typu `IO ()`!
+
+> sayHello
+What is your name?
+Friend!
+Hello, Friend!
+
+```
+
+Pominęliśmy wiele aspektów Haskella, wliczając w to monady. To właśnie one 
+sprawiają, że programowanie w Haskellu sprawia tyle frajdy. Na zakończenie
+pokażę Tobie implementację algorytmu quicksort w Haskellu:
+
+```haskell
+qsort [] = []
+qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
+    where lesser  = filter (< p) xs
+          greater = filter (>= p) xs
+```
+
+Haskell może zostać zainstalowany na co najmniej dwa sposoby:
+ - tradycyjnie [przy użyciu Cabala](http://www.haskell.org/platform/),
+ - nowocześnie [z pomocą Stack](https://www.stackage.org/install).
+
+Godnymi poleceniami wprowadzeniami są wspaniałe
+[Learn you a Haskell](http://learnyouahaskell.com/) albo
+[Real World Haskell](http://book.realworldhaskell.org/).
diff --git a/pl-pl/json-pl.html.markdown b/pl-pl/json-pl.html.markdown
new file mode 100644
index 00000000..872455de
--- /dev/null
+++ b/pl-pl/json-pl.html.markdown
@@ -0,0 +1,85 @@
+---
+language: json
+filename: learnjson-pl.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["himanshu", "https://github.com/himanshu81494"]
+  - ["Michael Neth", "https://github.com/infernocloud"]
+translators:
+  - ["Michał Mitrosz", "https://github.com/Voltinus"]
+lang: pl-pl
+---
+
+JSON to bardzo prosty format wymiany danych. Jak jest napisane na [json.org](http://json.org), jest łatwy do pisania i czytania dla ludzi i do parsowania i generowania dla maszyn.
+
+Kod JSON musi zawierać któreś z poniższych:
+* Zbiór par nazwa/wartość (`{ }`). W różnych językach jest to obiekt, rekord, struktura, słownik, tablica mieszająca, lista z kluczami, lub tablica asocjacyjna.
+* Uporządkowana lista wartości (`[ ]`). W różnych językach jest to tablica, wektor, lista, lub sekwencja.
+ tablica/lista/sekwencja (`[ ]`) lub słownik/obiekt/tablica asocjacyjna (`{ }`).
+
+JSON w swojej czystej postaci nie ma komentarzy, ale większość parserów akceptuje komentarze w stylu C (`//`, `/* */`). Niektóre parsery pozwalają także na końcowy przecinek (np. przecinek po ostatnim elemencie w tablicy lub po ostatiej własności obiektu), ale powinien on być omijany dla lepszej kompatybilności.
+
+Dla celów tego poradnika wszystko będzie 100% kodem JSON. Na szczęście, to samo mówi za siebie.
+
+Wspierane typy danych:
+
+* Łańcuchy znaków: `"witaj"`, `"\"Cytat.\""`, `"\u0abe"`, `"Nowa linia.\n"`
+* Liczby: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
+* Obiekty: `{ "klucz": "wartość" }`
+* Tablice: `["Wartości"]`
+* Inne: `true`, `false`, `null`
+
+```json
+{
+  "klucz": "wartość",
+
+  "klucze": "muszą być zawsze zamknięte w podwójnych cudzysłowach",
+  "liczby": 0,
+  "łańcuchy": "Hellø, wørld. Wszystkie znaki unicode są dozwolone, razem z \"sekwencjami escape\".",
+  "wartości logiczne?": true,
+  "nic": null,
+
+  "duża liczba": 1.2e+100,
+
+  "obiekty": {
+    "komentarz": "Większość twojej struktury będzie zbudowana z obiektów.",
+
+    "tablica": [0, 1, 2, 3, "Tablice mogą mieć wewnątrz cokolwiek", 5],
+
+    "inny obiekt": {
+      "komentarz": "Elementy mogą się w sobie zawierać, bardzo użyteczne"
+    }
+  },
+
+  "głupota": [
+    {
+      "źródła potasu": ["banany"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+
+  "styl alternatywny": {
+    "komentarz": "sprawdź to!"
+  , "pozycja przecinka": "nie ma znaczenia, o ile jest przed następnym kluczem, jest poprawnie"
+  , "następny komentarz": "jak ładnie"
+  },
+
+
+
+  "znaki białe": "nie mają znaczenia",
+
+
+
+  "to było krótkie": "I gotowe. Wiesz już wszystko o formacie JSON."
+}
+```
+
+## Dalsza lektura
+
+* [JSON.org](http://json.org) Cały JSON pięknie wytłumaczony na podstawie grafik przypominających schematy blokowe.
diff --git a/pl-pl/ruby-pl.html.markdown b/pl-pl/ruby-pl.html.markdown
index 73b1a7d8..7ab47847 100644
--- a/pl-pl/ruby-pl.html.markdown
+++ b/pl-pl/ruby-pl.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: ruby
-filename: learnruby.rb
+filename: learnruby-pl.rb
 contributors:
   - ["David Underwood", "http://theflyingdeveloper.com"]
   - ["Joel Walden", "http://joelwalden.net"]
diff --git a/pl-pl/vim-pl.html.markdown b/pl-pl/vim-pl.html.markdown
new file mode 100644
index 00000000..8ac2df56
--- /dev/null
+++ b/pl-pl/vim-pl.html.markdown
@@ -0,0 +1,236 @@
+---
+category: tool
+tool: vim
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+    - ["Adam Bobowski", "https://github.com/Bobowski"]
+lang: pl-pl
+filename: LearnVim-pl.txt
+---
+
+
+[Vim](http://www.vim.org)
+(Vi IMproved) jest klonem popularnego edytora vi dla systemów Unix. 
+Zaprojektowany z myślą o prędkości edycji i zwiększeniu produktywności jest 
+wszechobecny na systemach UNIXopodobnych. Posiada wiele skrótów klawiszowych 
+do szybkiej nawigacji do wybranych miejsc w plikach oraz szybkiej edycji 
+danych fragmentów.
+
+## Podstawy nawigacji w Vim
+
+```
+    vim <nazwapliku> # Otwórz <nazwapliku> w vim
+    :q               # Zamknij vim
+    :w               # Zapisz aktualny plik
+    :wq              # Zapisz i wyjdź z vim
+    :q!              # Wyjdź bez zapisywania
+                     # ! *wymusza* wykonanie :q, dlatego nie wykonuje zapisu
+    :x               # Zapisz i wyjdź, krótszy odpowiednik :wq
+
+    u                # Cofnij operację
+    CTRL+R           # Powtórz operację
+
+    h                # Przesuń kursor w lewo
+    j                # Przesuń kursor w dół
+    k                # Przesuń kursor w górę
+    l                # Przesuń kursor w prawo
+
+    # Poruszanie w obrębie jednej lini
+
+    0                # Skocz do początku linii
+    $                # Skocz do końca linii
+    ^                # Skocz do pierwszego niebiałego znaku
+
+    # Wyszukiwanie w tekście
+
+    /slowo           # Zaznacza wszystkie wystąpienia słowa za kursorem
+    ?slowo           # Zaznacza wszystkie wystąpienia słowa przed kursorem
+    n                # Przemieszcza kursor do następnego wystąpienia słowa
+    N                # Przemieszcza kursor do poprzedniego wystąpenia słowa
+
+    :%s/foo/bar/g    # Zamień 'foo' na 'bar' w każdej linii tekstu
+    :s/foo/bar/g     # Zamień 'foo' na 'bar' w aktualnej linii
+
+    # Skoki do znaków
+
+    f<znak>          # Skocz do przodu i zatrzymaj się na <znak>
+    t<znak>          # Skocz do przodu i zatrzymaj się przed <znak> 
+
+    # Na przykład,    
+    f<               # Skocz do przodu i zatrzymaj się na <
+    t<               # Skocz do przodu i zatrzymaj się przed <
+    
+    # Moving by word
+
+    w                # Przesuń kursor do przodu o jedno słowo
+    b                # Przesuń kursor do tyłu o jedno słowo
+    e                # Przesuń kursor do końca aktualnego słowa
+
+    # Inne znaki do przemieszczania się
+
+    gg               # Skocz na początek pliku
+    G                # Skocz na koniec pliku
+    :NUM             # Skocz do linii o numerze NUM
+    H                # Skocz na górę ekranu
+    M                # Skocz na środek ekranu
+    L                # Skocz na dół ekranu
+```
+
+## Tryby:
+
+Vim oparty jest na koncepcji **trybów**.
+
+Command Mode - (Tryb komend) vim zaczyna w tym trybie, używany do nawigacji i wpisywania komend
+Insert Mode  - (Tryb wprowadzania) używany do wprowadzania zmian w pliku
+Visual Mode  - (Tryb wizualny) używany do zaznaczania tekstu i wykonywania komend na nim
+Ex Mode      - (Tryb Ex) 
+
+```
+    i                # Przechodzi to trybu wprowadzania, przed pozycją kursora
+    a                # Przechodzi do trybu wprowadzania, za pozycją kursora
+    v                # Przechodzi do trybu wizualnego
+    :                # Przechodzi do trybu ex
+    <esc>            # Wychodzi z dowolnego aktywnego trybu do trybu komend
+
+    # Kopiowanie i wklejanie tekstu
+
+    y                # Skopiuj zaznaczony tekst
+    yy               # Skopiuj aktualną linię
+    d                # Usuń zaznaczony tekst
+    dd               # Usuń aktualną linię
+    p                # Wklej skopiowany tekst za kursorem
+    P                # Wklej skopiowany tekst przed kursorem
+    x                # Usuń znak pod kursorem
+```
+
+## 'Gramatyka' vim'a
+
+Vim można traktować jako zbiór komend w formacie 'Akcja-Modyfikator-Obiekt', gdzie:
+
+Akcja       - jedna z dostępnych akcji
+Modyfikator - w jaki sposób wykonywana jest akcja
+Obiekt      - obiekt na którym wykonywana jest akcja
+
+Kilka ważnych przykładów Akcji, Modyfikatorów i Obiektów:
+
+```
+    # 'Akcje'
+ 
+    d                # Usuń
+    c                # Zmień
+    y                # Skopiuj
+    v                # Zaznacz
+
+    # 'Modyfikatory'
+
+    i                # W środku
+    a                # Dookoła
+    NUM              # Liczba
+    f                # Szuka czegoś i zatrzymuje się na tym
+    t                # Szuka czegoś i zatrzymuje się przed tym
+    /                # Znajduje napis od kursora naprzód
+    ?                # Znajduje napis przed kursorem
+
+    # 'Obiekty'
+
+    w                # Słowo
+    s                # Zdanie
+    p                # Paragraf
+    b                # Blok
+    
+    # Przykładowe 'zdania'
+
+    d2w              # Usuń 2 słowa
+    cis              # Zmień w zdaniu
+    yip              # Skopiuj paragraf w którym jest kursor
+    ct<              # Zamień na <
+    d$               # Usuń tekst do końca linii
+```
+
+## Pewne skróty i triki
+
+        <!--TODO: Dodać więcej!-->
+```
+    >                # Zrób wcięcie zaznaczonego bloku
+    <                # Usuń wcięcie zaznaczonego bloku
+    :earlier 15m     # Przywróć dokument do stanu z przed 15 minut 
+    :later 15m       # Odwróć efekt poprzedniej komendy
+    ddp              # Zamień kolejnością kolejne linie, dd potem p
+    .                # Powtórz poprzednią komendę
+```
+
+## Makra
+
+Makra są właściwie nagrywanymi akcjami. Gdy zaczynasz nagrywać makro, nagrywa ono
+**każdą** akcję i komendę jaką wykonasz do momentu przerwania nagrywania.
+Wywołanie makra wykonuje dokładnie te same operacje w tej samej kolejności.
+
+```
+    qa               # Zacznij nagrywać makro 'a'
+    q                # Przerwij nagrywanie
+    @a               # Odtwórz makro 'a'
+```
+
+### Konfiguracja ~/.vimrc
+
+Plik .vimrc może być użyty do skonfigurowania Vim'a przy jego starcie
+
+Poniżej zamieszczono przykładowy plik ~/.vimrc:
+
+```
+" Przykładowy ~/.vimrc
+" 2016.10 
+
+" Wymagane aby korzystać z opcji iMproved
+set nocompatible
+
+" Na podstawie typu pliku włącza inteligentne wcięcia i inne.
+filetype indent plugin on
+
+" Włącz podkreślanie składni
+syntax on
+
+" Lepsze uzupełnianie składni komend
+set wildmenu
+
+" Wyszukiwanie będzie ignorować wielkość liter poza przypadkami gdy użyjemy wielkich liter
+set ignorecase
+set smartcase
+
+" Po otwarciu pliku gdzie nie jest zdefiniowane zachowanie wcięć
+" zostanie zachowane wcięcie takie samo jak w aktualnej linii
+set autoindent
+
+" Wyświetlaj numer lini
+set number
+
+" Opcje wcięć, zmień w zależności od osobistych upodobań
+
+" Szerokość TAB w spacjach
+set tabstop=4
+
+" Liczba spacji w TAB podczas edycji
+set softtabstop=4
+
+" Liczba spacji gdy wykonywane są operacje wcięcia (>> i <<)
+set shiftwidth=4
+
+" Zamieniaj tabulatory na spacje
+set expandtab
+
+" Aktywuj inteligentne tabulatory i spacje do wcięć i wyrównań
+set smarttab
+```
+
+### Odniesienia [ENG]
+
+[Vim | Home](http://www.vim.org/index.php)
+
+`$ vimtutor`
+
+[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)