8 files changed, 868 insertions, 8 deletions

diff --git a/tr-tr/brainfuck-tr.html.markdown b/tr-tr/bf-tr.html.markdown
index bd842b17..e7015cd0 100644
--- a/tr-tr/brainfuck-tr.html.markdown
+++ b/tr-tr/bf-tr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 filename: brainfuck-tr
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io"]
diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
index 2d4240ed..33544765 100644
--- a/tr-tr/c-tr.html.markdown
+++ b/tr-tr/c-tr.html.markdown
@@ -202,7 +202,7 @@ int main() {
     0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
 
     // Isaretli sayilari kaydirirken dikkatli olun - tanimsizlar sunlardir:
-    // - isaretli sayinin isaret bitinde yapÄilan kaydirma (int a = 1 << 32)
+    // - isaretli sayinin isaret bitinde yap?ilan kaydirma (int a = 1 << 32)
     // - negatif sayilarda sol kaydirma (int a = -1 << 2)
     // - LHS tipinde >= ile olan ofset genisletmelerde yapilan kaydirma:
     //   int a = 1 << 32; // UB if int is 32 bits wide
diff --git a/tr-tr/dynamic-programming-tr.html.markdown b/tr-tr/dynamic-programming-tr.html.markdown
new file mode 100644
index 00000000..1900ee93
--- /dev/null
+++ b/tr-tr/dynamic-programming-tr.html.markdown
@@ -0,0 +1,44 @@
+---
+language: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "https://github.com/akashdeepgoel"]
+translators:
+    - ["Mehmet Cem YaraÅŸ", "https://www.linkedin.com/in/yarascem/"]
+lang: tr-tr
+---
+
+Dinamik Programlama
+GiriÅŸ
+Dinamik Programlama, göreceğimiz gibi belirli bir problem sınıfını çözmek için kullanılan güçlü bir tekniktir. Fikir çok basittir, verilen girdiyle ilgili bir sorunu çözdüyseniz, aynı sorunun tekrar çözülmesini önlemek için sonucunu gelecekte referans olarak kaydedilmesine dayanır.
+
+Her zaman hatırla! "Geçmiş hatırlayamayanlar, aynı şeyleri tekrar yaşamaya mahkumlardır!"
+
+Bu tür sorunların çözüm yolları
+
+1-Yukarıdan aşağıya:
+Verilen problemi çözerek çözmeye başlayın. Sorunun zaten çözüldüğünü görürseniz, kaydedilen cevabı döndürmeniz yeterlidir. Çözülmemişse, çözünüz ve cevabı saklayınız. Bu genellikle düşünmek kolaydır ve çok sezgiseldir. Buna Ezberleştirme denir.
+
+2-Aşağıdan yukarıya:
+Sorunu analiz edin ve alt problemlerin çözülme sırasını görün ve önemsiz alt sorundan verilen soruna doğru başlayın. Bu süreçte, problemi çözmeden önce alt problemlerin çözülmesi gerekmektedir. Buna Dinamik Programlama denir.
+
+Örnek
+En Uzun Artan Subsequence problemi belirli bir dizinin en uzun artan alt dizini bulmaktır. S = {a1, a2, a3, a4, ............., an-1} dizisi göz önüne alındığında, en uzun bir alt kümeyi bulmak zorundayız, böylece tüm j ve i, j için <I, aj <ai alt kümesinde. Her şeyden önce, en son alt dizgenin (LSi) değerini dizinin son elemanı olan ai'nin her indeksinde bulmalıyız. Daha sonra en büyük LSi, verilen dizideki en uzun alt dizin olacaktır. Başlamak için, ai, dizinin elemanı olduğundan (Son öğe) LSi atanır. Sonra tüm j için j <i ve aj <ai gibi, En Büyük LSj'yi buluruz ve LSi'ye ekleriz. Sonra algoritma O (n2) zaman alır.
+
+En uzun artan alt dizinin uzunluğunu bulmak için sözde kod: Bu algoritmaların karmaşıklığı dizi yerine daha iyi veri yapısı kullanılarak azaltılabilir. Büyük dizin ve dizin gibi selefi dizi ve değişkeni saklama çok zaman kazandıracaktır.
+
+Yönlendirilmiş asiklik grafiğinde en uzun yolu bulmak için benzer bir kavram uygulanabilir.
+for i=0 to n-1
+    LS[i]=1
+    for j=0 to i-1
+        if (a[i] >  a[j] and LS[i]<LS[j])
+            LS[i] = LS[j]+1
+for i=0 to n-1
+    if (largest < LS[i])
+    
+Bazı Ünlü Dinamik Programlama Problemleri
+-Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs—floyd-warshall-algorithm-with-c-program-source-code
+-Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming—the-integer-knapsack-problem
+-Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming—longest-common-subsequence
+
+Online Kaynaklar
+https://www.codechef.com/wiki/tutorial-dynamic-programming
diff --git a/tr-tr/fsharp-tr.html.markdown b/tr-tr/fsharp-tr.html.markdown
new file mode 100644
index 00000000..8c47397c
--- /dev/null
+++ b/tr-tr/fsharp-tr.html.markdown
@@ -0,0 +1,631 @@
+---
+language: F#
+contributors:
+    - ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"]
+translators:
+    - ["Mustafa Zengin", "http://zengin.github.com/"]
+filename: learnfsharp-tr.fs
+lang: tr-tr
+---
+
+F# fonksiyonel ve nesne yönelimli, genel amaçlı bir programlama dilidir. Bedava ve açık kaynaklıdır ve Linux, Mac, Windows ve dahasında çalışır.
+
+Hataları derleme zamanında yakalayan çok güçlü bir tip sistemine sahiptir, ancak tip çıkarımı yaptığından dinamik bir dil gibi görünür.
+
+F#'ın söz dizimi C-stili dillerden farklıdır:
+
+* Küme parantezi kod bloklarını ayırmak için kullanılmaz. Bunun yerine Python'da olduğu gibi girinti kullanılır.
+* Parametreleri birbirinden ayırmak için virgül yerine boşluk karakteri kullanılır.
+
+Aşağıdaki kodu denemek istiyorsanız, [tryfsharp.org](http://www.tryfsharp.org/Create)'a gidin be interaktif REPL'e kodu yapıştırın.
+
+```csharp
+
+// tek satır yorumlar ikili bölme işareti ile başlar
+(* çok satırlı yorumlar ( * . . . * ) ikilisini kullanır
+
+-çok satırlı yorumun sonu- *)
+
+// ================================================
+// Temel Söz Dizimi
+// ================================================
+
+// ------ "DeÄŸiÅŸkenler" (tam da deÄŸil) ------
+// "let" anahtar kelimesi (değişmez) değer tanımlar
+let tamsayım = 5
+let ondalığım = 3.14
+let stringim = "merhaba"           // tip bilgisi olmamasına dikkat
+
+// ------ Listeler ------
+let ikidenBeşe = [2; 3; 4; 5]      // Köşeli parantezler listeleri oluşturur,
+                                   // değerler ise noktalı virgülle ayrılır.
+let birdenBeşe = 1 :: ikidenBeşe   // :: yeni birinci elemanı olan bir liste oluşturur.
+// Sonuç: [1; 2; 3; 4; 5]
+let sıfırdanBeşe = [0; 1] @ ikidenBeşe  // @ iki listeyi birbirine ekler.
+
+// ÖNEMLİ: virgüller hiçbir zaman ayraç olarak kullanılmaz, sadece noktalı virgüller!
+
+// ------ Fonksiyonlar ------
+// "let" anahtar kelimesi isimlendirilmiş fonksiyonları da tanımlar.
+let kare x = x * x          // Parantez kullanılmadığına dikkat.
+kare 3                      // Şimdi fonksiyonu uygulayın. Yine parantez yok.
+
+let topla x y = x + y       // topla (x,y) kullanmayın! Bu tamamen başka bir anlama geliyor.
+topla 2 3                   // Şimdi fonksiyonu uygulayın.
+
+// çok satırlı bir fonksiyon tanımlamak için sadece girinti kullanın. Noktalı virgül gerekmez.
+let çiftler liste =
+   let çiftMi x = x % 2 = 0     // "çiftMi"yi alt fonksiyon olarak tanımlayın
+   List.filter çiftMi liste     // List.filter 'boolean bir fonksiyon' ve
+                                // 'üzerinde çalışılacak bir liste' parametrelerinden oluşan
+                                // bir kütüphane fonksiyonu
+                              
+çiftler birdenBeşe              // Şimdi fonksiyonu uygula.
+
+// Parantezleri önceliği netleştirmek için kullanabilirsiniz. Bu örnek
+// "map"i önce iki argümana, sonra sonuç üzerinde "ekle" uyguluyor.
+// Parantezler olmasaydı, "List.map" List.sum'ın ilk argümanı olurdu.
+let yüzeKadarKarelerinToplamı =
+   List.sum ( List.map kare [1..100] )
+
+// Bir operasyonun sonucunu bir sonrakine "|>" kullanarak besleyebilirsin.
+// Veri beslemek F#'ta UNIX'te olduğu gibi yaygındır..
+
+// Burada yüzeKadarKarelerinToplamı fonksiyonunun veri beslemeyle yazılmış hali var:
+let veriBeslemeyleYüzeKadarKarelerinToplamı =
+   [1..100] |> List.map kare |> List.sum  // "kare" önceden tanımlanmıştı
+
+// Lambda'ları (anonim fonksiyonları) "fun" anahtar kelimesiyle tanımlayabilirsin
+let funlaYüzeKadarKarelerinToplamı =
+   [1..100] |> List.map (fun x -> x * x) |> List.sum
+
+// F#'ta "return" anahtar kelimesi yoktur. Bir fonksiyon
+// her zaman son kullanılan ifadeyi döndürür.
+
+// ------ Kalıp eşleştirme ------
+// Match..with.. çok güçlü bir case/switch türevidir.
+let basitKalıpEşleştirme =
+   let x = "a"
+   match x with
+    | "a" -> printfn "x a'dır"
+    | "b" -> printfn "x b'dir"
+    | _ -> printfn "x başka bir şeydir"   // alt çizgi bütün kalıplarla eşleşir
+
+// F# varsayılan olarak null'lara izin vermez -- Option tipini kullanıp
+// kalıp eşleştirme yapmalısın.
+// Some(..) ve None, Nullable tipler gibidir.
+let geçerliDeğer = Some(99)
+let geçersizDeğer = None
+
+// Bu örnekte, match..with "Some" ve "None"la eşleştirme yapıyor,
+// ve ayrıca "Some" içerisindeki değeri de çıkarıyor.
+let optionKalıpEşleştirme input =
+   match input with
+    | Some i -> printfn "input is an int=%d" i
+    | None -> printfn "input is missing"
+
+optionKalıpEşleştirme geçerliDeğer
+optionKalıpEşleştirme geçersizDeğer
+
+// ------ Yazdırma ------
+// printf/printfn fonksiyonları C#'taki 
+// Console.Write/WriteLine fonksiyonlarına benzer.
+printfn "Bir tamsayı %i, bir ondalık %f, bir boolean %b yazdırma" 1 2.0 true
+printfn "Bir string %s, ve jenerik bir tip %A" "merhaba" [1; 2; 3; 4]
+
+// sprintf/sprintfn fonksiyonları ise veriyi string'e
+// çevirmek içindir, C#'taki String.Format gibi.
+
+// ================================================
+// Fonksiyonlar hakkında dahası
+// ================================================
+
+// F# gerçek bir fonksiyonel dildir. Fonksiyonlar birinci
+// sınıf varlıklardır ve güçlü yapılar oluşturmak için
+// birleÅŸtirilebilirler.
+
+// Modüller fonksiyonları gruplamak için kullanılır.
+// Her bir modül için girinti gerekir.
+module FonksiyonOrnekleri =
+
+    // Temel bir ekleme fonksiyonu tanımla
+    let topla x y = x + y
+
+    // Bir fonksiyonun temel kullanımı
+    let a = topla 1 2
+    printfn "1 + 2 = %i" a
+
+    // Parametreleri kaynaklamak için parçalı uygulama
+    let kırkİkiEkle = topla 42
+    let b = kırkİkiEkle 1
+    printfn "42 + 1 = %i" b
+
+    // Fonksiyonları birleştirmek için kompozisyon
+    let birEkle = topla 1
+    let ikiEkle = topla 2
+    let üçEkle = birEkle >> ikiEkle
+    let c = üçEkle 7
+    printfn "3 + 7 = %i" c
+
+    // Yüksek dereceli fonksiyonlar
+    [1..10] |> List.map üçEkle |> printfn "yeni liste: %A"
+
+    // Fonksiyonlar listesi ve dahası
+    let altıEkle = [birEkle; ikiEkle; üçEkle] |> List.reduce (>>)
+    let d = altıEkle 7
+    printfn "1 + 2 + 3 + 7 = %i" d
+
+// ================================================
+// Listeler ve kolleksiyonlar
+// ================================================
+
+// Üç çesit sıralı fonksiyon vardır:
+// * Listeler en temel değiştirilemez kolleksiyonlardır.
+// * Diziler deÄŸiÅŸtirilebilir ve gerektiÄŸinde daha verimlidirler.
+// * Seriler tembel (lazy evaluation) ve sonsuzdurlar (Enumeratörler gibi). 
+// 
+// Değiştirilmez map'ler ve kümeler ve bütün .NET kolleksiyonları
+// diğer kolleksiyon türleridir.
+
+module ListeÖrnekleri =
+
+    // listeler köşeli parantez kullanır
+    let liste1 = ["a"; "b"]
+    let liste2 = "c" :: liste1    // :: baÅŸa eleman ekler
+    let liste3 = liste1 @ liste2   // @ listeleri birbirine ekler
+
+    // Liste comprehension'ları (jeneratörler olarak da bilinir)
+    let kareler = [for i in 1..10 do yield i * i]
+
+    // asal sayı jeneratörü
+    let rec elek = function
+        | (p::xler) -> p :: elek [ for x in xler do if x % p > 0 then yield x ]
+        | []      -> []
+    let asallar = elek [2..50]
+    printfn "%A" asallar
+
+    // Listelerle kalıp eşleştirme
+    let listeEÅŸleyici liste =
+        match liste with
+        | [] -> printfn "liste boÅŸ"
+        | [birinci] -> printfn "listede sadece bir eleman var: %A " birinci
+        | [birinci; ikinci] -> printfn "liste: %A ve %A" birinci ikinci
+        | _ -> printfn "listede ikiden fazla eleman var"
+
+    listeEÅŸleyici [1; 2; 3; 4]
+    listeEÅŸleyici [1; 2]
+    listeEÅŸleyici [1]
+    listeEÅŸleyici []
+
+    // Listeleri kullanarak recursion
+    let rec ekle liste =
+        match liste with
+        | [] -> 0
+        | x::xler -> x + ekle xler
+    ekle [1..10]
+
+    // -----------------------------------------
+    // Standart kütüphane fonksiyonları
+    // -----------------------------------------
+
+    // map
+    let üçEkle x = x + 3
+    [1..10] |> List.map üçEkle
+
+    // filter
+    let çift x = x % 2 = 0
+    [1..10] |> List.filter çift
+
+    // ve dahası -- dökümantasyona bakınız
+
+module DiziÖrnekleri =
+
+    // Diziler köşeli parantezle birlikte çubuk karakterini kullanır
+    let dizi1 = [| "a"; "b" |]
+    let birinci = dizi1.[0]        // nokta kullanarak indeks eriÅŸimi
+
+    // Diziler için kalıp eşleştirme listlerle aynıdır
+    let diziEÅŸleÅŸtirici liste =
+        match liste with
+        | [| |] -> printfn "dizi boÅŸ"
+        | [| birinci |] -> printfn "dizide sadece bir eleman var: %A " birinci
+        | [| birinci; ikinci |] -> printfn "dizi: %A ve %A" birinci ikinci
+        | _ -> printfn "dizide ikiden fazla eleman var"
+
+    diziEÅŸleÅŸtirici [| 1; 2; 3; 4 |]
+
+    // Listede olduğu gibi kütüphane fonksiyonları
+
+    [| 1..10 |]
+    |> Array.map (fun i -> i + 3)
+    |> Array.filter (fun i -> i % 2 = 0)
+    |> Array.iter (printfn "deÄŸer: %i. ")
+
+
+module SeriÖrnekleri =
+
+    // seriler kıvrık parantez kullanır
+    let seri1 = seq { yield "a"; yield "b" }
+
+    // seriler yield'ı kullanabilir
+    // ve alt seriler barındırabilir
+    let garip = seq {
+        // "yield" bir eleman ekliyor
+        yield 1; yield 2;
+
+        // "yield!" bütün bir alt seriyi ekliyor
+        yield! [5..10]
+        yield! seq {
+            for i in 1..10 do
+              if i % 2 = 0 then yield i }}
+    // test
+    garip |> Seq.toList
+
+
+    // Seriler "unfold" kullanılarak oluşturulabilir
+    // Fibonacci serisi örneği
+    let fib = Seq.unfold (fun (birinci,ikinci) ->
+        Some(birinci + ikinci, (ikinci, birinci + ikinci))) (0,1)
+
+    // test
+    let fib10 = fib |> Seq.take 10 |> Seq.toList
+    printf "ilk 10 fibonacci sayısı: %A" fib10
+
+
+// ================================================
+// Veri Tipleri
+// ================================================
+
+module VeriTipiÖrnekleri =
+
+    // Bütün veriler varsayılan olarak değiştirilemezdir.
+
+    // -- Tuple oluşturmak için virgül kullan
+    let ikiliTuple = 1, 2
+    let üçlüTuple = "a", 2, true
+    
+    // Tuple'lar çabuk ve kolay anonim tiplerdir.
+    // paketi açmak için kalıp eşleştirme kullan
+    let x, y = ikiliTuple  // x = 1, y = 2
+
+    // ------------------------------------
+    // Record tipi isimlendirilmiÅŸ alanlara sahiptir
+    // ------------------------------------
+
+    // "type" ile kıvrık parantezleri record tipi oluşturmak için kullan
+    type KiÅŸi = {Ad:string; Soyad:string}
+
+    // "let" ile kıvrık parantezi record tipi oluşturmak için kullan
+    let kiÅŸi1 = {Ad="Falanca"; Soyad="KiÅŸi"}
+
+    // paketi açmak için kalıp eşleştirme kullan
+    let {Ad = Ad} = kiÅŸi1    // birinci="John"
+
+    // ------------------------------------
+    // Union tipleri (deÄŸiÅŸkenler olarak da bilinir) birden fazla
+    // seçeneğe sahiptir. Belli bir zamanda sadece bir tanesi geçerlidir.
+    // ------------------------------------
+
+    // "type" ile çubuk karakterini union tipi tanımlamak için kullan
+    type Sıcaklık =
+        | Santigrat of float
+        | Fahrenhayt of float
+
+    // Seçeneklerden birini kullan
+    let derece1 = Fahrenhayt 98.6
+    let derece2 = Santigrat 37.0
+
+    // Paketi açmak için bütün seçenekler üzerinde kalıp eşleştirme kullan
+    let dereceYazdır = function
+       | Santigrat t -> printfn "%f C" t
+       | Fahrenhayt t -> printfn "%f F" t
+
+    dereceYazdır derece1
+    dereceYazdır derece2
+
+    // ------------------------------------
+    // Yinelgen (Recursive) tipler
+    // ------------------------------------
+
+    // Tipler alt sınıflar oluşturmadan karmaşık şekillerde
+    // yinelgen olarak birleÅŸtirilebilirler.
+    type Çalışan =
+      | İşçi of Kişi
+      | Yönetici of Çalışan list
+
+    let falancaKiÅŸi = {Ad="Falanca"; Soyad="KiÅŸi"}
+    let işçi = İşçi falancaKişi
+
+    // ------------------------------------
+    // Tipleri Kullanarak Modelleme
+    // ------------------------------------
+
+    // Union tipleri bayrak kullanmadan durum modelleme için harikadır.
+    type EpostaAdresi =
+        | GeçerliEpostaAdresi of string
+        | GeçersizEpostaAdresi of string
+
+    let epostaGöndermeyiDene eposta =
+        match eposta with                     // kalıp eşleştirme kullan
+        | GeçerliEpostaAdresi adres -> ()     // gönder
+        | GeçersizEpostaAdresi adres -> ()    // gönderme
+
+    // Union tiplerin record tiplerle birleÅŸimi
+    // domain driven design için iyi bir temel oluşturur.
+    // Domain'i yansıtan yüzlerce ufak tip oluşturabilirsiniz.
+
+    type Ürün = { ÜrünKodu: string; Miktar: int }
+    type Ödeme = Ödeme of float
+    type AktifSepetVerisi = { ÖdenmemişÜrünler: Ürün list }
+    type ÖdenmişSepetVerisi = { ÖdenmişÜrünler: Ürün list; Ödeme: Ödeme}
+
+    type AlışverişSepeti =
+        | BosSepet  // veri yok
+        | AktifSepet of AktifSepetVerisi
+        | ÖdenmişSepet of ÖdenmişSepetVerisi
+
+    // ------------------------------------
+    // Tipler için içgüdüsel davranış
+    // ------------------------------------
+
+    // Çekirdek tipler kendinden çok kullanışlı özelliklere sahiptir
+    // Ek kodlama gerektirmez
+    // * DeÄŸiÅŸmezlik
+    // * Debug ederken yazdırma
+    // * Eşitlik ve kıyaslama
+    // * Serialization
+
+    // %A kullanarak yazdırma
+    printfn "ikiliTuple=%A,\nKişi=%A,\Sıcaklık=%A,\nÇalışan=%A"
+             ikiliTuple kişi1 derece1 işçi
+
+    // Eşitlik ve kıyaslama içgüdüseldir.
+    // İskambil kartlarıyla bir örnek
+    type Simge = Sinek | Karo | Maça | Kupa
+    type Sıra = İki | Üç | Dört | Beş | Altı | Yedi | Sekiz
+                | Dokuz | On | Bacak | Kız | Papaz | As
+
+    let el = [ Sinek, As; Kupa, Üç; Kupa, As;
+                 Maça, Bacak; Karo, İki; Karo, As ]
+
+    // Sıralama
+    List.sort el |> printfn "artarak dizilen el: %A"
+    List.max el |> printfn "en yüksek kart: %A"
+    List.min el |> printfn "en düşük kart: %A"
+
+
+// ================================================
+// Aktif Kalıplar
+// ================================================
+
+module AktifKalıpÖrnekleri =
+
+    // F# "aktif kalıplar" denen bir kalıp eşleştirmeye sahiptir.
+    // Kalıplar dinamik bir şekilde tespit edilip eşleştirilebilir.
+
+    // Aktif kalıplar için söz dizimi (| ... |) şeklindedir
+
+    // Örneğin, karakter tiplerini eşleyen bir "aktif" kalıp tanımlayın...
+    let (|Rakam|Harf|BoÅŸluk|DiÄŸer|) karakter =
+       if System.Char.IsDigit(karakter) then Rakam
+       else if System.Char.IsLetter(karakter) then Harf
+       else if System.Char.IsWhiteSpace(karakter) then BoÅŸluk
+       else DiÄŸer
+
+    // ... daha sonra eşleme mantığı çok daha net yapmak için bunu kullanın
+    let karakterYazdır karakter =
+      match karakter with
+      | Rakam -> printfn "%c bir rakamdır" karakter
+      | Harf -> printfn "%c bir harftir" karakter
+      | BoÅŸluk -> printfn "%c bir boÅŸluktur" karakter
+      | _ -> printfn "%c baÅŸka bir ÅŸeydir" karakter
+
+    // Bir liste yazdırma
+    ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter karakterYazdır
+
+    // -----------------------------------
+    // Aktif Kalıpları Kullanarak FizzBuzz
+    // -----------------------------------
+
+    // Parçalı eşleşen kalıplar da oluşturabilirsiniz
+    // Tanımda alt çizgi karakterini kullanın ve eşleşince Some döndürün.
+    let (|ÜçünKatı|_|) i = if i % 3 = 0 then Some ÜçünKatı else None
+    let (|BeşinKatı|_|) i = if i % 5 = 0 then Some BeşinKatı else None
+
+    // Ana fonksiyon
+    let fizzBuzz i =
+      match i with
+      | ÜçünKatı & BeşinKatı -> printf "FizzBuzz, "
+      | ÜçünKatı -> printf "Fizz, "
+      | BeşinKatı -> printf "Buzz, "
+      | _ -> printf "%i, " i
+
+    // test
+    [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// Sadelik
+// ================================================
+
+module AlgoritmaÖrnekleri =
+
+    // F#'ın sinyal/gürültü oranı yüksektir, dolayısıyla
+    // kod algoritmayla hemen hemen aynı görünür.
+
+    // ------ Örnek: karelerToplami fonksiyonunu tanımla ------
+    let karelerToplamı n =
+       [1..n]                 // 1) 1'den n'e kadar bütün sayıları al
+       |> List.map kare       // 2) hepsinin karesini al
+       |> List.sum            // 3) sonuçları topla
+
+    // test
+    karelerToplamı 100 |> printfn "kareler toplamı = %A"
+
+    // ------ Örnek: bir sıralama fonksiyonu tanımla ------
+    let rec sırala liste =
+       match liste with
+       // Liste boÅŸsa
+       | [] ->
+            []                              // boş listeyi döndür
+       // Liste boÅŸ deÄŸilse
+       | ilkEleman::diğerElemanlar ->       // İlk elemanı al
+            let küçükElemanlar =            // Daha küçük elemanları 
+                diğerElemanlar              // diğerlerinden ayır
+                |> List.filter (fun e -> e < ilkEleman)
+                |> sırala                   // ve sırala
+            let büyükElemanlar =            // Daha büyük elemanları
+                diğerElemanlar              // diğerlerinden ayır
+                |> List.filter (fun e -> e >= ilkEleman)
+                |> sırala                   // ve sırala
+            // 3 parçayı birbirine ekle ve listeyi döndür
+            List.concat [küçükElemanlar; [ilkEleman]; büyükElemanlar]
+
+    // test
+    sırala [1; 5; 23; 18; 9; 1; 3] |> printfn "Sırala = %A"
+
+// ================================================
+// Eşzamansız kod
+// ================================================
+
+module EşzamansızÖrneği =
+
+    // F# "pyramid of doom" durumuyla karşılaştırmayacak şekilde
+    // içgüdüsel eşzamansız özelliklere sahiptir.
+    //
+    // Bir sonraki örnek bir web sayfasını paralel bir şekilde indirir.
+
+    open System.Net
+    open System
+    open System.IO
+    open Microsoft.FSharp.Control.CommonExtensions
+
+    // İçeriği eşzamansız bir şekilde getir
+    let eşzamansızUrlGetir url =
+        async {   // "async" anahtar kelimesi ve kıvrık parantez
+                  // "async (eşzamansız)" nesneyi oluşturur
+            let istek = WebRequest.Create(Uri(url))
+            use! cevap = istek.AsyncGetResponse()
+                // use! eşzamansız atamadır
+            use akış = cevap.GetResponseStream()
+                // "use" kullanılan bloğun dışına çıkınca
+                // close()'u otomatik olarak tetikler
+            use okuyucu = new IO.StreamReader(akış)
+            let html = okuyucu.ReadToEnd()
+            printfn "İndirme tamamlandı: %s" url
+            }
+
+    // İndirmek için bir web sitesi listesi
+    let siteler = ["http://www.bing.com";
+                 "http://www.google.com";
+                 "http://www.microsoft.com";
+                 "http://www.amazon.com";
+                 "http://www.yahoo.com"]
+
+    // Ä°ndir
+    siteler
+    |> List.map eşzamansızUrlGetir  // eşzamansız görevlerden oluşan bir liste yap
+    |> Async.Parallel               // bu görevleri paralel çalışacak şekilde ayarla
+    |> Async.RunSynchronously       // baÅŸlat
+
+// ================================================
+// .NET uyumluluÄŸu
+// ================================================
+
+module NetUyumlulukÖrnekleri =
+
+    // F#, C#'ın yapabildiği hemen herşeyi yapabilir,
+    // ve .NET ve Mono kütüphaneleriyle tereyağından kıl çeker gibi çalışır.
+
+    // ------- var olan kütüphane fonksiyonları ile çalışma -------
+
+    let (i1başarılı, i1) = System.Int32.TryParse("123");
+    if i1başarılı then printfn "%i olarak dönüştürüldü" i1 else printfn "dönüştürme başarısız"
+
+    // ------- Arayüzleri yol üstünde tanımlayın! -------
+
+    // IDisposable'ı sağlayan yeni bir nesne oluştur
+    let kaynakOluÅŸtur isim =
+       { new System.IDisposable
+         with member this.Dispose() = printfn "%s atıldı" isim }
+
+    let kaynakKullanVeAt =
+        use r1 = kaynakOluÅŸtur "birinci kaynak"
+        printfn "birinci kaynağı kullanıyor"
+        for i in [1..3] do
+            let kaynakİsmi = sprintf "\tiç kaynak %d" i
+            use geçici = kaynakOluştur kaynakİsmi
+            printfn "\t%s ile bir ÅŸey yap" kaynakÄ°smi
+        use r2 = kaynakOluÅŸtur "ikinci kaynak"
+        printfn "ikinci kaynağı kullanıyor"
+        printfn "bitti."
+
+    // ------- Nesne yönelimli kod -------
+
+    // F# aynı zamanda tam bir nesne yönelimli dildir.
+    // Sınıfları, kalıtımı ve sanal metotları destekler.
+
+    // Genel tipli bir arayüz
+    type IEnumerator<'a> =
+        abstract member Åžimdiki : 'a
+        abstract SonrakineGeç : unit -> bool
+
+    // Sanal metotları olan soyut temel sınıflar
+    [<AbstractClass>]
+    type Åžekil() =
+        // sadece okunabilir özellikler
+        abstract member GeniÅŸlik : int with get
+        abstract member Yükseklik : int with get
+        // sanal olmayan metot
+        member this.ÇevreleyenAlan = this.Yükseklik * this.Genişlik
+        // temel uygulamasıyla bir sanal metot
+        abstract member Yazdır : unit -> unit
+        default this.Yazdır () = printfn "Ben bir şekil (önümden çekil!)"
+
+    // Somut bir sınıfın soyut sınıftan kalıtımı
+    type Dikdörtgen(x:int, y:int) =
+        inherit Åžekil()
+        override this.GeniÅŸlik = x
+        override this.Yükseklik = y
+        override this.Yazdır ()  = printfn "Ben bir dikdörtgenim"
+
+    // test
+    let r = Dikdörtgen(2, 3)
+    printfn "GeniÅŸlik: %i" r.GeniÅŸlik
+    printfn "Çevreleyen Alan: %i" r.ÇevreleyenAlan
+    r.Yazdır()
+
+    // ------- ekleme metotları -------
+
+    // C#'ta olduğu gibi F# da var olan sınıfları ekleme metotları ile genişletebilir.
+    type System.String with
+       member this.StartsWithA = this.StartsWith "A"
+
+    // test
+    let s = "Ahmet"
+    printfn "'%s' 'A' ile baÅŸlar = %A" s s.StartsWithA
+
+    // ------- olaylar -------
+
+    type Butonum() =
+        let tıklamaOlayı = new Event<_>()
+
+        [<CLIEvent>]
+        member this.OnClick = tıklamaOlayı.Publish
+
+        member this.DenemeOlayı(arg) =
+            tıklamaOlayı.Trigger(this, arg)
+
+    // test
+    let butonum = new Butonum()
+    butonum.OnClick.Add(fun (sender, arg) ->
+            printfn "arg=%O ile beraber bir tıklama olayı" arg)
+
+    butonum.DenemeOlayı("Merhaba Dünya!")
+
+```
+
+## Daha fazla bilgi
+
+F# hakkında daha fazla demo için [Try F#](http://www.tryfsharp.org/Learn) sitesine gidin, veya benim (yazarın) [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/) serimi okuyun.
+
+F# hakkında daha fazla bilgi için: [fsharp.org](http://fsharp.org/).
diff --git a/tr-tr/markdown-tr.html.markdown b/tr-tr/markdown-tr.html.markdown
index bac8f6fc..b8f11e39 100644
--- a/tr-tr/markdown-tr.html.markdown
+++ b/tr-tr/markdown-tr.html.markdown
@@ -52,7 +52,7 @@ __Bu yazı da kalın.__
 **_Bu da öyle!_**
 *__Hatta bu bile!__*
 
-<!-- Github Flavored Markdown'da ayrıca üstü çizgili karakter de desteklenir: -->
+<!-- GitHub Flavored Markdown'da ayrıca üstü çizgili karakter de desteklenir: -->
 ~~Bu yazı üstü çizili olarak gözükecek.~~
 
 <!-- Paragraflar bir veya daha fazla boş satırla ayrılır. -->
@@ -151,7 +151,7 @@ kullanabilirsiniz -->
 
 Ahmet `go_to()` fonksiyonun ne yaptığını bilmiyor!
 
-<!-- Github Flavored Markdown'da, kod içerisinde aydınlatma kullanabilirsiniz -->
+<!-- GitHub Flavored Markdown'da, kod içerisinde aydınlatma kullanabilirsiniz -->
 
 \`\`\`ruby <!-- buradaki ters slaş (\) işaretlerini kullanmayın, sadece ```ruby ! -->
 def foobar
@@ -159,7 +159,7 @@ def foobar
 end
 \`\`\` <!-- burada da (\) işaretlerini kullanmayın, sadece ``` -->
 
-<!-- Yukarıdaki örnekte girinti kullanmanıza gerek yok, Github da 
+<!-- Yukarıdaki örnekte girinti kullanmanıza gerek yok, GitHub da 
 ``` işaretinden sonra belirttiğiniz yazılım diline göre gerekli
 syntax aydınlatmaları uygulanacaktır -->
 
@@ -230,7 +230,7 @@ Bu yazının *yıldızlar arasında gözükmesini* istiyorum fakat italik olmama
 bunun için, şu şekilde: \*bu yazı italik değil, yıldızlar arasında\*.
 
 <!-- Tablolar -->
-<!-- Tablolar sadece Github Flavored Markdown'da destekleniyor ve açıkçası
+<!-- Tablolar sadece GitHub Flavored Markdown'da destekleniyor ve açıkçası
 performansı çok yoruyorlar, fakat illa ki kullanmak isterseniz: -->
 
 | Sütun1       | Sütun 2  | Sütün 3       |
diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index c7de2922..e53d5568 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -618,14 +618,19 @@ print(soyle(lutfen_soyle=True))  # Ban soda alır mısın? Lutfen! Artık dayana
 
 ### Ãœcretsiz Online
 
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
 * [Ideas for Python Projects](http://pythonpracticeprojects.com)
-
 * [The Official Docs](http://docs.python.org/3/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
 * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
 * [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
+* [Python 3 Computer Science Circles](http://cscircles.cemc.uwaterloo.ca/)
 
 ### Kitaplar
 
diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index 15056bb8..e694d95d 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -2,7 +2,7 @@
 language: swift
 contributors:
   - ["Özgür Şahin", "https://github.com/ozgurshn/"]
-filename: learnswift.swift
+filename: learnswift-tr.swift
 lang: tr-tr
 ---
 
diff --git a/tr-tr/typescript-tr.html.markdown b/tr-tr/typescript-tr.html.markdown
new file mode 100644
index 00000000..1bf674c6
--- /dev/null
+++ b/tr-tr/typescript-tr.html.markdown
@@ -0,0 +1,180 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+    - ["Mustafa Zengin", "http://zengin.github.com"]
+filename: learntypescript-tr.ts
+lang: tr-tr
+---
+
+TypeScript, JavaScript'le yazılmış büyük ölçekli uygulamaların geliştirilmesini kolaylaştırmayı hedefleyen bir dildir.
+TypeScript, JavaScript'e sınıflar, modüller, arayüzler, jenerik tipler ve (isteğe bağlı) static tipleme gibi genel konseptler ekler.
+JavaScript, TypeScript'in bir alt kümesidir: Bütün JavaScript kodları geçerli birer TypeScript kodudur ve sorunsuz herhangi bir projeye eklenebilirler. TypeScript derleyici JavaScript kodu üretir.
+
+Bu makale sadece TypeScript'e ait ekstra söz dizimini konu alır, JavaScript için bkz: [JavaScript] (../javascript/).
+
+TypeScript derleyiciyi test etmek için [Playground] (http://www.typescriptlang.org/Playground)'a gidin. Orada otomatik tamamlama ile kod yazabilecek ve üretilen JavaScript'i görebileceksiniz.
+
+```js
+// TypeScript'te üç ana tip vardır.
+var bittiMi: boolean = false;
+var satırlar: number = 42;
+var isim: string = "Anders";
+
+// Tipin bilinmediği zamanlar için "Any" tipi
+var bilinmiyor: any = 4;
+bilinmiyor = "belki de bir string'dir";
+bilinmiyor = false; // tamam, boolean olsun
+
+// Kolleksiyon olarak, tipli ve jenerik diziler
+var liste: number[] = [1, 2, 3];
+// Alternatif olarak jenerik Array tipi
+var liste: Array<number> = [1, 2, 3];
+
+// 'enum' tipleri:
+enum Renk {Kırmızı, Yeşil, Mavi};
+var r: Renk = Renk.YeÅŸil;
+
+// Son olarak, "void" hiç bir şey döndürmeyen fonksiyonlarda kullanılan tiptir.
+function çokFeciBirUyarı(): void {
+  alert("Ben biraz sinir bozucuyum!");
+}
+
+// Fonksiyonlar birinci sınıf vatandaşlardır ve "kalın ok" lambda söz dizimi "=>"
+// ve tip çıkarımı kullanırlar.
+// Aşağıda listelenenler birbirinin aynısı ve derleyici aynı fonksiyon yapısını
+// çıkaracak ve aynı JavaScript kodunu üretecektir
+var f1 = function(i: number): number { return i * i; }
+// Döndürülen tip tip çıkarımıyla belirlendi
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Döndürülen tip tip çıkarımıyla belirlendi
+var f4 = (i: number) => { return i * i; }
+// Döndürülen tip tip çıkarımıyla belirlendi
+// Tek satırlık yazımda "return" anahtar kelimesine ihtiyaç yok.
+var f5 = (i: number) =>  i * i;
+
+// Arayüzler yapısaldır, listelenen özelliklere sahip her şey arayüzle uyumludur.
+interface KiÅŸi {
+  isim: string;
+  // İsteğe bağlı özellikler "?" ile işaretlenir
+  yaÅŸ?: number;
+  // Ve fonksiyonlar...
+  hareketEt(): void;
+}
+
+// "Kişi" arayüzünü kullanan bir nesne
+// isim ve hareketEt özelliklerine sahip olduğu için Kişi olarak kullanılabilir.
+var p: KiÅŸi = { isim: "Anders", hareketEt: () => {} };
+// İsteğe bağlı özelliğe sahip bir Kişi
+var geçerliKişi: Kişi = { isim: "Anders", yaş: 42, hareketEt: () => {} };
+// Geçersiz bir kişi, çünkü yaş bir sayı (number) tipi değil
+var geçersizKişi: Kişi = { isim: "Anders", yaş: true };
+
+// Arayüzler bir fonksiyon tipi de ifade edebilirler
+interface aramaFonksiyonu {
+  (kaynak: string, altString: string): boolean;
+}
+
+// Parametrelerin sadece tipleri önemli, isimleri önemli değil
+var benimAramam: aramaFonksiyonu;
+benimAramam = function(kynk: string, alt: string) {
+  return kynk.search(alt) != -1;
+}
+
+// Sınıflar - üyeler (members) varsayılan olarak public'tir.
+class Nokta {
+  // Özellikler
+  x: number;
+
+  // Yapıcı (constructor) - bu bağlamdaki public/private anahtar kelimeleri
+  // özellikler için gerekli demirbaş kodu oluşturur ve ilk değerlerin
+  // atanmasını sağlar.
+  // Bu örnekte, "y" de "x" gibi tanımlanacak is, but with less code
+  // Default values are also supported
+
+  constructor(x: number, public y: number = 0) {
+    this.x = x;
+  }
+
+  // Fonksiyonlar
+  mesafe() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+  // Statik üyeler
+  static orijin = new Nokta(0, 0);
+}
+
+var p1 = new Nokta(10 ,20);
+var p2 = new Nokta(25); //y = 0
+
+// Kalıtım
+class Nokta3Boyutlu extends Nokta {
+  constructor(x: number, y: number, public z: number = 0) {
+    super(x, y); // süper sınıfın yapıcısını çağırmak zorunlu
+  }
+
+  // yeniden tanımlama
+  mesafe() {
+    var d = super.mesafe();
+    return Math.sqrt(d * d + this.z * this.z);
+  }
+}
+
+// Modüller, "." alt modülleri ayırmak için kullanılabilir
+module Geometri {
+  export class Kare {
+    constructor(public kenarUzunluÄŸu: number = 0) {
+    }
+    alan() {
+      return Math.pow(this.kenarUzunluÄŸu, 2);
+    }
+  }
+}
+
+var s1 = new Geometri.Kare(5);
+
+// Modüle atıfta bulunmak için yerel takma ad
+import G = Geometri;
+
+var s2 = new G.Kare(10);
+
+// Jenerik Tipler
+// Sınıflar
+class Tuple<T1, T2> {
+  constructor(public item1: T1, public item2: T2) {
+  }
+}
+
+// Arayüzler
+interface Çift<T> {
+  item1: T;
+  item2: T;
+}
+
+// Ve fonksiyonlar
+var çifttenTupleÜret = function<T>(p: Çift<T>) {
+  return new Tuple(p.item1, p.item2);
+};
+
+var tuple = çifttenTupleÜret({ item1:"merhaba", item2:"dünya"});
+
+// Tanım dosyasına atıfta bulunma:
+/// <reference path="jquery.d.ts" />
+
+// Åžablon Stringleri (ters apostrof kullanan stringler)
+// Şablon Stringlerinin kullanımı
+var isim = 'Anders';
+var selamlama = `Merhaba ${isim}, nasılsın?`
+// Şablon Stringleri ile çok satırlı stringler
+var çokSatırlıString = `Bu çok satırlı
+bir string örneği`;
+
+```
+
+## Daha fazlası
+ * [TypeScript Resmi Sitesi] (http://www.typescriptlang.org/)
+ * [TypeScript dil spesifikasyonu (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Channel 9'da TypeScript'e GiriÅŸ] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [GitHub'ta Açık Kaynak Kodu] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - tip tanımları için kaynak] (http://definitelytyped.org/)