From a13f2f5e954b9d5448f8277a5912d25d5a88ff34 Mon Sep 17 00:00:00 2001
From: The Gitter Badger <badger@gitter.im>
Date: Sat, 28 Jan 2017 12:21:40 +0000
Subject: [PATCH 01/74] Add Gitter badge

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 4be63dfbb..a93282a3c 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,8 @@
 TypeScript Deep Dive
 =======
 
+[![Join the chat at https://gitter.im/codefiction/typescript-book](https://badges.gitter.im/codefiction/typescript-book.svg)](https://gitter.im/codefiction/typescript-book?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
 I've been looking at the issues that turn up commonly when people start using TypeScript. This is based on the lessons from [StackOverflow](http://stackoverflow.com/tags/typescript/topusers) / [DefinitelyTyped](https://github.com/DefinitelyTyped/) and general engagement with the [TypeScript community](https://github.com/TypeStrong/). You can [follow for updates](https://twitter.com/basarat) and [don't forget to ★ on Github](https://github.com/basarat/typescript-book) 🌹
 
 ## Reviews

From 7ae15cb0606a781e411c2c61357673c94d8ae718 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mahmut=20G=C3=BCndo=C4=9Fdu?=
 <mahmutgundogdu@hotmail.com.tr>
Date: Sun, 29 Jan 2017 13:22:27 +0200
Subject: [PATCH 02/74] Update CONTRIBUTING.md

---
 CONTRIBUTING.md | 33 ++++++++++-----------------------
 1 file changed, 10 insertions(+), 23 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index f48d44b7a..dabb69c72 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,23 +1,10 @@
-# Contributing
-
-This book is developed using [GitBook](https://github.com/GitbookIO/gitbook). Authored in Markdown files (I use [atom](http://atom.io)).
-
-Here's how to setup a Dev Environment:
-
-```
-npm install gitbook-cli -g
-gitbook serve .
-```
-Note: serve needs port `35729` (for live reload) and `4000` for serving http://localhost:4000.
-
-Also you can mostly just edit the `.md` files in [`/docs`](https://github.com/basarat/typescript-book/docs) using github and create a Pull Request (PR).
-
-# Code
-All the code for the book is in the `/code` folder. Tested with `atom-typescript`.
-
-#### More Gitbook Tips
-* Links best work if they are relative (e.g `./foo.md`) to the *current* file.
-* For links in the same file (`#foo-bar` style links) best to click the heading on github to get what gitbook expects.
-
-### TypeScript Compiler Docs
-Thanks to the TypeScript team for providing much of the docs : https://github.com/Microsoft/TypeScript/wiki/Architectural-Overview that are used to write the compiler story.
+ # Katkıda bulunmak için dikkat edilecekler
+
+- Öncelikle ingilizceye çevirdikten sonra iki farklı kişi gözden geçirecek. İki kişi onaylarsa merge edilecek. Pull requesti merge edecek kişi aynı isimle sonuna "gozden-gecirilecek" ekleyerek yeni bir issue açacak. Bu issue ile amaç imla kuralları ve yazımı denetlemek.
+- Çeviri ile ilgili görevler(issue) https://github.com/CodeFiction/typescript-book/issues adresinde mevcuttur. Buradan yapmak istediğiniz görevi kendinize 'assign' etmeniz yeterli. 
+- Atanmıs bir issue ile ilgili yardımcı olabilecekseniz issue sahibi ile iletişim geçilmeli.
+- Üzerinizdeki görevi(issue) bırakmanız gerekirse lütfen topluluğu haberdar ediniz.
+- Çeviri yapmak için öncelikle "fork" edip. Sonra pull request göndermeniz gerekli. 
+- Çeviri yaparken birebir çeviriden ziyade okuyacak kişinin türkçe olarak anlayabileceği şekilde olmasını hedefliyoruz.
+- Çeviri ile ilgili terimlerin ortak olarak olarak anlamlarının tutulduğu yer GLOSSARY.md dosyasıdır.
+- Görüş ve önerileriniz için gitter kanalına bekleriz. https://gitter.im/codefiction/typescript-book

From 155f2c8642083c299d6b67c8efd4eda03dd214a7 Mon Sep 17 00:00:00 2001
From: Onur Aykac <onuraykac@gmail.com>
Date: Sun, 29 Jan 2017 15:18:18 +0200
Subject: [PATCH 03/74] =?UTF-8?q?S=C3=B6zl=C3=BCk=20init?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 GLOSSARY.md | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/GLOSSARY.md b/GLOSSARY.md
index c0db2ff13..5a883aef3 100644
--- a/GLOSSARY.md
+++ b/GLOSSARY.md
@@ -1,8 +1,23 @@
-# Duck Typing
-If it walks like a duck and quacks like a duck, it is a duck. For TypeScript if it has all the members structurally then it is okay for other things (irrespecitive of name) that accept that structure.
+# Özet bilgi
+## Amaç
+Bu sözlük ile, kitaptaki anlam ve kelime bütünlüğünün sağlanması hedeflenmektedir. 
 
-# OE
-Operating Environment. I'd like to use the term Operating System, but that is not necessarily what I mean here. Think Browser,Node.js,WScriptHost etc.
+## Kullanım
+Çeviri yapılırken karşılaşılan teknik terimlerin Türkçe çevirilerini yapmadan önce bu sayfaya göz atılması gerekmektedir. Aşağıdaki sözlük tablosunda, çevirisi yapılacak olan teknik terimin kabul edilmiş bir karşılığı varsa, bu karşılığın kullanılması gerekmektedir.
 
-# Incremental Parsing
-Re-Parsing as the user edits the code.
\ No newline at end of file
+Eğer sözlükte olmayan bir terim ile karşılaşılmışsa, istenilen çeviri, tabloya da girilerek gönderilir.
+
+Fakat bazı terimlerin Türkçe çevirimi, cümleyi anlamsız bir hale getirebilmektedir. Bunun için "terim açıklamaları" bölümü kullanılıp, buraya bağlantı verilebilir.
+
+
+# Sözlük
+| İngilizce        | Türkçe           |
+| ------------------------------------- |---------------------------------------|
+| Hello world!     | Merhaba dünya! |
+| Issue | Madde|
+| Contributor | Katkıda bulunan kişi |
+| Object | Nesne |
+| Event | Olay |
+
+# Terim açıklamaları
+* Duck Typing: Eğer bir ördek gibi yürüyor ve bir ördek gibi "vak"lıyorsa, o zaman bu bir ördektir. Bir obje yapısal olarak tüm üyelere sahipse, diğer şeylerin de (ne olduğu önemli değil) var olduğu kabul edilir.

From e78f35502b917b00474494be163a06f96e21a357 Mon Sep 17 00:00:00 2001
From: Onur Aykac <onuraykac@gmail.com>
Date: Sun, 29 Jan 2017 15:18:18 +0200
Subject: [PATCH 04/74] Review edildi.

---
 GLOSSARY.md | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/GLOSSARY.md b/GLOSSARY.md
index c0db2ff13..60e5b0352 100644
--- a/GLOSSARY.md
+++ b/GLOSSARY.md
@@ -1,8 +1,23 @@
-# Duck Typing
-If it walks like a duck and quacks like a duck, it is a duck. For TypeScript if it has all the members structurally then it is okay for other things (irrespecitive of name) that accept that structure.
+# Özet bilgi
+## Amaç
+Bu sözlük ile, kitaptaki anlam ve kelime bütünlüğünün sağlanması hedeflenmektedir. 
 
-# OE
-Operating Environment. I'd like to use the term Operating System, but that is not necessarily what I mean here. Think Browser,Node.js,WScriptHost etc.
+## Kullanım
+Çeviri yapılırken karşılaşılan teknik terimlerin Türkçe çevirilerini yapmadan önce bu sayfaya göz atılması gerekmektedir. Aşağıdaki sözlük tablosunda, çevirisi yapılacak olan teknik terimin kabul edilmiş bir karşılığı varsa, bu karşılığın kullanılması gerekmektedir.
 
-# Incremental Parsing
-Re-Parsing as the user edits the code.
\ No newline at end of file
+Eğer sözlükte olmayan bir terim ile karşılaşılmışsa, istenilen çeviri, tabloya da girilerek gönderilir.
+
+Fakat bazı terimlerin Türkçe çevrimi, cümleyi anlamsız bir hale getirebilmektedir. Bunun için "terim açıklamaları" bölümü kullanılıp, buraya bağlantı verilebilir.
+
+
+# Sözlük
+| İngilizce        | Türkçe           |
+| ------------------------------------- |---------------------------------------|
+| Hello world!     | Merhaba dünya! |
+| Issue | Görev|
+| Contributor | Katkıda bulunan kişi |
+| Object | Nesne |
+| Event | Olay |
+
+# Terim açıklamaları
+* Duck Typing: Eğer bir ördek gibi yürüyor ve bir ördek gibi "vak"lıyorsa, o zaman bu bir ördektir. Bir nesne yapısal olarak tüm üyelere sahipse, diğer şeylerin de (ne olduğu önemli değil) var olduğu kabul edilir.

From 3903deb882eaa20d6d0d9b1962136d9a5ebdc7d4 Mon Sep 17 00:00:00 2001
From: Murat Mustafa Dinler <m.mustafadinler@gmail.com>
Date: Sun, 29 Jan 2017 20:38:32 +0300
Subject: [PATCH 05/74] =?UTF-8?q?lint=20kelimesini=20=C3=A7eviremedim?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/javascript/recap.md | 42 ++++++++++++++++++++--------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/docs/javascript/recap.md b/docs/javascript/recap.md
index 5bd784069..69e59d2ed 100644
--- a/docs/javascript/recap.md
+++ b/docs/javascript/recap.md
@@ -1,41 +1,41 @@
-# Your JavaScript is TypeScript
+# JavaScript'iniz TypeScript'tir.
 
-There were (and will continue to be) a lot of competitors in *Some syntax* to *JavaScript* compilers. TypeScript is different from them in that *Your JavaScript is TypeScript*. Here's a diagram:
+Bazı sözdiziminden JavaScript derleyicilerine kadar birçok rakip vardı (ve olmaya devam edecektir). TypeScript onlardan şu şekilde farklıdır *JavaScript'iniz TypeScript'tir*. İşte bir şema:
 
 ![](https://raw.githubusercontent.com/basarat/typescript-book/master/images/venn.png)
 
-However it does mean that *you need to learn JavaScript* (the good news is *you **only** need to learn JavaScript*). TypeScript is just standardizing all the ways you provide *good documentation* on JavaScript.
+Ancak bunun anlamı *JavaScript öğrenmeniz gerekir* (iyi haber şu ki *sizin **sadece** JavaScript öğrenmeniz gerekmektedir*). TypeScript sadece JavaScript'teki sunulan *iyi dökümantasyon'u* standartlaştırmaktadır.
 
-* Just giving you a new syntax doesn't help fix bugs (looking at you CoffeeScript).
-* Creating a new language abstracts you too far from your runtimes, communities (looking at you Dart).
+* Size yeni bir sözdizimi verilmesi hataların düzeltilmesine yardımcı olmaz (CoffeeScript, gözüm üzerinde).
+* Yeni bir dil oluşturmak sizi çalışma zamanı ortamlarınızdan ve topluluklarınızdan uzaklaşmanızı sağlar (Dart, gözüm üzerinde).
 
-TypeScript is just JavaScript with docs.
+TypeScript, dökümanlarla JavaScript'tir.
 
-## Making JavaScript Better
+## JavaScript'i İyileştirmek
 
-TypeScript will try to protect you from portions of JavaScript that never worked (so you don't need to remember this stuff):
+TypeScript sizi hiç çalışmamış JavaScript parçalarından korumaya çalışacaktır (Bu sebeple bunları hatırlamanıza gerek yok):
 
 ```ts
-[] + []; // JavaScript will give you "" (which makes little sense), TypeScript will error
+[] + []; // JavaScript size "" verecek (ki mantıklı olan), TypeScript ise hata
 
 //
-// other things that are nonsensical in JavaScript
-// - don't give a runtime error (making debugging hard)
-// - but TypeScript will give a compile time error (making debugging unnecessary)
+// JavaScript'te saçma olan diğer konular
+// - çalışma zamanı hatası verme (hata ayıklamayı zorlaştırıyor)
+// - ama TypeScript çalışma zamanı hatası verecek (hata ayıklamayı gereksizleştiriyor)
 //
-{} + []; // JS : 0, TS Error
-[] + {}; // JS : "[object Object]", TS Error
-{} + {}; // JS : NaN, TS Error
-"hello" - 1; // JS : NaN, TS Error
+{} + []; // JS : 0, TS Hata
+[] + {}; // JS : "[object Object]", TS Hata
+{} + {}; // JS : NaN, TS Hata
+"merhaba" - 1; // JS : NaN, TS Hata
 
-function add(a,b) {
+function ekle(a,b) {
   return
-    a + b; // JS : undefined, TS Error 'unreachable code detected'
+    a + b; // JS : undefined, TS Hata 'unreachable code detected'
 }
 ```
 
-Essentially TypeScript is linting JavaScript. Just doing a better job at it than other linters that don't have *type information*.
+Esasen TypeScript JavaScript'i lint eder. Sadece tür bilgisi olmayan diğer lint araçlarından daha iyi bir iş çıkarıyor.
 
-## You still need to learn JavaScript
+## Hala JavaScript öğrenmeniz gerekiyor
 
-That said TypeScript is very pragmatic about the fact that *you do write JavaScript* so there are some things about JavaScript that you still need to know in order to not be caught off-guard. Let's discuss them next.
+Bunun anlamı TypeScript *JavaScript yazmanız* gerçeği hakkında çok pragmatik yani gafil avlanmamanız için JavaScript ile ilgili hala farkına varmanız gereken bazı şeyler var. Gelin sırada bunları tartışalım.

From ef5a80097727798399c8cb514ae362f523b2f0a3 Mon Sep 17 00:00:00 2001
From: Murat Mustafa Dinler <m.mustafadinler@gmail.com>
Date: Sun, 29 Jan 2017 22:32:40 +0300
Subject: [PATCH 06/74] =?UTF-8?q?UgurAldanmaz=20review=20sonras=C4=B1=20d?=
 =?UTF-8?q?=C3=BCzeltmeler?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/javascript/recap.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/javascript/recap.md b/docs/javascript/recap.md
index 69e59d2ed..e7475f58c 100644
--- a/docs/javascript/recap.md
+++ b/docs/javascript/recap.md
@@ -16,12 +16,12 @@ TypeScript, dökümanlarla JavaScript'tir.
 TypeScript sizi hiç çalışmamış JavaScript parçalarından korumaya çalışacaktır (Bu sebeple bunları hatırlamanıza gerek yok):
 
 ```ts
-[] + []; // JavaScript size "" verecek (ki mantıklı olan), TypeScript ise hata
+[] + []; // JavaScript size "" sonucunu verecek (ki mantıklı olan), TypeScript ise hata
 
 //
-// JavaScript'te saçma olan diğer konular
-// - çalışma zamanı hatası verme (hata ayıklamayı zorlaştırıyor)
-// - ama TypeScript çalışma zamanı hatası verecek (hata ayıklamayı gereksizleştiriyor)
+// JavaScript'te anlamsız olan diğer konular
+// - çalışma zamanı hatası vermez (hata ayıklamayı zorlaştırıyor)
+// - ama TypeScript derleme zamanı hatası verecek (hata ayıklamayı gereksizleştiriyor)
 //
 {} + []; // JS : 0, TS Hata
 [] + {}; // JS : "[object Object]", TS Hata
@@ -34,8 +34,8 @@ function ekle(a,b) {
 }
 ```
 
-Esasen TypeScript JavaScript'i lint eder. Sadece tür bilgisi olmayan diğer lint araçlarından daha iyi bir iş çıkarıyor.
+Esasen TypeScript JavaScript'i potansiyel hatalar için analiz eder. Sadece benzer işi yapıp, tür bilgisi olmayan diğerlerinden daha iyi bir iş çıkarıyor.
 
 ## Hala JavaScript öğrenmeniz gerekiyor
 
-Bunun anlamı TypeScript *JavaScript yazmanız* gerçeği hakkında çok pragmatik yani gafil avlanmamanız için JavaScript ile ilgili hala farkına varmanız gereken bazı şeyler var. Gelin sırada bunları tartışalım.
+Bunun anlamı TypeScript *JavaScript yazmanız* gerçeği hakkında oldukça pragmatiktir. Yani gafil avlanmamanız için JavaScript ile ilgili hala farkına varmanız gereken bazı şeyler var. Gelin şimdi bunları tartışalım.

From 5c1cefa511d6c227c1d240b64978903b2925dd73 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Atar?= <ugur.atar@metry.io>
Date: Sun, 29 Jan 2017 22:47:58 +0100
Subject: [PATCH 07/74] =?UTF-8?q?Spread=20operat=C3=B6r=C3=BC=20=C3=A7evir?=
 =?UTF-8?q?isi?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/spread-operator.md | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/docs/spread-operator.md b/docs/spread-operator.md
index ae8e01766..cc736e027 100644
--- a/docs/spread-operator.md
+++ b/docs/spread-operator.md
@@ -1,9 +1,8 @@
-### Spread Operator
-
-The main objective of the spread operator is to *spread* the objects of an array. This is best explained with examples.
+### Spread (Yayma) Operatörü
+Spread (Yayma) operatörünün ana hedefi bir dizinin elemanlarını *yaymaktır*. Bu operatörü açıklamak için örnekleri kullanacağız.
 
 #### Apply
-A common use case is to spread an array into the function arguments. Previously you would need to use `Function.prototype.apply`:
+Yayma işleminin en yaygın kullanımlarından biri, dizinin elemanlarını bir fonksiyonun argümanları olarak kullanmaktır. Önceki sürümlerde bu işlemi yapmak için `Function.prototype.apply` ifadesini kullanmanız gerekmekteydi. 
 
 ```ts
 function foo(x, y, z) { }
@@ -11,7 +10,7 @@ var args = [0, 1, 2];
 foo.apply(null, args);
 ```
 
-Now you can do this simply by prefixing the arguments with `...` as shown below:
+Şimdi ise bu işlemi yapmak için gereken tek şey, aşağıdaki örnekte de görüleceği üzere, fonksiyon argümanlarınızın önüne `...` eklemektir.
 
 ```ts
 function foo(x, y, z) { }
@@ -19,19 +18,19 @@ var args = [0, 1, 2];
 foo(...args);
 ```
 
-Here we are *spreading* the `args` array into positional `arguments`.
+Yukarıdaki örnekte `args` dizisini fonksiyon argümanlarına dönüşecek şekilde yayıyoruz.
 
-#### Destructuring
-We've already seen one usage of this in *destructuring*
+#### Parçalama (Sökme)
+Bu konunun bir örneğini *destructuring* bölümünde görmüştük.
 
 ```ts
 var [x, y, ...remaining] = [1, 2, 3, 4];
 console.log(x, y, remaining); // 1, 2, [3,4]
 ```
-The motivation here is to simply make it easy for you to capture the remaining elements of an array when destructuring.
+Bu örnekteki amaç, diziyi parçalarken dizide kalan eşleşmemiş elemanları kolay bir şekilde yakalayarak bir değişkene atamaktır.  
 
-#### Array Assignment
-The spread operator allows you to easily place an *expanded version* of an array into another array. This is demonstrated in the example below:
+#### Dizi Atama
+Yayma operatörü, bir dizinin *yayılmış (genişletilmiş) versiyonunu* kolaylıkla başka bir dizinin içerisine yerleştirmenize olanak sağlar. Aşağıda bunun bir örneğini görebilirsiniz:
 
 ```ts
 var list = [1, 2];
@@ -39,8 +38,8 @@ list = [...list, 3, 4];
 console.log(list); // [1,2,3,4]
 ```
 
-#### Summary
-`apply` is something that you would inevitably do in JavaScript, so it's good to have a better syntax where you don't have that ugly `null` for the `this` argument. Also having a dedicated syntax for moving arrays out of (destructuring) or into (assignment) other arrays provides neat syntax for when you are doing array processing on partial arrays.
-
+#### Özet
+`apply` fonksiyonu JavaScript ile çalışırken kaçınılmaz olarak kullanacağınız bir ifadedir, bu sebeple `apply` fonksiyonunun ilk argümanı olan `this` yerine uygunsuz ve neredeyse çirkin denilebilecek bir sözdizimine yol açan`null` kullanmak yerine daha düzgün bir sözdizimi getiren *spread (yayma) operatörü* kullanmayı tercih edebilirsiniz. 
+Bununla birlikte  *spread (yayma) operatörü*,  kısmı diziler üzerinden yapılan parçalamak ve birleştirme işlemleri için çok daha zarif bir söz dizimi sunmaktadır.
 
 [](https://github.com/Microsoft/TypeScript/pull/1931)

From 121d555e2ec37b79f8545ef3f4e37058fc9b06d0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Atar?= <ugur.atar@metry.io>
Date: Sun, 29 Jan 2017 22:50:39 +0100
Subject: [PATCH 08/74] =?UTF-8?q?#13=20Spread=20Operat=C3=B6r=C3=BC=20?=
 =?UTF-8?q?=C3=A7evirisi?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/spread-operator.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/spread-operator.md b/docs/spread-operator.md
index cc736e027..afc2523f8 100644
--- a/docs/spread-operator.md
+++ b/docs/spread-operator.md
@@ -29,7 +29,7 @@ console.log(x, y, remaining); // 1, 2, [3,4]
 ```
 Bu örnekteki amaç, diziyi parçalarken dizide kalan eşleşmemiş elemanları kolay bir şekilde yakalayarak bir değişkene atamaktır.  
 
-#### Dizi Atama
+#### Dizi Atama (Birleştirme)
 Yayma operatörü, bir dizinin *yayılmış (genişletilmiş) versiyonunu* kolaylıkla başka bir dizinin içerisine yerleştirmenize olanak sağlar. Aşağıda bunun bir örneğini görebilirsiniz:
 
 ```ts

From 8fd139538f1774fd81e1a7ab88b63caf96dfbc6e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mahmut=20G=C3=BCndo=C4=9Fdu?=
 <mahmutgundogdu@hotmail.com.tr>
Date: Mon, 30 Jan 2017 09:11:45 +0200
Subject: [PATCH 09/74] =?UTF-8?q?Pr=20sonras=C4=B1=20yorumlardaki=20d?=
 =?UTF-8?q?=C3=BCzeltmeler=20yap=C4=B1ld=C4=B1.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CONTRIBUTING.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index dabb69c72..d89baf959 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,10 +1,10 @@
  # Katkıda bulunmak için dikkat edilecekler
 
-- Öncelikle ingilizceye çevirdikten sonra iki farklı kişi gözden geçirecek. İki kişi onaylarsa merge edilecek. Pull requesti merge edecek kişi aynı isimle sonuna "gozden-gecirilecek" ekleyerek yeni bir issue açacak. Bu issue ile amaç imla kuralları ve yazımı denetlemek.
-- Çeviri ile ilgili görevler(issue) https://github.com/CodeFiction/typescript-book/issues adresinde mevcuttur. Buradan yapmak istediğiniz görevi kendinize 'assign' etmeniz yeterli. 
-- Atanmıs bir issue ile ilgili yardımcı olabilecekseniz issue sahibi ile iletişim geçilmeli.
+- Öncelikle İngilizce'ye çevirdikten sonra iki farklı kişi gözden geçirecek. İki kişi onaylarsa merge edilecek. Pull request'i merge edecek kişi aynı isimle sonuna "gözden geçirilecek" ekleyerek yeni bir issue açacak. Bu issue ile amaç imla kuralları ve yazımı denetlemek.
+- Çeviri ile ilgili görevler(issue) https://github.com/CodeFiction/typescript-book/issues adresinde mevcuttur. Katkıda bulunmak istediğiniz konuya yorum bırakarak son durumu sorabilirsiniz. Katılmak için talepte bulunabilirsiniz. 
+- Atanmış bir issue ile ilgili yardımcı olabilecekseniz issue sahibi ile iletişim geçilmelisiniz.
 - Üzerinizdeki görevi(issue) bırakmanız gerekirse lütfen topluluğu haberdar ediniz.
 - Çeviri yapmak için öncelikle "fork" edip. Sonra pull request göndermeniz gerekli. 
-- Çeviri yaparken birebir çeviriden ziyade okuyacak kişinin türkçe olarak anlayabileceği şekilde olmasını hedefliyoruz.
-- Çeviri ile ilgili terimlerin ortak olarak olarak anlamlarının tutulduğu yer GLOSSARY.md dosyasıdır.
+- Çeviri yaparken hedefimiz birebir çeviriden ziyade, bir Türk okuyucu için anlamlı cümlelerin oluşturulmasıdır.
+- Teknik terimlerin çevirisinde bir bütünlük sağlamak amacı ile bir [sözlük](GLOSSARY.md) oluşturulmuştur. Lütfen çevirinizi yaparken ve bir Pull Request'i incelerken bu sözlükte yer alan terimleri takip ediniz. 
 - Görüş ve önerileriniz için gitter kanalına bekleriz. https://gitter.im/codefiction/typescript-book

From c9ed178f79b1aa1652ab9e59aa8ddb414495ac5f Mon Sep 17 00:00:00 2001
From: DorukUlucay <doruk.ulucay@cronom.com>
Date: Mon, 30 Jan 2017 22:46:45 +0200
Subject: [PATCH 10/74] started work on promise.md

---
 docs/promise.md | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/docs/promise.md b/docs/promise.md
index c30da0beb..7fcb934b2 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -1,10 +1,10 @@
 ## Promise
 
-The `Promise` class is something that exists in many modern JavaScript engines and can be easily [polyfilled][polyfill]. The main motivation for promises is to bring synchronous style error handling to Async / Callback style code.
+Promise, pek çok modern Javascript motorunda bulunan ve rahatlıkla polyfill edilebilen bir sınıftır. Promise'lerin öncelikli amacı Async/Callback stili yazılmış koda senkronize stilde hata yakalama fonksiyonunu kazandırmaktır.
 
 ### Callback style code
 
-In order to fully appreciate promises let's present a simple sample that proves the difficulty of creating reliable Async code with just callbacks. Consider the simple case of authoring an async version of loading JSON from a file. A synchronous version of this can be quite simply
+Promise'in sağladığı kolaylıkları daha iyi anlamak için sadece Callback kullanarak Async kod yazan bir örnek görelim. Bir JSON dosyasından asenkron bir şekilde dosya okuma örneğini değerlendirelim. Senkronize bir vesiyonu oldukça kolay olacaktır:
 
 ```ts
 import fs = require('fs');
@@ -13,10 +13,10 @@ function loadJSONSync(filename: string) {
     return JSON.parse(fs.readFileSync(filename));
 }
 
-// good json file
+// geçerli json dosyası
 console.log(loadJSONSync('good.json'));
 
-// non-existent file, so fs.readFileSync fails
+// olmayan json dosyası. bu yüzden fs.readFilesync hata verir
 try {
     console.log(loadJSONSync('absent.json'));
 }
@@ -24,7 +24,7 @@ catch (err) {
     console.log('absent.json error', err.message);
 }
 
-// invalid json file i.e. the file exists but contains invalid JSON so JSON.parse fails
+// geçersiz json dosyası. dosya var ama içindeki JSON geçersiz. bu yüzden JSON.parse hata verir
 try {
     console.log(loadJSONSync('invalid.json'));
 }
@@ -33,7 +33,7 @@ catch (err) {
 }
 ```
 
-There are three behaviors of this simple `loadJSONSync` function, a valid return value, a file system error or a JSON.parse error. We handle the errors with a simple try/catch as you are used to when doing synchronous programming in other languages. Now let's make a good async version of such a function. A decent initial attempt with a trivial error checking logic would be as follows,
+Bu basit `loadJSONSync` fonksiyonunun üç davranışı vardır. Geçerli bir dönüş değeri, bir dosya sistemi hatası ya da JSON.parse hatası. Bu hataları diğer senkronize çalışan dillerde yaptığımız gibi basit try/catch bloğu ile yakalıyoruz. Şimdi bu fonksiyonun düzgün çalışan bir asenkron versiyonunu yapalım. Düzgün bir ilk deneme (with a trivial error checking) aşağıdaki şekilde olacaktır.
 
 ```ts
 import fs = require('fs');
@@ -47,12 +47,12 @@ function loadJSON(filename: string, cb: (error: Error, data: any) => void) {
 }
 ```
 
-Simple enough, it takes a callback, passes any file system errors to the callback. If no filesystem errors, it returns the `JSON.parse` result. A few points to keep in mind when working with async functions based on callbacks are
+Yeteri kadar basit, bir callback alır, bulduğu dosya sistemi hatalarını callback'e iletir. Eğer dosya sistemi hatası yok ise JSON.parse işleminin sonucunu döndürür. Callback'lere dayalı asenkron fonksiyonlarla çalışılırken unutulmaması gereken noktalar:
 
-1. Never call the callback twice.
-1. Never throw an error.
+1. Bir callback'i asla iki defa çağırmamak
+2. Asla hata fırlatmamak
 
-This simple function however fails to accommodate for point two. In fact `JSON.parse` throws an error if it is passed bad JSON and the callback never gets called and the application crashes. This is demonstrated in the below example:
+Bu basit fonksiyon 2. noktada çalışmakta problem yaşıyor. Aslında eğer geçersiz JSON verilir ise, JSON.parse hata verir, callback hiçbir zaman çağırılmaz ve uygulama çöker. Bu durum aşağıdaki örnekte gösterilmiştir.
 
 ```ts
 import fs = require('fs');
@@ -73,7 +73,7 @@ loadJSON('invalid.json', function (err, data) {
 });
 ```
 
-A naïve attempt at fixing this would be to wrap the `JSON.parse` in a try catch as shown in the below example:
+Bu durumu düzeltmek için naifçe bir çaba, JSON.parse'ı bir try/catch'e almak olurdu, aşağıdaki örnekteki gibi:
 
 ```ts
 import fs = require('fs');
@@ -102,6 +102,7 @@ loadJSON('invalid.json', function (err, data) {
 });
 ```
 
+Yine de bu kodda yakalaması zor bir hata var. Eğer JSON.parse değil de callback hata fırlatırsa, biz bunu try catch ile sarmaladığımız için catch çalışır ve callback'i bir daha çağırırız. Bu örnekte callback iki defa çağırılır! Bu aşağıdaki örnekte gösterilmiştir:
 However there is a subtle bug in this code. If the callback (`cb`), and not `JSON.parse`, throws an error, since we wrapped it in a `try`/`catch`, the `catch` executes and we call the callback again i.e. the callback gets called twice! This is demonstrated in the example below:
 
 ```ts
@@ -144,11 +145,11 @@ our callback called
 Error: Cannot read property 'bar' of undefined
 ```
 
-This is because our `loadJSON` function wrongfully wrapped the callback in a `try` block. There is a simple lesson to remember here.
+Bunun sebebi `loadJSON` fonksiyonumuzun yanlış biçimde callback'i bir `try` bloğu ile sarmalamış olmasıdır. Burada hatırlanması gereken küçük bir ders var.
 
-> Simple lesson: Contain all your sync code in a try catch, except when you call the callback.
+> küçük Bir Ders: Tüm senkronize kodunuzu bir try/catch içine alın, callback'i çağırdığnız yer hariç.
 
-Following this simple lesson, we have a fully functional async version of `loadJSON` as shown below:
+Bu küçük dersi takip ederek `loadJSON` metodumuzun tamamen fonksiyonel asenkron çalışan bir versiyonunu elde ediyoruz:
 
 ```ts
 import fs = require('fs');

From aa87f539306d57f5b0352af90933978b226c582d Mon Sep 17 00:00:00 2001
From: vceylan <veyselceylan@yandex.com>
Date: Tue, 31 Jan 2017 11:20:35 +0300
Subject: [PATCH 11/74] Update iterators.md

---
 docs/iterators.md | 54 +++++++++++++++++++++++------------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/docs/iterators.md b/docs/iterators.md
index 59c194fd4..ef914a29b 100644
--- a/docs/iterators.md
+++ b/docs/iterators.md
@@ -1,8 +1,7 @@
-### Iterators
+### Yineleyiciler
 
-Iterator itself is not a TypeScript or ES6 feature, Iterator is a
-Behavioral Design Pattern common for Object oriented programming languages.
-It is, generally, an object which implements the following interface:
+Yineleyici kavramı ne TypeScript ne de ES6'e ait bir özelliktir. Yineleyici Nesneye Dayalı Programlama dilleri için ortak bir davranışsal tasarım desenidir.
+Bu kavram, genellikle, aşağıdaki arayüzü uygulayan nesnedir:
 
 ```ts
 interface Iterator<T> {
@@ -12,12 +11,10 @@ interface Iterator<T> {
 }
 ```
 
-This interface allows to retrieve a value from some collection or sequence
-which belongs to the object.
+Bu arayüz, nesneye ait olan bir koleksiyon veya diziden değer elde etmeyi sağlar.
 
-Imagine that there's an object of some frame, which includes the list of
-components of which this frame consists. With Iterator interface it is possible
-to retrieve components from this frame object like below:
+Kendisini oluşturan bileşenlerin listesini içeren yapıya ait bir nesne tasarlanmış olduğunu düşünün.
+Yineleyici arayüzü ile bu nesneden bileşenlerini almak aşağıdaki gibi mümkündür:
 
 ```ts
 'use strict';
@@ -54,16 +51,17 @@ let iteratorResult3 = frame.next(); //{ done: false, value: Component { name: 'l
 let iteratorResult4 = frame.next(); //{ done: false, value: Component { name: 'right' } }
 let iteratorResult5 = frame.next(); //{ done: true }
 
-//It is possible to access the value of iterator result via the value property:
+//Yineleyici sonucunun değerine 'value' özelliği aracılığıyla ulaşmak mümkündür.
 let component = iteratorResult1.value; //Component { name: 'top' }
 ```
-Again. Iterator itself is not a TypeScript feature, this code could work without
-implementing Iterator and IteratorResult interfaces explicitly.
-However it is very helpful to use these common
-ES6 [interfaces](./types/interfaces.md) for code consistency.
 
-Ok, Nice, but could be more helpful. ES6 defines the *iterable protocol*
-which includes [Symbol.iterator] `symbol` if Iterable interface implemented:
+Tekrar belirtmek gerekirse yineleyici bir TypeScript özelliği değildir.  Bu kod Iterator ve IteratorResult arayüzlerini açıkça uygulamadan da çalışabilir.
+
+Ancak, kod tutarlılığı için, bu ortak ES6 arayüzlerini (./types/interfaces.md) kullanmak çok yararlı olacaktır.
+
+Peki, iyi güzel, fakat daha da yararlı nasıl kullanabilir? ES6 [Symbol.iterator] `sembol` içeren *tekrarlanabilir protokol* tanımlar. 
+Iterable arayüzü şu şekilde uygulanabilir:
+
 ```ts
 //...
 class Frame implements Iterable<Component> {
@@ -102,8 +100,9 @@ for (let cmp of frame) {
 }
 ```
 
-Unfortunately `frame.next()` won't work with this pattern and it also looks
-a bit clunky. IterableIterator interface to the rescue!
+Ne yazık ki bu tasarımla `frame.next()` çalışmaz ve bir takım işler eksikmiş gibi gözükür. 
+IterableIterator arayüzü durumu kurtarmak için imdadımıza şu şekilde yetişir:
+
 ```ts
 //...
 class Frame implements IterableIterator<Component> {
@@ -132,10 +131,12 @@ class Frame implements IterableIterator<Component> {
 }
 //...
 ```
-Both `frame.next()` and `for` cycle now work fine with IterableIterator interface.
 
-Iterator does not have to iterate a finite value.
-The typical example is a Fibonacci sequence:
+IterableIterator arayüzü ile `frame.next()` ve `for` döngüleri olması gerektiği gibi çalışabilir.
+
+Yineleyicinin sonlu bir değeri yinelemesi gerekmez.
+Bununla ilgili tipik örnek olarak Fibonacci dizisi şu şekilde uygulanır:
+
 ```ts
 class Fib implements IterableIterator<number> {
 
@@ -183,9 +184,8 @@ for(let num of fibMax21) {
 }
 ```
 
-#### Building code with iterators for ES5 target
-Code examples above require ES6 target, however it could work
-with ES5 target as well if target JS engine supports `Symbol.iterator`.
-This can be achieved by using ES6 lib with ES5 target
-(add es6.d.ts to your project) to make it compile.
-Compiled code should work in node 4+, Google Chrome and in some other browsers.
+#### ES5 hedef alınarak yineleyicilerle kod oluşturma
+Yukarıdaki kod örneklerinin çalıştırılabilmesi için ES6 hedef olarak gösterilmesi gerekmektedir, ancak ES5 kullanarak, `Symbol.iterator` yapısını destekleyen bir JS motoru ile de kodlar derlenebilir.
+Buda ES5 hedef alınarak, ES6 kütüphanesi kullanılarak gerçekleştirilebilir(Projenize es6.d.ts kütüphanesini ekleyip derleyin.)
+Derlenmiş kod node 4+, Google Chrome ve bazı diğer tarayıcılarda çalışacaktır.
+

From 148222b3098c1b927d42c431c92a0fce1732b8fa Mon Sep 17 00:00:00 2001
From: Mert Susur <mail@mertsusur.com>
Date: Sun, 29 Jan 2017 17:33:22 +0000
Subject: [PATCH 12/74] Fixes #2

---
 docs/getting-started.md | 36 +++++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/docs/getting-started.md b/docs/getting-started.md
index fb5d1fcdb..12411bdac 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -1,31 +1,32 @@
-* [Getting Started with TypeScript](#getting-started-with-typescript)
-* [TypeScript Version](#typescript-version)
+* [TypeScript'e Başlarken](#typescripte-başlarken)
+* [TypeScript Sürümleri](#typescript-sürümleri)
+* [Örneklerin Kaynak Kodlarını İndirmek](#Örneklerin-kaynak-kodlarını-İndirmek)
 
-# Getting Started With TypeScript
+# TypeScript'e Başlarken
 
-TypeScript compiles into JavaScript. JavaScript is what you are actually going to execute (either in the browser or on the server). So you are going to need the following:
+TypeScript, JavaScript'e derlenmektedir. Aslında JavaScript sunucu tarafında ya da tarayıcıda çalışacak olan kodun kendisidir. Dolayısıyla uygulamanızı çalıştırabilmek için aşağıdaki kurulumları tamamlamanız gerekmektedir:
 
-* TypeScript compiler (OSS available [in source](https://github.com/Microsoft/TypeScript/) and on [NPM](https://www.npmjs.com/package/typescript))
-* A TypeScript editor (you can use notepad if you want but I use [alm 🌹](http://alm.tools). Also [lots of other IDES support it as well]( https://github.com/Microsoft/TypeScript/wiki/TypeScript-Editor-Support))
+* TypeScript derleyicisi ([Kaynak Kodu](https://github.com/Microsoft/TypeScript/) ve [NPM](https://www.npmjs.com/package/typescript) paketi mevcuttur.)
+* Bir TypeScript editörü (Notepad ya da diğer birçok editörden bir tanesini kullanabilirsiniz. Örneğin bulut tabanlı olan [alm](http://alm.tools)'nin güzel bir örnek olması yanında [bir çok farklı editör de mevcuttur]( https://github.com/Microsoft/TypeScript/wiki/TypeScript-Editor-Support).)
 
 
 ![](https://raw.githubusercontent.com/alm-tools/alm-tools.github.io/master/screens/main.png)
 
 
-## TypeScript Version
+## TypeScript Sürümleri
 
-Instead of using the *stable* TypeScript compiler we will be presenting a lot of new stuff in this book that may not be associated with a version number yet. I generally recommend people to use the nightly version because **the compiler test suite only catches more bugs over time**.
+Kitapta anlatacağımız bazı yeni özellikler henüz *kararlı* bir TypeScript derleyicisi tarafından desteklenmemektedir. Hatta bazıları henüz bir sürüm numarası ile bile ilişkilendirilmemiş olabilir.
 
-You can install it on the command line as
+TypeScript derleyicisini aşağıdaki komut ile bilgisayarınıza kurabilirsiniz,
 
 ```
 npm install -g typescript@next
 ```
 
-And now the command line `tsc` will be the latest and greatest. Various IDEs support it too, e.g.
+Bundan sonra komut satırına yazılacak olan `tsc` komutu, en son ve en iyi versiyonu olarak kullanılabilir olacaktır. Birçok editör bu sürümü desteklemektedir. Örneğin,
 
-* `alm` always ships with the latest TypeScript version.
-* You can ask vscode to use this version by creating `.vscode/settings.json` with the following contents:
+* `alm` her zaman son sürümünde en güncel TypeScript sürümü ile yayınlanmaktadır.
+* Eğer `vscode` kullanıyorsanız aşağıdaki içeriğe sahip bir `.vscode/settings.json` dosyası oluşturursanız son sürümü kullanacaktır:
 
 ```json
 {
@@ -33,12 +34,13 @@ And now the command line `tsc` will be the latest and greatest. Various IDEs sup
 }
 ```
 
-## Getting the Source Code
-The source for this book is available in the books github repository https://github.com/basarat/typescript-book/tree/master/code most of the code samples can be copied into alm and you can play with them as is. For code samples that need additional setup (e.g. npm modules), we will link you to the code sample before presenting the code. e.g.
+## Örneklerin Kaynak Kodlarını İndirmek
+Kitabın içerisindeki örneklerin kaynak kodlarına GitHub üzerinden https://github.com/Codefiction/typescript-book/tree/master/code adresinden ulaşabilirsiniz. Kodların büyük bir kısmı alm'ye kopyalandığında hemen çalıştırılabilir durumdadır.
+Ek bir kurulum gerektiren örnekler (örneğin npm modülleri) için kod bloğu anlatılmadan önce ilişkili kod ile ilgili aşağıdaki gibi bir referans verilecektir.
 
-`this/will/be/the/link/to/the/code.ts`
+`bu/referans/olacak/kodun/adresi.ts`
 ```ts
-// This will be the code under discussion
+// Örneklerde anlatılan kodun kendisi
 ```
 
-With a dev setup out of the way let's jump into TypeScript syntax.
+Geliştirme ortamının kurulumunu tamamladığımıza göre artık TypeScript diline giriş yapabiliriz.

From ab06dce76eeb961ff6f9316d5f9d64e19c7b2a7b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Aldanmaz?= <tool-accounts@jooweb.net>
Date: Sun, 29 Jan 2017 20:19:32 +0300
Subject: [PATCH 13/74] =?UTF-8?q?#6=20-=20Rest=20Parameters=20=C3=A7eviris?=
 =?UTF-8?q?i?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/rest-parameters.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/rest-parameters.md b/docs/rest-parameters.md
index c847c4b99..12690d4f3 100644
--- a/docs/rest-parameters.md
+++ b/docs/rest-parameters.md
@@ -1,5 +1,5 @@
-### Rest Parameters
-Rest parameters (denoted by `...argumentName` for the last argument) allow you to quickly accept multiple arguments in your function and get them as an array. This is demonstrated in the below example.
+### Rest Parametreleri
+Rest parametreleri, belirsiz sayıda argümanı bir dizi olarak alan fonksiyonlar oluşturabilmenize olanak sağlar. Tanımlaması ise, fonksiyonun son argümanının `...argumentName` olarak ifade edilmesi ile gerçekleştirilir. Aşağıdaki örneği inceleyiniz.
 
 ```ts
 function iTakeItAll(first, second, ...allOthers) {
@@ -9,4 +9,4 @@ iTakeItAll('foo', 'bar'); // []
 iTakeItAll('foo', 'bar', 'bas', 'qux'); // ['bas','qux']
 ```
 
-Rest parameters can be used in any function be it `function`/`()=>`/`class member`.
+Rest parametreleri herhangi bir fonksiyonda kullanılabilir  `function`/`()=>`/`class member`.
\ No newline at end of file

From eddf1d450de8a93330b6a03ae606239d54ae46c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tu=C4=9Frul=20Can=20=C5=9E=C3=B6ll=C3=BC?=
 <tugrulcansollu@gmail.com>
Date: Tue, 31 Jan 2017 23:04:55 +0200
Subject: [PATCH 14/74] argumentName argumanIsmi

---
 docs/rest-parameters.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/rest-parameters.md b/docs/rest-parameters.md
index 12690d4f3..e7a736bca 100644
--- a/docs/rest-parameters.md
+++ b/docs/rest-parameters.md
@@ -1,5 +1,5 @@
 ### Rest Parametreleri
-Rest parametreleri, belirsiz sayıda argümanı bir dizi olarak alan fonksiyonlar oluşturabilmenize olanak sağlar. Tanımlaması ise, fonksiyonun son argümanının `...argumentName` olarak ifade edilmesi ile gerçekleştirilir. Aşağıdaki örneği inceleyiniz.
+Rest parametreleri, belirsiz sayıda argümanı bir dizi olarak alan fonksiyonlar oluşturabilmenize olanak sağlar. Tanımlaması ise, fonksiyonun son argümanının `...argumanIsmi` olarak ifade edilmesi ile gerçekleştirilir. Aşağıdaki örneği inceleyiniz.
 
 ```ts
 function iTakeItAll(first, second, ...allOthers) {
@@ -9,4 +9,4 @@ iTakeItAll('foo', 'bar'); // []
 iTakeItAll('foo', 'bar', 'bas', 'qux'); // ['bas','qux']
 ```
 
-Rest parametreleri herhangi bir fonksiyonda kullanılabilir  `function`/`()=>`/`class member`.
\ No newline at end of file
+Rest parametreleri herhangi bir fonksiyonda kullanılabilir  `function`/`()=>`/`class member`.

From 92144052fe4e07cb8f59e62d7f93ce0b201fd0e1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tu=C4=9Frul=20Can=20=C5=9E=C3=B6ll=C3=BC?=
 <tugrulcansollu@gmail.com>
Date: Tue, 31 Jan 2017 23:41:39 +0200
Subject: [PATCH 15/74] =?UTF-8?q?G=C3=BCncelle=C5=9Ftirmeler?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CONTRIBUTING.md | 26 ++++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index d89baf959..d854cc04e 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,10 +1,20 @@
- # Katkıda bulunmak için dikkat edilecekler
+ # Katkıda bulunmak isteyenler için Bilgilendirme: 
 
-- Öncelikle İngilizce'ye çevirdikten sonra iki farklı kişi gözden geçirecek. İki kişi onaylarsa merge edilecek. Pull request'i merge edecek kişi aynı isimle sonuna "gözden geçirilecek" ekleyerek yeni bir issue açacak. Bu issue ile amaç imla kuralları ve yazımı denetlemek.
-- Çeviri ile ilgili görevler(issue) https://github.com/CodeFiction/typescript-book/issues adresinde mevcuttur. Katkıda bulunmak istediğiniz konuya yorum bırakarak son durumu sorabilirsiniz. Katılmak için talepte bulunabilirsiniz. 
+*typescript-book kitabının yerelleştirmesini yaparken hedefimiz birebir çeviriden ziyade, bir Türk okuyucu tarafından bütünüyle anlaşılır bir kaynak oluşturmaktır.*
+
+### Yerelleştirme İşlemi Aşamaları
+1. Katkıda bulunmak isteyenler, ilgili repository'de açılan issue'lar içerisinden (https://github.com/CodeFiction/typescript-book/issues) bir görevi üstlenip, değişiklikleri ve çevirileri kendi kopyası (forku) üzerinden gerçekleştirir. 
+2. Gerekli değişiklikler yapıldıktan sonra ana repository'e Pull Request gönderilir. 
+	..* Ana reposory'e gelen pull request'ini **iki farklı kişi** gözden geçirir.
+	..* İki ayrı kullanıcının da onayını alan pull request sonrasında ana repository'e merge (rebase and merge yöntemiyle) edilir. 
+	..* Gelen pull request'i merge işlemini gerçekleştiren kişi, aynı isimle sonuna "gözden geçirilecek" ekleyerek yeni bir issue açar. *(Açılan bu issue ile amacımız, yapılan değişikliklerin Türkçe dil ve imla kurallarına uygunluğunun denetlenmesini sağlamak.)*
+
+### Ek Notlar
+- Katkıda bulunmak istediğiniz konuya yorum bırakarak son durumu sorabilirsiniz. Katılmak için talepte bulunabilirsiniz. 
 - Atanmış bir issue ile ilgili yardımcı olabilecekseniz issue sahibi ile iletişim geçilmelisiniz.
-- Üzerinizdeki görevi(issue) bırakmanız gerekirse lütfen topluluğu haberdar ediniz.
-- Çeviri yapmak için öncelikle "fork" edip. Sonra pull request göndermeniz gerekli. 
-- Çeviri yaparken hedefimiz birebir çeviriden ziyade, bir Türk okuyucu için anlamlı cümlelerin oluşturulmasıdır.
-- Teknik terimlerin çevirisinde bir bütünlük sağlamak amacı ile bir [sözlük](GLOSSARY.md) oluşturulmuştur. Lütfen çevirinizi yaparken ve bir Pull Request'i incelerken bu sözlükte yer alan terimleri takip ediniz. 
-- Görüş ve önerileriniz için gitter kanalına bekleriz. https://gitter.im/codefiction/typescript-book
+- Üzerinizdeki görevi(issue) bırakmanız gerekirse lütfen topluluğa ilgili Gitter kanalı üzerinden haber veriniz.
+- Teknik terimlerin çevirisinde bir bütünlük sağlamak amacı ile bir [sözlük](GLOSSARY.md) oluşturulmaktadır. Lütfen çevirinizi yaparken ve bir Pull Request'i incelerken bu sözlükte yer alan terimleri takip ediniz. 
+- Diğer görüş ve önerileriniz için gitter kanalına bekleriz. https://gitter.im/codefiction/typescript-book
+
+
+:tr: Codefiction Ekibi

From 0e41396479c33ba1daaaf1a9162f1ad6e48100bb Mon Sep 17 00:00:00 2001
From: DorukUlucay <doruk.ulucay@cronom.com>
Date: Tue, 31 Jan 2017 23:54:12 +0200
Subject: [PATCH 16/74] continued work on promised.md

---
 docs/promise.md | 58 ++++++++++++++++++++++++-------------------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/docs/promise.md b/docs/promise.md
index 7fcb934b2..32cc8afe4 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -38,7 +38,7 @@ Bu basit `loadJSONSync` fonksiyonunun üç davranışı vardır. Geçerli bir d
 ```ts
 import fs = require('fs');
 
-// A decent initial attempt .... but not correct. We explain the reasons below
+// uygun bir ilk deneme... ama yanlış çalışıyor. Sebeplerini aşağıda açıklayacağız.
 function loadJSON(filename: string, cb: (error: Error, data: any) => void) {
     fs.readFile(filename, function (err, data) {
         if (err) cb(err);
@@ -57,7 +57,7 @@ Bu basit fonksiyon 2. noktada çalışmakta problem yaşıyor. Aslında eğer ge
 ```ts
 import fs = require('fs');
 
-// A decent initial attempt .... but not correct
+// uygun bir ilk deneme ama çalışmıyor.
 function loadJSON(filename: string, cb: (error: Error, data: any) => void) {
     fs.readFile(filename, function (err, data) {
         if (err) cb(err);
@@ -65,7 +65,7 @@ function loadJSON(filename: string, cb: (error: Error, data: any) => void) {
     });
 }
 
-// load invalid json
+// hatalı json yüklüyoruz
 loadJSON('invalid.json', function (err, data) {
     // This code never executes
     if (err) console.log('bad.json error', err.message);
@@ -78,7 +78,7 @@ Bu durumu düzeltmek için naifçe bir çaba, JSON.parse'ı bir try/catch'e alma
 ```ts
 import fs = require('fs');
 
-// A better attempt ... but still not correct
+// daha iyi bir deneme ama hala hatalı
 function loadJSON(filename: string, cb: (error: Error) => void) {
     fs.readFile(filename, function (err, data) {
         if (err) {
@@ -95,15 +95,14 @@ function loadJSON(filename: string, cb: (error: Error) => void) {
     });
 }
 
-// load invalid json
+// hatalı json yüklüyoruz
 loadJSON('invalid.json', function (err, data) {
     if (err) console.log('bad.json error', err.message);
     else console.log(data);
 });
 ```
 
-Yine de bu kodda yakalaması zor bir hata var. Eğer JSON.parse değil de callback hata fırlatırsa, biz bunu try catch ile sarmaladığımız için catch çalışır ve callback'i bir daha çağırırız. Bu örnekte callback iki defa çağırılır! Bu aşağıdaki örnekte gösterilmiştir:
-However there is a subtle bug in this code. If the callback (`cb`), and not `JSON.parse`, throws an error, since we wrapped it in a `try`/`catch`, the `catch` executes and we call the callback again i.e. the callback gets called twice! This is demonstrated in the example below:
+Yine de bu kodda yakalaması zor bir hata var. Eğer `JSON.parse` değil de callback(`cb`) hata fırlatırsa, biz bunu `try`/`catch` ile sarmaladığımız için `catch` çalışır ve callback'i bir daha çağırırız. Bu örnekte callback iki defa çağırılır! Bu aşağıdaki örnekte gösterilmiştir:
 
 ```ts
 import fs = require('fs');
@@ -124,24 +123,24 @@ function loadJSON(filename: string, cb: (error: Error) => void) {
     });
 }
 
-// a good file but a bad callback ... gets called again!
+// düzgün bir dosya ama hatalı bir callback... tekrar çağırılıyor
 loadJSON('good.json', function (err, data) {
-    console.log('our callback called');
+    console.log('callback çağırıldı');
 
     if (err) console.log('Error:', err.message);
     else {
-        // let's simulate an error by trying to access a property on an undefined variable
+        // atanmamış(undefined) bir değerdeki bir alana erişmeye çalışarak bir hata simüle ediyoruz
         var foo;
-        // The following code throws `Error: Cannot read property 'bar' of undefined`
+        // aşağıdaki kod `Error: Cannot read property 'bar' of undefined` hatası verecektir
         console.log(foo.bar);
     }
 });
 ```
 
-```bash
+```bash(konsol)
 $ node asyncbadcatchdemo.js
-our callback called
-our callback called
+callback çağırıldı
+callback çağırıldı
 Error: Cannot read property 'bar' of undefined
 ```
 
@@ -157,59 +156,60 @@ import fs = require('fs');
 function loadJSON(filename: string, cb: (error: Error) => void) {
     fs.readFile(filename, function (err, data) {
         if (err) return cb(err);
-        // Contain all your sync code in a try catch
+        // senkronize çalışması gereken tüm kodu try'ın içine alın
         try {
             var parsed = JSON.parse(data);
         }
         catch (err) {
             return cb(err);
         }
-        // except when you call the callback
+        // callback'i çağırdığınız an hariç
         return cb(null, parsed);
     });
 }
 ```
-Admittedly this is not hard to follow once you've done it a few times but nonetheless it’s a lot of boiler plate code to write simply for good error handling. Now let's look at a better way to tackle asynchronous JavaScript using promises.
+Bunu birkaç kez yaptıktan sonra çok daha kolay olmakla beraber basit bir hata yakalama için bu çok fazla boilerplate kod yazmak anlamına geliyor. Şimdi promise'leri kullanarak javascript'te asenkron kodla uğraşmanın daha iyi bir yolunu bulalım.
 
-## Creating a Promise
 
-A promise can be either `pending` or `resolved` or `rejected`.
+## Bir Promise oluşturmak
+
+Bir promise `pending`(çalışmaya devam ediyor), `resolved`(çalışması sonlanmış) veya `rejected`(reddedilmiş) durumunda olabilir.
 
 ![](https://raw.githubusercontent.com/basarat/typescript-book/master/images/promise%20states%20and%20fates.png)
 
-Let's look at creating a promise. Its a simple matter of calling `new` on `Promise` (the promise constructor). The promise constructor is passed `resolve` and `reject` functions for settling the promise state.
+Bir promise oluşturalım. Bunun için promise ctor'u üzerinde `new` kelimesini çalıştırmak yeterli. `resolve` and `reject` fonksiyonları promise'in durumunu almak için constructor'a geçilir.
 
 ```ts
 const promise = new Promise((resolve, reject) => {
-    // the resolve / reject functions control the fate of the promise
+    // resolve / reject fonksiyonları promise'in sonucunu belirler
 });
 ```
 
-### Subscribing to the fate of the promise
+### Promise'in sonucuna abone olmak
 
-The promise fate can be subscribed to using `.then` (if resolved) or `.catch` (if rejected).
+Promise'in sonucu `.then`(eğer sonlanmış ise) veya `.catch`(eğer reddedilmiş ise) metotları ile gözlemlenebilir.
 
 ```ts
 const promise = new Promise((resolve, reject) => {
     resolve(123);
 });
 promise.then((res) => {
-    console.log('I get called:', res === 123); // I get called: true
+    console.log('I get called:', res === 123); // Ben çağırıldım. Sonuç: true
 });
 promise.catch((err) => {
-    // This is never called
+    // Burası hiç çağırılmadı
 });
 ```
 
 ```ts
 const promise = new Promise((resolve, reject) => {
-    reject(new Error("Something awful happened"));
+    reject(new Error("Çok kötü bir şey oldu."));
 });
 promise.then((res) => {
-    // This is never called
+    // Burası hiç çağırılmadı
 });
 promise.catch((err) => {
-    console.log('I get called:', err.message); // I get called: 'Something awful happened'
+    console.log('Çağırıldım :', err.message); // Çağırıldım : "Çok kötü bir şey oldu"
 });
 ```
 
@@ -217,7 +217,7 @@ promise.catch((err) => {
 * Quickly creating an already resolved promise : `Promise.resolve(result)`
 * Quickly creating an already rejected promise : `Promise.reject(error)`
 
-### Chain-ability of Promises
+### Promise'lerin zincirlenebilmesi
 The chain-ability of promises **is the heart of the benefit that promises provide**. Once you have a promise, from that point on, you use the `then` function to create a chain of promises.
 
 * If you return a promise from any function in the chain, `.then` is only called once the value is resolved

From 2aa5694da5b353979695f2b6aea3ca10d782cd9f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Atar?= <ugur.atar@metry.io>
Date: Tue, 31 Jan 2017 23:17:50 +0100
Subject: [PATCH 17/74] =?UTF-8?q?#13=20Spread=20Operat=C3=B6r=C3=BC=20?=
 =?UTF-8?q?=C3=A7evirisi=20d=C3=BCzeltmeler?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

#discussion_r98396231 ile vurgulanan hatalar düzeltildi.
---
 docs/spread-operator.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/spread-operator.md b/docs/spread-operator.md
index afc2523f8..ebd573980 100644
--- a/docs/spread-operator.md
+++ b/docs/spread-operator.md
@@ -39,7 +39,7 @@ console.log(list); // [1,2,3,4]
 ```
 
 #### Özet
-`apply` fonksiyonu JavaScript ile çalışırken kaçınılmaz olarak kullanacağınız bir ifadedir, bu sebeple `apply` fonksiyonunun ilk argümanı olan `this` yerine uygunsuz ve neredeyse çirkin denilebilecek bir sözdizimine yol açan`null` kullanmak yerine daha düzgün bir sözdizimi getiren *spread (yayma) operatörü* kullanmayı tercih edebilirsiniz. 
-Bununla birlikte  *spread (yayma) operatörü*,  kısmı diziler üzerinden yapılan parçalamak ve birleştirme işlemleri için çok daha zarif bir söz dizimi sunmaktadır.
+`apply` fonksiyonu JavaScript ile çalışırken kaçınılmaz olarak kullanacağınız bir ifadedir, bu sebeple `apply` fonksiyonunun ilk argümanı olan `this` yerine uygunsuz ve neredeyse çirkin denilebilecek bir sözdizimine yol açan `null` kullanmak yerine daha düzgün bir sözdizimi getiren *spread (yayma) operatörü* kullanmayı tercih edebilirsiniz. 
+Bununla birlikte  *spread (yayma) operatörü*,  kısmı diziler üzerinden yapılan parçalama ve birleştirme işlemleri için çok daha zarif bir sözdizimi sunmaktadır.
 
 [](https://github.com/Microsoft/TypeScript/pull/1931)

From 6472b2ff0999c8ac6d8656f22aca483be13a3595 Mon Sep 17 00:00:00 2001
From: Cronom-mustafa <mustafa.dinler@cronom.com>
Date: Wed, 1 Feb 2017 10:50:53 +0300
Subject: [PATCH 18/74] recap.md duzenlemesi ve awful.md cevirisi

---
 docs/javascript/awful.md | 38 +++++++++++++++++++-------------------
 docs/javascript/recap.md |  2 +-
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/docs/javascript/awful.md b/docs/javascript/awful.md
index 217f39c8e..0d6054dae 100644
--- a/docs/javascript/awful.md
+++ b/docs/javascript/awful.md
@@ -1,60 +1,60 @@
-# JavaScript the awful parts
+# JavaScript'in kötü tarafları
 
-Here are some awful (misunderstood) parts of JavaScript that you must know.
+İşte JavaScript'in bilmeniz gereken bazı kötü (anlaşılmaz) tarafları.
 
-> Note: TypeScript is a superset of JavaScript. Just with documentation that can actually be used by compilers / IDEs ;)
+> Not: TypeScript, JavaScript'in süpersetidir. Aslında derleyiciler/IDE'ler tarafından kullanılan dökümantasyonlu halidir ;)
 
-## Null and Undefined
+## Null ve Undefined
 
-Fact is you will need to deal with both. Just check for either with `==` check.
+Gerçek şu ki ikisiyle de uğraşmanız gerekecektir. İkisi için de `==` ile kontrol edelim.
 
 ```ts
-/// Imagine you are doing `foo.bar == undefined` where bar can be one of:
+/// bar aşagıdakilerden biri iken `foo.bar == undefined` yaptığınızı düşünün:
 console.log(undefined == undefined); // true
 console.log(null == undefined); // true
 console.log(0 == undefined); // false
 console.log('' == undefined); // false
 console.log(false == undefined); // false
 ```
-Recommend `== null` to check for both `undefined` or `null`. You generally don't want to make a distinction between the two.
+Tavsiyem `undefined` veya `null`, ikisi için de `== null` ile kontrol etmelisiniz. Genellikle bu ikisi arasında bir ayrım yapmak istemezsiniz.
 
 ## undefined
 
-Remember how I said you should use `== null`. Of course you do (cause I just said it ^). Don't use it for root level things. In strict mode if you use `foo` and `foo` is undefined you get a `ReferenceError` **exception** and the whole call stack unwinds.
+Hatırlarsanız `== null` kullanmanız gerektiğini söylemiştim. Tabi ki kullanacaksınız (çünkü ben öyle söyledim ^). Kök seviyesindeki şeyler için kullanmayın. Katı modda (strict mode) eğer `foo` kullanırsanız ve `foo` tanımlanmamış (undefined) ise, `ReferenceError` **hatası** alırsınız ve tüm çağrı kümeniz bozulur.
 
-> You should use strict mode ... and in fact the TS compiler will insert it for you if you use modules ... more on those later in the book so you don't have to be explicit about it :)
+> Katı mod (strict mode) kullanmalısınız ... ve aslında TS derleyicisi eğer modül kullanırsanız sizin için bunu ekleyecektir ... daha fazlası kitabın ilerleyen bölümlerinde var yani şu anda açık şekilde anlamış olmanız gerekmez :)
 
-So to check if a variable is defined or not at a *global* level you normally use `typeof`:
+Yani bir değişkenin *global* düzeyde tanımlanıp tanımlanmadığını kontrol etmek için `typeof` kullanılır:
 
 ```ts
 if (typeof someglobal !== 'undefined') {
-  // someglobal is now safe to use
+  // someglobal şu anda kullanım için güvenlidir
   console.log(someglobal);
 }
 ```
 
 ## this
 
-Any access to `this` keyword within a function is actually controlled by how the function is actually called. It is commonly referred to as the `calling context`.
+Bir fonksiyon içindeki `this` anahtar sözcüğüne herhangi bir erişim , aslında fonksiyonun nasıl çağrıldığına göre kontrol edilir. Genellikle `çağrı bağlamı (calling context)` olarak bahsedilir.
 
-Here is an example:
+Aşağıdaki örnek bunu açıklamaktadır:
 
 ```ts
 function foo() {
   console.log(this);
 }
 
-foo(); // logs out the global e.g. `window` in browsers
+foo(); // global olarak çıktı verir örneğin tarayıcılardaki `window` 
 let bar = {
   foo
 }
-bar.foo(); // Logs out `bar` as `foo` was called on `bar`
+bar.foo(); // `bar` üzerinde çağrıldığında `foo` olarak `bar` çıktısı verir
 ```
 
-So be mindful of your usage of `this`. If you want to disconnect `this` in a class from the calling context use an arrow function, [more on that later][arrow].
+Bu nedenle `this` kullanımınızda dikkatli olun . Eğer çağırdığınız bağlamda gelen sınıfın icindeki `this`'ten kopmak isterseniz ok fonksiyonlarını kullanın, [daha fazlası][ok].
 
-[arrow]:../arrow-functions.md
+[ok]:../arrow-functions.md
 
-## Next
+## Sıradaki
 
-That's it. Those are the simple *misunderstood* portions of JavaScript that still result in various bugs for developers that are new to the language 🌹.
+İşte bu. Bunlar JavaScript'in bazı yanlış anlaşılan parçalarıdır ve hala bu dilde yeni olan geliştiriciler için çeşitli hatalarla sonuçlanır 🌹.
diff --git a/docs/javascript/recap.md b/docs/javascript/recap.md
index e7475f58c..e36a0be24 100644
--- a/docs/javascript/recap.md
+++ b/docs/javascript/recap.md
@@ -38,4 +38,4 @@ Esasen TypeScript JavaScript'i potansiyel hatalar için analiz eder. Sadece benz
 
 ## Hala JavaScript öğrenmeniz gerekiyor
 
-Bunun anlamı TypeScript *JavaScript yazmanız* gerçeği hakkında oldukça pragmatiktir. Yani gafil avlanmamanız için JavaScript ile ilgili hala farkına varmanız gereken bazı şeyler var. Gelin şimdi bunları tartışalım.
+Bunun anlamı TypeScript *JavaScript yazmanız* gerçeği hakkında oldukça faydalıdır. Yani gafil avlanmamanız için JavaScript ile ilgili hala farkına varmanız gereken bazı şeyler var. Gelin şimdi bunları tartışalım.

From 09eb685c08cb47e5d972b784e7469bd3ea54c43d Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Wed, 1 Feb 2017 11:03:13 +0300
Subject: [PATCH 19/74] recap.md duzenlemesi ve awful.md cevirisi

---
 docs/javascript/awful.md | 2 +-
 docs/javascript/recap.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/javascript/awful.md b/docs/javascript/awful.md
index 0d6054dae..1ffa5e92e 100644
--- a/docs/javascript/awful.md
+++ b/docs/javascript/awful.md
@@ -16,7 +16,7 @@ console.log(0 == undefined); // false
 console.log('' == undefined); // false
 console.log(false == undefined); // false
 ```
-Tavsiyem `undefined` veya `null`, ikisi için de `== null` ile kontrol etmelisiniz. Genellikle bu ikisi arasında bir ayrım yapmak istemezsiniz.
+Tavsiyem `undefined` veya `null` , ikisi için de `== null` ile kontrol etmelisiniz. Genellikle bu ikisi arasında bir ayrım yapmak istemezsiniz.
 
 ## undefined
 
diff --git a/docs/javascript/recap.md b/docs/javascript/recap.md
index e36a0be24..eb9d0054f 100644
--- a/docs/javascript/recap.md
+++ b/docs/javascript/recap.md
@@ -13,7 +13,7 @@ TypeScript, dökümanlarla JavaScript'tir.
 
 ## JavaScript'i İyileştirmek
 
-TypeScript sizi hiç çalışmamış JavaScript parçalarından korumaya çalışacaktır (Bu sebeple bunları hatırlamanıza gerek yok):
+TypeScript sizi hiç çalışmamış JavaScript parçalarından korumaya çalışacaktır ( Bu sebeple bunları hatırlamanıza gerek yok):
 
 ```ts
 [] + []; // JavaScript size "" sonucunu verecek (ki mantıklı olan), TypeScript ise hata

From bb08417ecbdbd3f1f5fe341b447ba6dd800fec15 Mon Sep 17 00:00:00 2001
From: Basarat Ali Syed <basaratali@gmail.com>
Date: Tue, 10 Jan 2017 07:48:47 +1100
Subject: [PATCH 20/74] Merge pull request #215 from artyil/patch-1

fix some typos
---
 docs/javascript/awful.md | 40 ++++++++++++++++++++++------------------
 docs/javascript/recap.md |  2 +-
 2 files changed, 23 insertions(+), 19 deletions(-)

diff --git a/docs/javascript/awful.md b/docs/javascript/awful.md
index 1ffa5e92e..572c35fdc 100644
--- a/docs/javascript/awful.md
+++ b/docs/javascript/awful.md
@@ -1,60 +1,64 @@
-# JavaScript'in kötü tarafları
+# JavaScript the awful parts
 
-İşte JavaScript'in bilmeniz gereken bazı kötü (anlaşılmaz) tarafları.
+Here are some awful (misunderstood) parts of JavaScript that you must know.
 
-> Not: TypeScript, JavaScript'in süpersetidir. Aslında derleyiciler/IDE'ler tarafından kullanılan dökümantasyonlu halidir ;)
+> Note: TypeScript is a superset of JavaScript. Just with documentation that can actually be used by compilers / IDEs ;)
 
-## Null ve Undefined
+## Null and Undefined
 
-Gerçek şu ki ikisiyle de uğraşmanız gerekecektir. İkisi için de `==` ile kontrol edelim.
+Fact is you will need to deal with both. Just check for either with `==` check.
 
 ```ts
-/// bar aşagıdakilerden biri iken `foo.bar == undefined` yaptığınızı düşünün:
+/// Imagine you are doing `foo.bar == undefined` where bar can be one of:
 console.log(undefined == undefined); // true
 console.log(null == undefined); // true
 console.log(0 == undefined); // false
 console.log('' == undefined); // false
 console.log(false == undefined); // false
 ```
+<<<<<<< HEAD
 Tavsiyem `undefined` veya `null` , ikisi için de `== null` ile kontrol etmelisiniz. Genellikle bu ikisi arasında bir ayrım yapmak istemezsiniz.
+=======
+Recommend `== null` to check for both `undefined` or `null`. You generally don't want to make a distinction between the two.
+>>>>>>> parent of 6472b2f... recap.md duzenlemesi ve awful.md cevirisi
 
 ## undefined
 
-Hatırlarsanız `== null` kullanmanız gerektiğini söylemiştim. Tabi ki kullanacaksınız (çünkü ben öyle söyledim ^). Kök seviyesindeki şeyler için kullanmayın. Katı modda (strict mode) eğer `foo` kullanırsanız ve `foo` tanımlanmamış (undefined) ise, `ReferenceError` **hatası** alırsınız ve tüm çağrı kümeniz bozulur.
+Remember how I said you should use `== null`. Of course you do (cause I just said it ^). Don't use it for root level things. In strict mode if you use `foo` and `foo` is undefined you get a `ReferenceError` **exception** and the whole call stack unwinds.
 
-> Katı mod (strict mode) kullanmalısınız ... ve aslında TS derleyicisi eğer modül kullanırsanız sizin için bunu ekleyecektir ... daha fazlası kitabın ilerleyen bölümlerinde var yani şu anda açık şekilde anlamış olmanız gerekmez :)
+> You should use strict mode ... and in fact the TS compiler will insert it for you if you use modules ... more on those later in the book so you don't have to be explicit about it :)
 
-Yani bir değişkenin *global* düzeyde tanımlanıp tanımlanmadığını kontrol etmek için `typeof` kullanılır:
+So to check if a variable is defined or not at a *global* level you normally use `typeof`:
 
 ```ts
 if (typeof someglobal !== 'undefined') {
-  // someglobal şu anda kullanım için güvenlidir
+  // someglobal is now safe to use
   console.log(someglobal);
 }
 ```
 
 ## this
 
-Bir fonksiyon içindeki `this` anahtar sözcüğüne herhangi bir erişim , aslında fonksiyonun nasıl çağrıldığına göre kontrol edilir. Genellikle `çağrı bağlamı (calling context)` olarak bahsedilir.
+Any access to `this` keyword within a function is actually controlled by how the function is actually called. It is commonly referred to as the `calling context`.
 
-Aşağıdaki örnek bunu açıklamaktadır:
+Here is an example:
 
 ```ts
 function foo() {
   console.log(this);
 }
 
-foo(); // global olarak çıktı verir örneğin tarayıcılardaki `window` 
+foo(); // logs out the global e.g. `window` in browsers
 let bar = {
   foo
 }
-bar.foo(); // `bar` üzerinde çağrıldığında `foo` olarak `bar` çıktısı verir
+bar.foo(); // Logs out `bar` as `foo` was called on `bar`
 ```
 
-Bu nedenle `this` kullanımınızda dikkatli olun . Eğer çağırdığınız bağlamda gelen sınıfın icindeki `this`'ten kopmak isterseniz ok fonksiyonlarını kullanın, [daha fazlası][ok].
+So be mindful of your usage of `this`. If you want to disconnect `this` in a class from the calling context use an arrow function, [more on that later][arrow].
 
-[ok]:../arrow-functions.md
+[arrow]:../arrow-functions.md
 
-## Sıradaki
+## Next
 
-İşte bu. Bunlar JavaScript'in bazı yanlış anlaşılan parçalarıdır ve hala bu dilde yeni olan geliştiriciler için çeşitli hatalarla sonuçlanır 🌹.
+That's it. Those are the simple *misunderstood* portions of JavaScript that still result in various bugs for developers that are new to the language 🌹.
diff --git a/docs/javascript/recap.md b/docs/javascript/recap.md
index eb9d0054f..127a3d140 100644
--- a/docs/javascript/recap.md
+++ b/docs/javascript/recap.md
@@ -38,4 +38,4 @@ Esasen TypeScript JavaScript'i potansiyel hatalar için analiz eder. Sadece benz
 
 ## Hala JavaScript öğrenmeniz gerekiyor
 
-Bunun anlamı TypeScript *JavaScript yazmanız* gerçeği hakkında oldukça faydalıdır. Yani gafil avlanmamanız için JavaScript ile ilgili hala farkına varmanız gereken bazı şeyler var. Gelin şimdi bunları tartışalım.
+Bunun anlamı TypeScript *JavaScript yazmanız* gerçeği hakkında oldukça pragmatiktir. Yani gafil avlanmamanız için JavaScript ile ilgili hala farkına varmanız gereken bazı şeyler var. Gelin şimdi bunları tartışalım.

From 023c8ae05c37dab7402e13361868aac385b9b798 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Wed, 1 Feb 2017 11:55:55 +0300
Subject: [PATCH 21/74] recap.md duzenlemesi ve awful.md cevirisi

---
 docs/javascript/awful.md | 43 ++++++++++++++++++----------------------
 docs/javascript/recap.md |  2 +-
 2 files changed, 20 insertions(+), 25 deletions(-)

diff --git a/docs/javascript/awful.md b/docs/javascript/awful.md
index 572c35fdc..415040256 100644
--- a/docs/javascript/awful.md
+++ b/docs/javascript/awful.md
@@ -1,64 +1,59 @@
-# JavaScript the awful parts
+# JavaScript'in kötü tarafları
 
-Here are some awful (misunderstood) parts of JavaScript that you must know.
+İşte JavaScript'in bilmeniz gereken bazı kötü (anlaşılmaz) tarafları.
 
-> Note: TypeScript is a superset of JavaScript. Just with documentation that can actually be used by compilers / IDEs ;)
+> Not: TypeScript, JavaScript'in süpersetidir. Aslında derleyiciler/IDE'ler tarafından kullanılan dökümantasyonlu halidir ;)
 
-## Null and Undefined
+## Null ve Undefined
 
-Fact is you will need to deal with both. Just check for either with `==` check.
+Gerçek şu ki ikisiyle de uğraşmanız gerekecektir. İkisi için de `==` ile kontrol edelim.
 
 ```ts
-/// Imagine you are doing `foo.bar == undefined` where bar can be one of:
+/// bar aşagıdakilerden biri iken `foo.bar == undefined` yaptığınızı düşünün:
 console.log(undefined == undefined); // true
 console.log(null == undefined); // true
 console.log(0 == undefined); // false
 console.log('' == undefined); // false
 console.log(false == undefined); // false
 ```
-<<<<<<< HEAD
-Tavsiyem `undefined` veya `null` , ikisi için de `== null` ile kontrol etmelisiniz. Genellikle bu ikisi arasında bir ayrım yapmak istemezsiniz.
-=======
-Recommend `== null` to check for both `undefined` or `null`. You generally don't want to make a distinction between the two.
->>>>>>> parent of 6472b2f... recap.md duzenlemesi ve awful.md cevirisi
+Tavsiyem `undefined` veya `null`, ikisi için de `== null` ile kontrol etmelisiniz. Genellikle bu ikisi arasında bir ayrım yapmak istemezsiniz.
 
 ## undefined
 
-Remember how I said you should use `== null`. Of course you do (cause I just said it ^). Don't use it for root level things. In strict mode if you use `foo` and `foo` is undefined you get a `ReferenceError` **exception** and the whole call stack unwinds.
+Hatırlarsanız `== null` kullanmanız gerektiğini söylemiştim. Tabi ki kullanacaksınız (çünkü ben öyle söyledim ^). Kök seviyesindeki şeyler için kullanmayın. Katı modda (strict mode) eğer `foo` kullanırsanız ve `foo` tanımlanmamış (undefined) ise, `ReferenceError` **hatası** alırsınız ve tüm çağrı kümeniz bozulur.
 
-> You should use strict mode ... and in fact the TS compiler will insert it for you if you use modules ... more on those later in the book so you don't have to be explicit about it :)
+> Katı mod (strict mode) kullanmalısınız ... ve aslında TS derleyicisi eğer modül kullanırsanız sizin için bunu ekleyecektir ... daha fazlası kitabın ilerleyen bölümlerinde var yani şu anda açık şekilde anlamış olmanız gerekmez :)
 
-So to check if a variable is defined or not at a *global* level you normally use `typeof`:
+Yani bir değişkenin *global* düzeyde tanımlanıp tanımlanmadığını kontrol etmek için `typeof` kullanılır:
 
 ```ts
 if (typeof someglobal !== 'undefined') {
-  // someglobal is now safe to use
+  // someglobal şu anda kullanım için güvenlidir
   console.log(someglobal);
 }
 ```
 
 ## this
 
-Any access to `this` keyword within a function is actually controlled by how the function is actually called. It is commonly referred to as the `calling context`.
+Bir fonksiyon içindeki `this` anahtar sözcüğüne herhangi bir erişim , aslında fonksiyonun nasıl çağrıldığına göre kontrol edilir. Genellikle `çağrı bağlamı (calling context)` olarak bahsedilir.
 
-Here is an example:
+Aşağıdaki örnek bunu açıklamaktadır:
 
 ```ts
 function foo() {
   console.log(this);
 }
 
-foo(); // logs out the global e.g. `window` in browsers
+foo(); // global olarak çıktı verir örneğin tarayıcılardaki `window` 
 let bar = {
   foo
 }
-bar.foo(); // Logs out `bar` as `foo` was called on `bar`
+bar.foo(); // `bar` üzerinde çağrıldığında `foo` olarak `bar` çıktısı verir
 ```
+Bu nedenle `this` kullanımınızda dikkatli olun . Eğer çağırdığınız bağlamda gelen sınıfın icindeki `this`'ten kopmak isterseniz ok fonksiyonlarını kullanın, [daha fazlası][ok].
 
-So be mindful of your usage of `this`. If you want to disconnect `this` in a class from the calling context use an arrow function, [more on that later][arrow].
+[ok]:../arrow-functions.md
 
-[arrow]:../arrow-functions.md
+## Sıradaki
 
-## Next
-
-That's it. Those are the simple *misunderstood* portions of JavaScript that still result in various bugs for developers that are new to the language 🌹.
+İşte bu. Bunlar JavaScript'in bazı yanlış anlaşılan parçalarıdır ve hala bu dilde yeni olan geliştiriciler için çeşitli hatalarla sonuçlanır 🌹.
\ No newline at end of file
diff --git a/docs/javascript/recap.md b/docs/javascript/recap.md
index 127a3d140..9be3af827 100644
--- a/docs/javascript/recap.md
+++ b/docs/javascript/recap.md
@@ -38,4 +38,4 @@ Esasen TypeScript JavaScript'i potansiyel hatalar için analiz eder. Sadece benz
 
 ## Hala JavaScript öğrenmeniz gerekiyor
 
-Bunun anlamı TypeScript *JavaScript yazmanız* gerçeği hakkında oldukça pragmatiktir. Yani gafil avlanmamanız için JavaScript ile ilgili hala farkına varmanız gereken bazı şeyler var. Gelin şimdi bunları tartışalım.
+Bunun anlamı TypeScript *JavaScript yazmanız* gerçeği hakkında oldukça faydalıdır. Yani gafil avlanmamanız için JavaScript ile ilgili hala farkına varmanız gereken bazı şeyler var. Gelin şimdi bunları tartışalım.
\ No newline at end of file

From 77171f3b1ad06e4dce200e4f06bf96656ed8d027 Mon Sep 17 00:00:00 2001
From: vceylan <veyselceylan@yandex.com>
Date: Wed, 1 Feb 2017 14:19:07 +0300
Subject: [PATCH 22/74] =?UTF-8?q?=C4=B0stenilen=20de=C4=9Fi=C5=9Fiklikleri?=
 =?UTF-8?q?n=20=C3=BCzerinden=20ge=C3=A7ildi.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/iterators.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/iterators.md b/docs/iterators.md
index ef914a29b..8fa17aab2 100644
--- a/docs/iterators.md
+++ b/docs/iterators.md
@@ -59,7 +59,7 @@ Tekrar belirtmek gerekirse yineleyici bir TypeScript özelliği değildir.  Bu k
 
 Ancak, kod tutarlılığı için, bu ortak ES6 arayüzlerini (./types/interfaces.md) kullanmak çok yararlı olacaktır.
 
-Peki, iyi güzel, fakat daha da yararlı nasıl kullanabilir? ES6 [Symbol.iterator] `sembol` içeren *tekrarlanabilir protokol* tanımlar. 
+Peki, iyi guzel de, daha da yararlı nasıl kullanılabilir? ES6 [Symbol.iterator] `sembol` içeren *tekrarlanabilir protokol* tanımlar. 
 Iterable arayüzü şu şekilde uygulanabilir:
 
 ```ts
@@ -100,7 +100,7 @@ for (let cmp of frame) {
 }
 ```
 
-Ne yazık ki bu tasarımla `frame.next()` çalışmaz ve bir takım işler eksikmiş gibi gözükür. 
+Ne yazık ki bu tasarımla `frame.next()` çalışmaz ve bir takım işler eksikmiş gibi görünür. 
 IterableIterator arayüzü durumu kurtarmak için imdadımıza şu şekilde yetişir:
 
 ```ts

From abd4b636cfbb4893eda15a9bb1251bb492162904 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Wed, 1 Feb 2017 15:00:04 +0300
Subject: [PATCH 23/74] awful.md duzenlemesi ve closure.md cevirisi

---
 docs/javascript/awful.md   |  6 +++---
 docs/javascript/closure.md | 30 +++++++++++++++---------------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/docs/javascript/awful.md b/docs/javascript/awful.md
index 415040256..9cc65063f 100644
--- a/docs/javascript/awful.md
+++ b/docs/javascript/awful.md
@@ -2,7 +2,7 @@
 
 İşte JavaScript'in bilmeniz gereken bazı kötü (anlaşılmaz) tarafları.
 
-> Not: TypeScript, JavaScript'in süpersetidir. Aslında derleyiciler/IDE'ler tarafından kullanılan dökümantasyonlu halidir ;)
+> Not: TypeScript, JavaScript'in süpersetidir. Aslında derleyiciler/IDE'ler tarafından kullanılan dokümantasyonlu halidir ;)
 
 ## Null ve Undefined
 
@@ -20,7 +20,7 @@ Tavsiyem `undefined` veya `null`, ikisi için de `== null` ile kontrol etmelisin
 
 ## undefined
 
-Hatırlarsanız `== null` kullanmanız gerektiğini söylemiştim. Tabi ki kullanacaksınız (çünkü ben öyle söyledim ^). Kök seviyesindeki şeyler için kullanmayın. Katı modda (strict mode) eğer `foo` kullanırsanız ve `foo` tanımlanmamış (undefined) ise, `ReferenceError` **hatası** alırsınız ve tüm çağrı kümeniz bozulur.
+Hatırlarsanız `== null` kullanmanız gerektiğini söylemiştim. Tabii ki kullanacaksınız (çünkü ben öyle söyledim ^). Kök seviyesindeki şeyler için kullanmayın. Katı modda (strict mode) eğer `foo` kullanırsanız ve `foo` tanımlanmamış (undefined) ise, `ReferenceError` **hatası** alırsınız ve tüm çağrı kümeniz bozulur.
 
 > Katı mod (strict mode) kullanmalısınız ... ve aslında TS derleyicisi eğer modül kullanırsanız sizin için bunu ekleyecektir ... daha fazlası kitabın ilerleyen bölümlerinde var yani şu anda açık şekilde anlamış olmanız gerekmez :)
 
@@ -35,7 +35,7 @@ if (typeof someglobal !== 'undefined') {
 
 ## this
 
-Bir fonksiyon içindeki `this` anahtar sözcüğüne herhangi bir erişim , aslında fonksiyonun nasıl çağrıldığına göre kontrol edilir. Genellikle `çağrı bağlamı (calling context)` olarak bahsedilir.
+Bir fonksiyon içindeki `this` anahtar sözcüğüne herhangi bir erişim, aslında fonksiyonun nasıl çağrıldığına göre kontrol edilir. Genellikle `çağrı bağlamı (calling context)` olarak bahsedilir.
 
 Aşağıdaki örnek bunu açıklamaktadır:
 
diff --git a/docs/javascript/closure.md b/docs/javascript/closure.md
index fcecfc5c5..d827e2e56 100644
--- a/docs/javascript/closure.md
+++ b/docs/javascript/closure.md
@@ -1,25 +1,25 @@
-## Closure
+## Kapsanım
 
-The best thing that JavaScript ever got was closures. A function in JavaScript has access to any variables defined in the outer scope. Closures are best explained with examples:
+JavaScript'in sahip olduğu en iyi şey kapsanımlardır. JavaScript'de bir fonksiyon dış faaliyet alanında tanımlanmış herhangi bir değişkene erişebilir. Kapsanımlar en iyi şekilde örneklerle açıklanabilir:
 
 ```ts
 function outerFunction(arg) {
     var variableInOuterFunction = arg;
 
     function bar() {
-        console.log(variableInOuterFunction); // Access a variable from the outer scope
+        console.log(variableInOuterFunction); // Dış faaliyet alanındaki bir değişkene erişim 
     }
 
-    // Call the local function to demonstrate that it has access to arg
+    // arg'ye erişim olduğunu göstermek için yerel fonksiyon çağrısı
     bar();
 }
 
-outerFunction("hello closure"); // logs hello closure!
+outerFunction("merhaba kapsanım"); // merhaba kapsanım çıktısı üretir!
 ```
 
-You can see that the inner function has access to a variable (variableInOuterFunction) from the outer scope. The variables in the outer function have been closed by (or bound in) the inner function. Hence the term **closure**. The concept in itself is simple enough and pretty intuitive.
+Gördüğünüz üzere iç fonksiyonun, dış faaliyet alanındaki değişkene (variableInOuterFunction) erişimi vardır. Dış fonksiyondaki değişkenler iç fonksiyon tarafından kapatılmıştır (veya bağlanmıştır). Bu nedenle terim **kapsanım**. Kendi içindeki kavram yeterince basit ve oldukça sezgisel.
 
-Now the awesome part: The inner function can access the variables from the outer scope *even after the outer function has returned*. This is because the variables are still bound in the inner function and not dependent on the outer function. Again let's look at an example:
+Şimdi en harika kısmı: *Dış fonksiyon geri döndükten sonra bile* iç fonksiyon, dış faaliyet alanındaki değişkenlere erişebilir. Bunun nedeni, değişkenlerin hala iç fonksiyona bağlı olması ve dış fonksiyona bağımlı olmamasıdır. Gelin tekrar örneğe bakalım:
 
 ```ts
 function outerFunction(arg) {
@@ -29,14 +29,14 @@ function outerFunction(arg) {
     }
 }
 
-var innerFunction = outerFunction("hello closure!");
+var innerFunction = outerFunction("merhaba kapsanım!");
 
-// Note the outerFunction has returned
-innerFunction(); // logs hello closure!
+// outerFunction geri geldiğine dikkat edin
+innerFunction(); // merhaba kapsanım! çıktısı üretir
 ```
 
-### Reason why it's awesome
-It allows you to compose objects easily e.g. the revealing module pattern:
+### Harika olmasının sebebi
+Size nesneleri kolayca oluşturmanızı sağlar, örneğin açıklayıcı modül kalıbı:
 
 ```ts
 function createCounter() {
@@ -54,13 +54,13 @@ counter.increment();
 console.log(counter.getVal()); // 2
 ```
 
-At a high level it is also what makes something like nodejs possible (don't worry if it doesn't click in your brain right now. It will eventually 🌹):
+Üst seviyede nodejs gibi bir şeyi mümkün kılan şey de budur (Kafanızda şekillenmediyse endişelenmeyin. Sonunda olacak 🌹):
 
 ```ts
-// Pseudo code to explain the concept
+// Kavramı açıklamak için sözde kod (pseudo code)
 server.on(function handler(req, res) {
     loadData(req.id).then(function(data) {
-        // the `res` has been closed over and is available
+        // `res` kapatıldı ve hazır
         res.send(data);
     })
 });

From 71b38f01284ccfd6c7687ea5dd016e93fd9774b9 Mon Sep 17 00:00:00 2001
From: ozgend <revolter00k@gmail.com>
Date: Tue, 31 Jan 2017 02:45:55 +0300
Subject: [PATCH 24/74] #12 - String Template cevirisi tamamlandi

---
 docs/template-strings.md | 54 +++++++++++++++++++++-------------------
 1 file changed, 28 insertions(+), 26 deletions(-)

diff --git a/docs/template-strings.md b/docs/template-strings.md
index d634e497f..0e5f86473 100644
--- a/docs/template-strings.md
+++ b/docs/template-strings.md
@@ -1,62 +1,64 @@
-### Template Strings
-Syntactically these are strings that use backticks ( i.e. \` ) instead of single (') or double (") quotes. The motivation of Template Strings is three fold:
+### Şablon Stringler  
+Tek tırnak veya çift tırnak ile tanımlanan stringler yerine aksan işareti (\`) ile tanımlanmış stringlerdir. Şablon Stringler aşağıdaki amaçlar için kullanılır:
 
-* String Interpolation
-* Multiline Strings
-* Tagged Templates
+* String Aradeğerleme
+* Çok Satırlı Stringler
+* Biçimlendirilmiş Şablonlar
 
-#### String Interpolation
-Another common use case is when you want to generate some string out of some static strings + some variables. For this you would need some *templating logic* and this is where *template strings* get their name from. Here's how you would potentially generate an html string previously:
+#### String Aradeğerleme
+Verilen string ile değişkenlerin değerini barındıran bir string çıktısı elde edilmek istendigi durumda yaygın olarak kullanılan bir yöntemdir. Bunun gerçekleştirilmesi için bir *şablonlama mantığı* gereksinimi bulundugundan *şablon stringler* adını buradan alır.
+Sıradan yollarla bir html string tanımlamak istendiğinde büyük olasılıkla şu şekilde gerçekleştirilecektir:
 
 ```ts
 var lyrics = 'Never gonna give you up';
 var html = '<div>' + lyrics + '</div>';
 ```
-Now with template strings you can just do:
+Şablon stringler ile bu şekilde yapılabilir:
 
 ```ts
 var lyrics = 'Never gonna give you up';
 var html = `<div>${lyrics}</div>`;
 ```
 
-Note that any placeholder inside the interpolation (`${` and `}`) is treated as a JavaScript expression and evaluated as such e.g. you can do fancy math.
+Aradeğerleme işlemi (`${` ve `}`)  içerisindeki yertutucuların birer JavaScript ifadesi olarak işlenip değerlendirileceğini unutmayınız. Örneğin burada bir takım matematiksel işlemler de gerçekleştirilebilir.
 
 ```ts
-console.log(`1 and 1 make ${1 + 1}`);
+console.log(`1 + 1 = ${1 + 1}`);
 ```
 
-#### Multiline Strings
-Ever wanted to put a newline in a JavaScript string? Perhaps you wanted to embed some lyrics? You would have needed to *escape the literal newline* using our favorite escape character `\`, and then put a new line into the string manually `\n` at the next line. This is shown below:
+#### Çok Satırlı Stringler
+Hiç JavaScript stringlerinde satırbaşı yapmak istediniz mi? Ya da bir şarkı sözü belirtmek istemediniz mi? Bu durumda stringimizin ilgili yerine favori *kaçış karakteri*miz olan `\` ile *satırbaşı karakteri* olan `\n`'yi 
+aşağıdaki örnekte gösterildiği gibi yerleştirmemiz gerekecektir:
 
 ```ts
 var lyrics = "Never gonna give you up \
 \nNever gonna let you down";
 ```
 
-With TypeScript you can just use a template string:
+TypeScript'teki şablon stringler aşağıdaki kolaylığı sağlamakta:
 
 ```ts
 var lyrics = `Never gonna give you up
 Never gonna let you down`;
 ```
 
-#### Tagged Templates
+#### Biçimlendirilmiş Şablonlar
+Şablon string tanımının önüne (`tag` olarak isimlendirilen) fonksiyonları ekleyebilir ve ilgili şablon stringinin ön işlenmesini gerçekleştirerek buradan dönen sonucu kullanabilirsiniz.
+Not:
+* Şablondaki tüm statik stringler çağırılacak fonksiyonun ilk parametresine bir dizi olarak iletilir.
+* Kalan tüm yertutucu ifadelerin değerleri fonksiyonun diğer argümanlarını oluşturur. Genellikle sonradan iletilen tüm bu parametreleri bir diziye çevirerek kullanım sağlanır. 
 
-You can place a function (called a `tag`) before the template string and it gets the opportunity to pre process the template string literals plus the values of all the placeholder expressions and return a result. A few notes:
-* All the static literals are passed in as an array for the first argument.
-* All the values of the placeholders expressions are passed in as the remaining arguments. Most commonly you would just use rest parameters to convert these into an array as well.
-
-Here is an example where we have a tag function (named `htmlEscape`) that escapes the html from all the placeholders:
+Verilen html içerisinden tüm yertutucuların arındırıldığı `htmlEscape` adıyla tanımlmanan bir biçimlendirme fonksiyonunun hazırlanması ve kullanımı aşağıdaki gibidir:
 
 ```ts
 var say = "a bird in hand > two in the bush";
 var html = htmlEscape `<div> I would just like to say : ${say}</div>`;
 
-// a sample tag function
+// örnek biçimlendirme fonksiyonu
 function htmlEscape(literals, ...placeholders) {
     let result = "";
 
-    // interleave the literals with the placeholders
+    // yertutucularin değerler ile değiştirilmesi
     for (let i = 0; i < placeholders.length; i++) {
         result += literals[i];
         result += placeholders[i]
@@ -67,14 +69,14 @@ function htmlEscape(literals, ...placeholders) {
             .replace(/>/g, '&gt;');
     }
 
-    // add the last literal
+    // son değerin eklenmesi
     result += literals[literals.length - 1];
     return result;
 }
 ```
 
-#### Generated JS
-For pre ES6 compile targets the code is fairly simple. Multiline strings become escaped strings. String interpolation becomes *string concatenation*. Tagged Templates become function calls.
+#### Üretilen JS
+ES6 öncesi derlemede oluşturulan çıktı oldukça basit. Çok satırlı stringler kaçış karakterlilere çevirilir. String aradeğerleme ifadeleri *string birleştirme*ye dönüşür. Biçimlendirilmiş şablonlar normal fonksiyon çağırımları ile değiştirilir.
 
-#### Summary
-Multiline strings and string interpolation are just great things to have in any language. It's great that you can now use them in your JavaScript (thanks TypeScript!). Tagged templates allow you to create powerful string utilities.
+#### Özet
+Bir programlama dilinde *çok satırlı stringler* ve *string aradeğerleme* kullanımlarının bulunması buyuk kolaylık sağlamaktadır. TypeScript sayesinde bunlar artık JavaScript ile kullanılabililir. Biçimlendirilmiş şablonlar ile de detaylı string işlemleri gerçekleştirilebilen uzantılar yazılabilir.

From c76e7b400c22ea865fa38363effff08de1d2c601 Mon Sep 17 00:00:00 2001
From: ozgend <revolter00k@gmail.com>
Date: Tue, 31 Jan 2017 02:47:52 +0300
Subject: [PATCH 25/74] glossary - string tanimi eklendi

---
 GLOSSARY.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GLOSSARY.md b/GLOSSARY.md
index 60e5b0352..ef40b0920 100644
--- a/GLOSSARY.md
+++ b/GLOSSARY.md
@@ -18,6 +18,7 @@ Fakat bazı terimlerin Türkçe çevrimi, cümleyi anlamsız bir hale getirebilm
 | Contributor | Katkıda bulunan kişi |
 | Object | Nesne |
 | Event | Olay |
+| String | Karakter dizimi |
 
 # Terim açıklamaları
 * Duck Typing: Eğer bir ördek gibi yürüyor ve bir ördek gibi "vak"lıyorsa, o zaman bu bir ördektir. Bir nesne yapısal olarak tüm üyelere sahipse, diğer şeylerin de (ne olduğu önemli değil) var olduğu kabul edilir.

From 5d6075a8bc42cdb1a6c69462ec804baa539907c9 Mon Sep 17 00:00:00 2001
From: ozgend <revolter00k@gmail.com>
Date: Wed, 1 Feb 2017 21:09:31 +0300
Subject: [PATCH 26/74] =?UTF-8?q?#32=20review=20-=20escape=20karakter=20ta?=
 =?UTF-8?q?nim=C4=B1,=20string=20eki?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 GLOSSARY.md              |  1 +
 docs/template-strings.md | 24 ++++++++++++------------
 2 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/GLOSSARY.md b/GLOSSARY.md
index ef40b0920..475f7b080 100644
--- a/GLOSSARY.md
+++ b/GLOSSARY.md
@@ -19,6 +19,7 @@ Fakat bazı terimlerin Türkçe çevrimi, cümleyi anlamsız bir hale getirebilm
 | Object | Nesne |
 | Event | Olay |
 | String | Karakter dizimi |
+| Escape character (`\`) | Kaçış karakteri |
 
 # Terim açıklamaları
 * Duck Typing: Eğer bir ördek gibi yürüyor ve bir ördek gibi "vak"lıyorsa, o zaman bu bir ördektir. Bir nesne yapısal olarak tüm üyelere sahipse, diğer şeylerin de (ne olduğu önemli değil) var olduğu kabul edilir.
diff --git a/docs/template-strings.md b/docs/template-strings.md
index 0e5f86473..1e24a53cf 100644
--- a/docs/template-strings.md
+++ b/docs/template-strings.md
@@ -1,19 +1,19 @@
-### Şablon Stringler  
-Tek tırnak veya çift tırnak ile tanımlanan stringler yerine aksan işareti (\`) ile tanımlanmış stringlerdir. Şablon Stringler aşağıdaki amaçlar için kullanılır:
+### Şablon String'ler  
+Tek tırnak veya çift tırnak ile tanımlanan string'ler yerine aksan işareti (\`) ile tanımlanmış string'lerdir. Şablon String'ler aşağıdaki amaçlar için kullanılır:
 
 * String Aradeğerleme
-* Çok Satırlı Stringler
+* Çok Satırlı String'ler
 * Biçimlendirilmiş Şablonlar
 
 #### String Aradeğerleme
-Verilen string ile değişkenlerin değerini barındıran bir string çıktısı elde edilmek istendigi durumda yaygın olarak kullanılan bir yöntemdir. Bunun gerçekleştirilmesi için bir *şablonlama mantığı* gereksinimi bulundugundan *şablon stringler* adını buradan alır.
+Verilen string ile değişkenlerin değerini barındıran bir string çıktısı elde edilmek istendigi durumda yaygın olarak kullanılan bir yöntemdir. Bunun gerçekleştirilmesi için bir *şablonlama mantığı* gereksinimi bulundugundan *şablon string'ler* adını buradan alır.
 Sıradan yollarla bir html string tanımlamak istendiğinde büyük olasılıkla şu şekilde gerçekleştirilecektir:
 
 ```ts
 var lyrics = 'Never gonna give you up';
 var html = '<div>' + lyrics + '</div>';
 ```
-Şablon stringler ile bu şekilde yapılabilir:
+Şablon string'ler ile bu şekilde yapılabilir:
 
 ```ts
 var lyrics = 'Never gonna give you up';
@@ -26,8 +26,8 @@ Aradeğerleme işlemi (`${` ve `}`)  içerisindeki yertutucuların birer JavaScr
 console.log(`1 + 1 = ${1 + 1}`);
 ```
 
-#### Çok Satırlı Stringler
-Hiç JavaScript stringlerinde satırbaşı yapmak istediniz mi? Ya da bir şarkı sözü belirtmek istemediniz mi? Bu durumda stringimizin ilgili yerine favori *kaçış karakteri*miz olan `\` ile *satırbaşı karakteri* olan `\n`'yi 
+#### Çok Satırlı String'ler
+Hiç JavaScript string'lerinde satırbaşı yapmak istediniz mi? Ya da bir şarkı sözü belirtmek istemediniz mi? Bu durumda string'imizin ilgili yerine favori *escape karakteri*miz olan `\` ile *satırbaşı karakteri* olan `\n`'yi 
 aşağıdaki örnekte gösterildiği gibi yerleştirmemiz gerekecektir:
 
 ```ts
@@ -35,7 +35,7 @@ var lyrics = "Never gonna give you up \
 \nNever gonna let you down";
 ```
 
-TypeScript'teki şablon stringler aşağıdaki kolaylığı sağlamakta:
+TypeScript'teki şablon string'ler aşağıdaki kolaylığı sağlamakta:
 
 ```ts
 var lyrics = `Never gonna give you up
@@ -43,9 +43,9 @@ Never gonna let you down`;
 ```
 
 #### Biçimlendirilmiş Şablonlar
-Şablon string tanımının önüne (`tag` olarak isimlendirilen) fonksiyonları ekleyebilir ve ilgili şablon stringinin ön işlenmesini gerçekleştirerek buradan dönen sonucu kullanabilirsiniz.
+Şablon string tanımının önüne (`tag` olarak isimlendirilen) fonksiyonları ekleyebilir ve ilgili şablon string'inin ön işlenmesini gerçekleştirerek buradan dönen sonucu kullanabilirsiniz.
 Not:
-* Şablondaki tüm statik stringler çağırılacak fonksiyonun ilk parametresine bir dizi olarak iletilir.
+* Şablondaki tüm statik string'ler çağırılacak fonksiyonun ilk parametresine bir dizi olarak iletilir.
 * Kalan tüm yertutucu ifadelerin değerleri fonksiyonun diğer argümanlarını oluşturur. Genellikle sonradan iletilen tüm bu parametreleri bir diziye çevirerek kullanım sağlanır. 
 
 Verilen html içerisinden tüm yertutucuların arındırıldığı `htmlEscape` adıyla tanımlmanan bir biçimlendirme fonksiyonunun hazırlanması ve kullanımı aşağıdaki gibidir:
@@ -76,7 +76,7 @@ function htmlEscape(literals, ...placeholders) {
 ```
 
 #### Üretilen JS
-ES6 öncesi derlemede oluşturulan çıktı oldukça basit. Çok satırlı stringler kaçış karakterlilere çevirilir. String aradeğerleme ifadeleri *string birleştirme*ye dönüşür. Biçimlendirilmiş şablonlar normal fonksiyon çağırımları ile değiştirilir.
+ES6 öncesi derlemede oluşturulan çıktı oldukça basit. Çok satırlı string'ler escape karakterlilere çevirilir. String aradeğerleme ifadeleri *string birleştirme*ye dönüşür. Biçimlendirilmiş şablonlar normal fonksiyon çağırımları ile değiştirilir.
 
 #### Özet
-Bir programlama dilinde *çok satırlı stringler* ve *string aradeğerleme* kullanımlarının bulunması buyuk kolaylık sağlamaktadır. TypeScript sayesinde bunlar artık JavaScript ile kullanılabililir. Biçimlendirilmiş şablonlar ile de detaylı string işlemleri gerçekleştirilebilen uzantılar yazılabilir.
+Bir programlama dilinde *çok satırlı string'ler* ve *string aradeğerleme* kullanımlarının bulunması büyük kolaylık sağlamaktadır. TypeScript sayesinde bunlar artık JavaScript ile kullanılabililir. Biçimlendirilmiş şablonlar ile de detaylı string işlemleri gerçekleştirilebilen uzantılar yazılabilir.

From c12ed53539ee96dcb87e757f413107baf1ea29f3 Mon Sep 17 00:00:00 2001
From: YunusAlgan <yunusalgan@users.noreply.github.com>
Date: Thu, 2 Feb 2017 07:58:38 +0200
Subject: [PATCH 27/74] Update CONTRIBUTING.md

---
 CONTRIBUTING.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index d854cc04e..dfda5dad7 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -11,7 +11,7 @@
 
 ### Ek Notlar
 - Katkıda bulunmak istediğiniz konuya yorum bırakarak son durumu sorabilirsiniz. Katılmak için talepte bulunabilirsiniz. 
-- Atanmış bir issue ile ilgili yardımcı olabilecekseniz issue sahibi ile iletişim geçilmelisiniz.
+- Atanmış bir issue ile ilgili yardımcı olabilecekseniz issue sahibi ile iletişime geçebilirsiniz.
 - Üzerinizdeki görevi(issue) bırakmanız gerekirse lütfen topluluğa ilgili Gitter kanalı üzerinden haber veriniz.
 - Teknik terimlerin çevirisinde bir bütünlük sağlamak amacı ile bir [sözlük](GLOSSARY.md) oluşturulmaktadır. Lütfen çevirinizi yaparken ve bir Pull Request'i incelerken bu sözlükte yer alan terimleri takip ediniz. 
 - Diğer görüş ve önerileriniz için gitter kanalına bekleriz. https://gitter.im/codefiction/typescript-book

From 0416b6ce2301bc74fef32056b511b9ef2a7da248 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Thu, 2 Feb 2017 10:39:23 +0300
Subject: [PATCH 28/74] awful.md ve recap.md duzeltmeler

---
 docs/javascript/awful.md |  2 +-
 docs/javascript/recap.md | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/javascript/awful.md b/docs/javascript/awful.md
index 9cc65063f..679d23951 100644
--- a/docs/javascript/awful.md
+++ b/docs/javascript/awful.md
@@ -44,7 +44,7 @@ function foo() {
   console.log(this);
 }
 
-foo(); // global olarak çıktı verir örneğin tarayıcılardaki `window` 
+foo(); // global olarak çıktı verir, örneğin tarayıcılardaki `window` 
 let bar = {
   foo
 }
diff --git a/docs/javascript/recap.md b/docs/javascript/recap.md
index 9be3af827..d8f53d232 100644
--- a/docs/javascript/recap.md
+++ b/docs/javascript/recap.md
@@ -23,14 +23,14 @@ TypeScript sizi hiç çalışmamış JavaScript parçalarından korumaya çalı
 // - çalışma zamanı hatası vermez (hata ayıklamayı zorlaştırıyor)
 // - ama TypeScript derleme zamanı hatası verecek (hata ayıklamayı gereksizleştiriyor)
 //
-{} + []; // JS : 0, TS Hata
-[] + {}; // JS : "[object Object]", TS Hata
-{} + {}; // JS : NaN, TS Hata
-"merhaba" - 1; // JS : NaN, TS Hata
+{} + []; // JS : 0, TS Error
+[] + {}; // JS : "[object Object]", TS Error
+{} + {}; // JS : NaN, TS Error
+"merhaba" - 1; // JS : NaN, TS Error
 
 function ekle(a,b) {
   return
-    a + b; // JS : undefined, TS Hata 'unreachable code detected'
+    a + b; // JS : undefined, TS Error 'unreachable code detected'
 }
 ```
 

From 9358fb6a1ec086e63e0ea11a9b27a739788c1db2 Mon Sep 17 00:00:00 2001
From: vceylan <veyselceylan@yandex.com>
Date: Thu, 2 Feb 2017 16:10:57 +0300
Subject: [PATCH 29/74] =?UTF-8?q?Bo=C5=9Fluk=20kald=C4=B1r=C4=B1ld=C4=B1?=
 =?UTF-8?q?=20ve=20=C3=A7eviri=20de=C4=9Fi=C5=9Ftirildi.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/iterators.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/iterators.md b/docs/iterators.md
index 8fa17aab2..4a6f13dfe 100644
--- a/docs/iterators.md
+++ b/docs/iterators.md
@@ -55,7 +55,7 @@ let iteratorResult5 = frame.next(); //{ done: true }
 let component = iteratorResult1.value; //Component { name: 'top' }
 ```
 
-Tekrar belirtmek gerekirse yineleyici bir TypeScript özelliği değildir.  Bu kod Iterator ve IteratorResult arayüzlerini açıkça uygulamadan da çalışabilir.
+Tekrar belirtmek gerekirse yineleyici bir TypeScript özelliği değildir. Bu kod Iterator ve IteratorResult arayüzleri kullanılmadan da çalışabilir.
 
 Ancak, kod tutarlılığı için, bu ortak ES6 arayüzlerini (./types/interfaces.md) kullanmak çok yararlı olacaktır.
 

From c20b5085aecde5b7a314ac2e38412a6b632efe36 Mon Sep 17 00:00:00 2001
From: ozgend <revolter00@gmail.com>
Date: Thu, 2 Feb 2017 21:52:10 +0300
Subject: [PATCH 30/74] #15 Generators cevirisi tamamlandi

---
 docs/generators.md | 65 ++++++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 31 deletions(-)

diff --git a/docs/generators.md b/docs/generators.md
index c788d40b2..bdeba3c6a 100644
--- a/docs/generators.md
+++ b/docs/generators.md
@@ -1,12 +1,12 @@
-## Generators
+## Oluşturucular
 
-> NOTE: You cannot use generators in TypeScript in a meaningful way (the ES5 emitter is in progress). However that will change soon so we still have this chapter.
+> NOT: TypeScript'te oluşturucular henüz olgunlaşmamıştır. Yine de olgunlaştırma çalışmaları olduğundan bu konuyu ekledik.  
 
-`function *` is the syntax used to create a *generator function*. Calling a generator function returns a *generator object*. There are two key motivations behind generator functions. The generator object just follows the [iterator][iterator] interface (i.e. the `next`, `return` and `throw` functions).
+TypeScript'te `function *` deyimi kullanılarak bir *oluşturucu fonksiyon* tanımlanabilir. Oluşturucu fonksiyonun geridönüşü bir *oluşturucu nesne*dir ve [yineleyici][iterator] arayüzünü uygulamaktadır. Bu bağlamda `next`, `return` ve `throw` çağırımlarına uygundur. Oluşturucu fonksiyonlar iki temel amaca sahiptir.
 
-### Lazy Iterators
+### Geç Yineleyiciler
 
-Generator functions can be used to create lazy iterators e.g. the following function returns an **infinite** list of integers on demand:
+Aşağıda **sonsuz** sayıda tamsayı dönen fonksiyon örneğindeki gibi, oluşturucu fonksiyonlar geç yineleyicileri tanımlamak için kullanılabilir.  
 
 ```ts
 function* infiniteSequence() {
@@ -18,11 +18,11 @@ function* infiniteSequence() {
 
 var iterator = infiniteSequence();
 while (true) {
-    console.log(iterator.next()); // { value: xxxx, done: false } forever and ever
+    console.log(iterator.next()); // { value: xxxx, done: false } - işlem sonsuza kadar devam eder
 }
 ```
 
-of course if the iterator does end, you get the result of `{done:true}` as demonstrated below:
+ancak yineleyicinin bir sonu olduğu koşulda aşağıda gözlemleyebileceğiniz şekilde `{done:true}` sonucu alınabilir:
 
 ```ts
 function* idMaker(){
@@ -39,10 +39,12 @@ console.log(gen.next()); // { value: 2, done: false }
 console.log(gen.next()); // { done: true }
 ```
 
-### Externally Controlled Execution
-This is the part of generators that is truly exciting. It essentially allows a function to pause its execution and pass control (fate) of the remainder of the function execution to the caller.
+### Dışarıdan Kontrol Edilen Yürütmeler
+Yürütülen bir fonksiyonu duraklatmak ve kalan yürütme işinin kontrolünü o fonksiyonu çağırana iletmek oluşturucuların temel işlevidir. 
+Bu, oluşturucuların keyifli ve heyecan verici yanıdır.
 
-A generator function does not execute when you call it. It just creates a generator object. Consider the following example along with a sample execution:
+Oluşturucu fonksiyonlar çağırıldıkları anda yürütülmezler, yalnızca nesne oluştururlar.
+Aşağıdaki örneği ve örnek çağırımı inceleyelim:
 
 ```ts
 function* generator(){
@@ -53,14 +55,14 @@ function* generator(){
     console.log('Execution resumed');
 }
 
-var iterator = generator();
-console.log('Starting iteration'); // This will execute before anything in the generator function body executes
+var iterator = generator(); // Oluşturucu nesnesi
+console.log('Starting iteration'); // Oluşturucu fonksiyonun içeriğinden önce bu satır çalışacaktır.
 console.log(iterator.next()); // { value: 0, done: false }
 console.log(iterator.next()); // { value: 1, done: false }
 console.log(iterator.next()); // { value: undefined, done: true }
 ```
 
-If you run this you get the following output:
+Örneğin çalıştırılması durumunda aşağıdaki çıktı gözlemlenebilir:
 
 ```
 $ node outside.js
@@ -73,18 +75,19 @@ Execution resumed
 { value: undefined, done: true }
 ```
 
-* The function only starts execution once `next` is called on the generator object.
-* The function *pauses* as soon as a `yield` statement is encountered
-* The function *resumes* when `next` is called.
+* Oluşturucu fonksiyon (`generator()`) ancak oluşturucu nesnesindeki `next` fonksiyonunun çağırımıyla yürütülmeye başlar.  
+* Oluşturucu fonksiyon `yield` deyimi ile *duraklatılır* *(pause)*.
+* Oluşturucu fonksiyon `next` çağırımı yapıldığında yürütülmeye *devam eder* *(resume)*.
 
-> So essentially the execution of the generator function is controllable by the generator object.
+> Oluşturucu fonksiyonun yürütülmesi, oluşturucu nesne tarafından kontrol edilebilir durumdadır.
 
-Our communication using the generator has been mostly one way with the generator returning values for the iterator. One extremely powerful feature of generators in JavaScript is that they allow two way communications!
+Oluşturucuları çoğu zaman *tek yönlü* olarak, yani sadece yineleyiciden geri döndürülen değerleri için kullanırız.
+Ancak JavaScript'in gerçeklen güçlü bu ozelliği aslında *iki yönlü* olarak kullanıma olanak verir.
 
-* you can control the resulting value of the `yield` expression using `iterator.next(valueToInject)`
-* you can throw an exception at the point of the `yield` expression using `iterator.throw(error)`
+* `iterator.next(valueToInject)` kullanılarak `yield` ile döndürülen değer kontrol edilebilir veya değiştirilebilir.
+* `iterator.throw(error)` kullanılarak `yield` işleyişinde istisna oluşturulabilir.
 
-The following example demonstrates `iterator.next(valueToInject)`:
+`iterator.next(valueToInject)` örneği:
 
 ```ts
 function* generator() {
@@ -93,14 +96,14 @@ function* generator() {
 }
 
 const iterator = generator();
-// Start execution till we get first yield value
+// yield'dan dönen ilk değeri alana kadar yürütmeyi başlat
 const foo = iterator.next();
 console.log(foo.value); // foo
-// Resume execution injecting bar
+// bar değerini işleme alarak yürütmeye devam et
 const nextThing = iterator.next('bar');
 ```
 
-The following example demonstrates `iterator.throw(error)`:
+`iterator.throw(error)` örneği:
 
 ```ts
 function* generator() {
@@ -113,19 +116,19 @@ function* generator() {
 }
 
 var iterator = generator();
-// Start execution till we get first yield value
+// yield'dan dönen ilk değeri alana kadar yürütmeyi başlat
 var foo = iterator.next();
 console.log(foo.value); // foo
-// Resume execution throwing an exception 'bar'
+// 'bar' mesajıyla bir istisna oluşturarak yürütmeye devam et
 var nextThing = iterator.throw(new Error('bar'));
 ```
 
-So here is the summary:
-* `yield` allows a generator function to pause its communication and pass control to an external system
-* the external system can push a value into the generator function body
-* the external system can throw an exception into the generator function body
+Özetleyecek olursak:
+* `yield` deyimi bir oluşturucu fonksiyonun işleyişini duraksatarak, yürütme kontrolünü dış yapıya iletir.
+* oluşturucu fonksiyonlardaki değerler dışarıdan manipüle edilebilir. 
+* oluşturucu fonksiyonların işleyişleri istisnalara ve hatalara göre şekillendirilebilir.
 
-How is this useful? Jump to the next section [**async/await**][async-await] and find out.
+Bu konuyla ilgili olarak bir sonraki bölüm olan [**async/await**][async-await] konusuna bir göz atın.
 
 [iterator]:./iterators.md
 [async-await]:./async-await.md

From 5a95c55e03d676e50266e2120484b0416c1beccd Mon Sep 17 00:00:00 2001
From: DorukUlucay <doruk.ulucay@cronom.com>
Date: Sat, 4 Feb 2017 16:09:49 +0200
Subject: [PATCH 31/74] continued work on promises.md(almost there) also
 started work on readme.md

---
 README.md       | 42 +++++++++++++++++++++++-------------------
 docs/promise.md | 42 +++++++++++++++++++++---------------------
 2 files changed, 44 insertions(+), 40 deletions(-)

diff --git a/README.md b/README.md
index a93282a3c..456d71e34 100644
--- a/README.md
+++ b/README.md
@@ -1,17 +1,17 @@
-TypeScript Deep Dive
+TypeScript'e Derin Dalış
 =======
 
-[![Join the chat at https://gitter.im/codefiction/typescript-book](https://badges.gitter.im/codefiction/typescript-book.svg)](https://gitter.im/codefiction/typescript-book?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Chat kanalına katılın https://gitter.im/codefiction/typescript-book](https://badges.gitter.im/codefiction/typescript-book.svg)](https://gitter.im/codefiction/typescript-book?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-I've been looking at the issues that turn up commonly when people start using TypeScript. This is based on the lessons from [StackOverflow](http://stackoverflow.com/tags/typescript/topusers) / [DefinitelyTyped](https://github.com/DefinitelyTyped/) and general engagement with the [TypeScript community](https://github.com/TypeStrong/). You can [follow for updates](https://twitter.com/basarat) and [don't forget to ★ on Github](https://github.com/basarat/typescript-book) 🌹
+Typescript kullanılırken genel olarak karşılaşılan hatalarla ilgilenmekteyim. Bu çalışma [StackOverflow](http://stackoverflow.com/tags/typescript/topusers) / [DefinitelyTyped](https://github.com/DefinitelyTyped/) ve [TypeScript community](https://github.com/TypeStrong/) komünitesine bağlı kaynaklar üzerine kuruludur. [Güncellemeleri takip edebilirsiniz](https://twitter.com/basarat) ve [Github'da ★'lamayı unutmayın' ](https://github.com/basarat/typescript-book) 🌹
 
-## Reviews
+## Yorumlar
 
-* Thanks for the wonderful book. Learned a lot from it. ([link](https://www.gitbook.com/book/basarat/typescript/discussions/21#comment-1468279131934))
-* Its probably the Best TypeScript book out there. Good Job ([link](https://twitter.com/thelondonjs/status/756419561570852864))
-* Love how precise and clear the examples and explanations are! ([link](https://twitter.com/joe_mighty/status/758290957280346112))
+* Bu harika kitap için teşekkürler. Kitaptan pek çok şey öğrendim. ([link](https://www.gitbook.com/book/basarat/typescript/discussions/21#comment-1468279131934))
+* Muhtemelen mevcut en iyi Typescript kitabı. İyi iş. ([link](https://twitter.com/thelondonjs/status/756419561570852864))
+* Açıklama ve örneklerin isabetliliğine ve açıklığına bayıldım. ([link](https://twitter.com/joe_mighty/status/758290957280346112))
 * For the low, low price of free, you get pages of pure awesomeness. Chock full of source code examples and clear, concise explanations, TypeScript Deep Dive will help you learn TypeScript development. ([link](https://www.nativescript.org/blog/details/free-book-typescript-deep-dive))
-* Just a big thank you! **Best TypeScript 2 detailed explanation!** ([link](https://www.gitbook.com/book/basarat/typescript/discussions/38))
+* Kocaman bir teşekkür! **Best TypeScript 2 detailed explanation!** ([link](https://www.gitbook.com/book/basarat/typescript/discussions/38))
 * This gitbook got my project going pronto. Fluent easy read 5 stars. ([link](https://twitter.com/thebabellion/status/779888195559235584))
 * I recommend the online #typescript book by @basarat you'll love it.([link](https://twitter.com/markpieszak/status/788099306590969860))
 * I've always found this by @basarat really helpful. ([link](https://twitter.com/Brocco/status/789887640656945152))
@@ -25,17 +25,21 @@ I've been looking at the issues that turn up commonly when people start using Ty
 * Leaning on the legendary @basarat's "TypeScript Deep Dive" book heavily at the moment ([link](https://twitter.com/sitapati/status/814379404956532737))
 * numTimesPointedPeopleToBasaratsTypeScriptBook++; ([link](https://twitter.com/brocco/status/814227741696462848))
 
-## Get Started
-If you are here to read the book online [get started](http://basarat.gitbooks.io/typescript/content/docs/getting-started.html).
+## Başlamak için
+Kitabı okumaya [buradan başlayabilirsiniz](http://basarat.gitbooks.io/typescript/content/docs/getting-started.html).
 
-## Other Options
-You can also download one of the following:
-* [EPUB for iPad,iPhone,Mac](https://www.gitbook.com/download/epub/book/basarat/typescript)
-* [PDF for Windows and others](https://www.gitbook.com/download/pdf/book/basarat/typescript)
-* [MOBI for Kindle](https://www.gitbook.com/download/mobi/book/basarat/typescript)
+## Diğer seçenekler
+Aşağıdakilerden birini indirebilirsiniz
+* [iPad,iPhone,Mac için EPUB](https://www.gitbook.com/download/epub/book/basarat/typescript)
+* [Windows ve diğerleri için PDF](https://www.gitbook.com/download/pdf/book/basarat/typescript)
+* [Kindle için MOBI](https://www.gitbook.com/download/mobi/book/basarat/typescript)
 
-## Special Thanks
-All the amazing [contributors](https://github.com/basarat/typescript-book/graphs/contributors) 🌹
+## Teşekkürler
+[Katkıda bulunan herkese](https://github.com/basarat/typescript-book/graphs/contributors) 🌹
 
-## Share
-Share URL: http://basarat.gitbooks.io/typescript/
+## Paylaşın
+Adres: http://basarat.gitbooks.io/typescript/
+
+## Türkçe Çeviri
+Kitabın Türkçe Çevirisi [Codefiction](https://github.com/Codefiction) tarafından yapılmıştır.
+Codefiction, **"Yazılımın açık kaynaklısı var. Topluluğun neden olmasın ?"** mottosuyla yola çıkmış bir geliştirici topluluğudur.
diff --git a/docs/promise.md b/docs/promise.md
index 32cc8afe4..fb4e7f57b 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -218,9 +218,9 @@ promise.catch((err) => {
 * Quickly creating an already rejected promise : `Promise.reject(error)`
 
 ### Promise'lerin zincirlenebilmesi
-The chain-ability of promises **is the heart of the benefit that promises provide**. Once you have a promise, from that point on, you use the `then` function to create a chain of promises.
+Promise'lerin zincirlenebilir olması **en önemli özelliğidir**. Bir Promise'iniz olduğunda, `then` fonksiyonunu kullanarak promise zinciri yaratabilirsiniz.
 
-* If you return a promise from any function in the chain, `.then` is only called once the value is resolved
+* Zincirdeki herhangi bir fonksiyondan bir promise döndürürseniz, `.then` sadece fonksiyon çözümlendiğinde çağırılır.
 
 ```ts
 Promise.resolve(123)
@@ -230,10 +230,10 @@ Promise.resolve(123)
     })
     .then((res) => {
         console.log(res); // 456
-        return Promise.resolve(123); // Notice that we are returning a Promise
+        return Promise.resolve(123); // Bir promise dmndürüyor olduğumuza dikkat edin
     })
     .then((res) => {
-        console.log(res); // 123 : Notice that this `then` is called with the resolved value
+        console.log(res); // Bu `then`'in çözümlenmiş değer ile çağırıldığına dikkat edin.   
         return 123;
     })
 ```
@@ -241,36 +241,36 @@ Promise.resolve(123)
 * you can aggregate the error handling of any preceding portion of the chain with a single `catch`
 
 ```ts
-// Create a rejected promise
-Promise.reject(new Error('something bad happened'))
+// Reddedilen bir promise yaratın
+Promise.reject(new Error('kötü bir şey oldu'))
     .then((res) => {
-        console.log(res); // not called
+        console.log(res); // çağırılmadı
         return 456;
     })
     .then((res) => {
-        console.log(res); // not called
+        console.log(res); // çağırılmadı
         return 123;
     })
     .then((res) => {
-        console.log(res); // not called
+        console.log(res); // çağırılmadı
         return 123;
     })
     .catch((err) => {
-        console.log(err.message); // something bad happened
+        console.log(err.message); // kötü bir şey oldu
     });
 ```
 
-* the `catch` actually returns a new promise (effectively creating a new promise chain):
+* `catch` yeni bir promise döndürür(yeni bir promise zinciri yaratarak)
 
 ```ts
-// Create a rejected promise
-Promise.reject(new Error('something bad happened'))
+// Reddedilecek bir promise yaratalım
+Promise.reject(new Error('kötü bir şey oldu'))
     .then((res) => {
-        console.log(res); // not called
+        console.log(res); // çağırılmadı
         return 456;
     })
     .catch((err) => {
-        console.log(err.message); // something bad happened
+        console.log(err.message); // kötü bir şey oldu
         return 123;
     })
     .then((res) => {
@@ -278,20 +278,20 @@ Promise.reject(new Error('something bad happened'))
     })
 ```
 
-* Any synchronous errors thrown in a `then` (or `catch`) result in the returned promise to fail
+* Bir `then` (ya da `catch`) fonksiyonunda gerçekleşen herhangi bir asenkron hata, döndürülen promise'in fail olmasına sebep olur.
 
 ```ts
 Promise.resolve(123)
     .then((res) => {
-        throw new Error('something bad happened'); // throw a synchronous error
+        throw new Error('kötü bir şey oldu'); // asenkron bir hata fırlatalım
         return 456;
     })
     .then((res) => {
-        console.log(res); // never called
+        console.log(res); // hiç çağırılmadı
         return Promise.resolve(789);
     })
     .catch((err) => {
-        console.log(err.message); // something bad happened
+        console.log(err.message); // kötü bir şey oldu
     })
 ```
 
@@ -303,8 +303,8 @@ The fact that:
 effectively provides us with an async programming paradigm that allows better error handling than raw callbacks. More on this below.
 
 
-### TypeScript and promises
-The great thing about TypeScript is that it understands the flow of values through a promise chain.
+### TypeScript ve Promise'ler
+Typescript ile ilgili harika olan şey, bir promise chain içerisinde gerçekleşen değer akışını anlayabilmesidir.
 
 ```ts
 Promise.resolve(123)

From 43ac1c612bcf3d50df3adb3bcdc081206ceb41be Mon Sep 17 00:00:00 2001
From: Mert Susur <mail@mertsusur.com>
Date: Wed, 1 Feb 2017 10:08:14 +0000
Subject: [PATCH 32/74] =?UTF-8?q?Contributing=20kurallar=C4=B1na=20git=20m?=
 =?UTF-8?q?esajlar=C4=B1n=C4=B1=20ekliyorum?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CONTRIBUTING.md | 49 +++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 43 insertions(+), 6 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index dfda5dad7..8f5259ecc 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,20 +1,57 @@
- # Katkıda bulunmak isteyenler için Bilgilendirme: 
+ # Katkıda bulunmak isteyenler için bilgilendirme:
 
 *typescript-book kitabının yerelleştirmesini yaparken hedefimiz birebir çeviriden ziyade, bir Türk okuyucu tarafından bütünüyle anlaşılır bir kaynak oluşturmaktır.*
 
 ### Yerelleştirme İşlemi Aşamaları
-1. Katkıda bulunmak isteyenler, ilgili repository'de açılan issue'lar içerisinden (https://github.com/CodeFiction/typescript-book/issues) bir görevi üstlenip, değişiklikleri ve çevirileri kendi kopyası (forku) üzerinden gerçekleştirir. 
-2. Gerekli değişiklikler yapıldıktan sonra ana repository'e Pull Request gönderilir. 
+1. Katkıda bulunmak isteyenler, ilgili repository'de açılan issue'lar içerisinden (https://github.com/CodeFiction/typescript-book/issues) bir görevi üstlenip, değişiklikleri ve çevirileri kendi kopyası (forku) üzerinden gerçekleştirir.
+2. Gerekli değişiklikler yapıldıktan sonra ana repository'e Pull Request gönderilir.
 	..* Ana reposory'e gelen pull request'ini **iki farklı kişi** gözden geçirir.
-	..* İki ayrı kullanıcının da onayını alan pull request sonrasında ana repository'e merge (rebase and merge yöntemiyle) edilir. 
+	..* İki ayrı kullanıcının da onayını alan pull request sonrasında ana repository'e merge (rebase and merge yöntemiyle) edilir.
 	..* Gelen pull request'i merge işlemini gerçekleştiren kişi, aynı isimle sonuna "gözden geçirilecek" ekleyerek yeni bir issue açar. *(Açılan bu issue ile amacımız, yapılan değişikliklerin Türkçe dil ve imla kurallarına uygunluğunun denetlenmesini sağlamak.)*
 
 ### Ek Notlar
-- Katkıda bulunmak istediğiniz konuya yorum bırakarak son durumu sorabilirsiniz. Katılmak için talepte bulunabilirsiniz. 
+- Katkıda bulunmak istediğiniz konuya yorum bırakarak son durumu sorabilirsiniz. Katılmak için talepte bulunabilirsiniz.
 - Atanmış bir issue ile ilgili yardımcı olabilecekseniz issue sahibi ile iletişime geçebilirsiniz.
 - Üzerinizdeki görevi(issue) bırakmanız gerekirse lütfen topluluğa ilgili Gitter kanalı üzerinden haber veriniz.
-- Teknik terimlerin çevirisinde bir bütünlük sağlamak amacı ile bir [sözlük](GLOSSARY.md) oluşturulmaktadır. Lütfen çevirinizi yaparken ve bir Pull Request'i incelerken bu sözlükte yer alan terimleri takip ediniz. 
+- Teknik terimlerin çevirisinde bir bütünlük sağlamak amacı ile bir [sözlük](GLOSSARY.md) oluşturulmaktadır. Lütfen çevirinizi yaparken ve bir pull request'i incelerken bu sözlükte yer alan terimleri takip ediniz.
 - Diğer görüş ve önerileriniz için gitter kanalına bekleriz. https://gitter.im/codefiction/typescript-book
 
+### Kodları İndirirken
+- Öncelikle [codefiction/typescript-book](https://github.com/CodeFiction/typescript-book) repository'sini **fork** yaparak kendinize bir kopyasını oluşturun.
+- Daha sonra `git clone` komutunu kullanarak kendi bilgisayarınıza kendinize ait olan kopyayı indirin.
+- Kopyayı indirdikten sonra `git remote` komutunu kullanarak **codefiction** repository'sini yeni bir *remote* olarak ekleyin.
+```sh
+git remote add upstream https://github.com/CodeFiction/typescript-book.git
+```
+
+#### Değişikliklerinizi Gönderirken
+- Değişikliklerinizi yaptıktan sonra uygun **commit mesajı** ile değişikliklerinizi *commit* yapın.
+```sh
+git commit -m "Contributing kurallarına git mesajlarını ekliyorum"
+```
+- Yaptığınız değişikliği *push* yapmadan önce **git pull** komutunu kullanarak *upstream* i lokalinize indirin.
+```sh
+git pull upstream master --rebase
+```
+- Eğer merge konusunda bir sorun yaşamazsanız **git push** yapabilirsiniz.
+```sh
+git push origin master
+```
+- Artık GitHub üzerinden [**pull request**](https://help.github.com/articles/creating-a-pull-request/) oluşturabilirsiniz.
+
+#### Pull Request Yorumlarını Düzeltirken
+- Değişikliklerinizi yaptıktan sonra uygun **commit mesajı** ile değişikliklerinizi *commit* yapın.
+```sh
+git commit -m "Contributing kurallarını yorumlardan sonra düzelttim"
+```
+- Yaptığınız değişiklik *push* yapmadan önce **git pull** komutunu kullanarak *upstream* i lokalinize indirin.
+```sh
+git pull upstream master --rebase
+```
+- Eğer merge konusunda bir sorun yaşamazsanız **git push** yapabilirsiniz.
+```sh
+git push origin master
+```
+- Yeni bir *pull request* yapmanıza gerek kalmadan değişikliklerinizin önceki *pull request* içinde oluştuğunu göreceksiniz.
 
 :tr: Codefiction Ekibi

From 3783be9c0846863e8195fbb9979f721731214777 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Mon, 6 Feb 2017 10:11:23 +0300
Subject: [PATCH 33/74] awful.md review sonrasi duzeltme

---
 docs/javascript/awful.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/javascript/awful.md b/docs/javascript/awful.md
index 679d23951..339f0021b 100644
--- a/docs/javascript/awful.md
+++ b/docs/javascript/awful.md
@@ -9,7 +9,7 @@
 Gerçek şu ki ikisiyle de uğraşmanız gerekecektir. İkisi için de `==` ile kontrol edelim.
 
 ```ts
-/// bar aşagıdakilerden biri iken `foo.bar == undefined` yaptığınızı düşünün:
+/// bar aşağıdakilerden biri iken `foo.bar == undefined` yaptığınızı düşünün:
 console.log(undefined == undefined); // true
 console.log(null == undefined); // true
 console.log(0 == undefined); // false
@@ -20,7 +20,7 @@ Tavsiyem `undefined` veya `null`, ikisi için de `== null` ile kontrol etmelisin
 
 ## undefined
 
-Hatırlarsanız `== null` kullanmanız gerektiğini söylemiştim. Tabii ki kullanacaksınız (çünkü ben öyle söyledim ^). Kök seviyesindeki şeyler için kullanmayın. Katı modda (strict mode) eğer `foo` kullanırsanız ve `foo` tanımlanmamış (undefined) ise, `ReferenceError` **hatası** alırsınız ve tüm çağrı kümeniz bozulur.
+Hatırlarsanız `== null`'u nasıl kullanmanız gerektiğini söylemiştim. Tabii ki kullanacaksınız (çünkü ben öyle söyledim ^). Kök seviyesindeki şeyler için kullanmayın. Katı modda (strict mode) eğer `foo` kullanırsanız ve `foo` tanımlanmamış (undefined) ise, `ReferenceError` **hatası** alırsınız ve tüm çağrı kümeniz bozulur.
 
 > Katı mod (strict mode) kullanmalısınız ... ve aslında TS derleyicisi eğer modül kullanırsanız sizin için bunu ekleyecektir ... daha fazlası kitabın ilerleyen bölümlerinde var yani şu anda açık şekilde anlamış olmanız gerekmez :)
 
@@ -28,7 +28,7 @@ Yani bir değişkenin *global* düzeyde tanımlanıp tanımlanmadığını kontr
 
 ```ts
 if (typeof someglobal !== 'undefined') {
-  // someglobal şu anda kullanım için güvenlidir
+  // someglobal kullanımı şu anda güvenli
   console.log(someglobal);
 }
 ```

From abac9494309afd50b8d467de389d67587746dc4d Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Mon, 6 Feb 2017 11:01:41 +0300
Subject: [PATCH 34/74] Issue #4 let.md cevirisi

---
 docs/let.md | 60 ++++++++++++++++++++++++++---------------------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/docs/let.md b/docs/let.md
index a966a7b65..51702bcbb 100644
--- a/docs/let.md
+++ b/docs/let.md
@@ -1,6 +1,6 @@
 ### let
 
-`var` Variables in JavaScript are *function scoped*. This is different from many other languages (C# / Java etc.) where the variables are *block scoped*. If you bring a *block scoped* mindset to JavaScript, you would expect the following to print `123`, instead it will print `456`:
+JavaScript'deki `var` değişkenleri *fonksiyon faaliyet alan*'lıdır. Bu, değişkenlerin *blok faaliyet alanlı* olduğu diğer birçok dilden farklidir (C# / Java vb.). Eğer JavaScript'e *blok faaliyet alanlı* düşünce yapısı getirirseniz, aşağıdakilerin `123` çıktısı vermesini beklersiniz, bunun yerine  `456` yazdıracaktır:
 
 ```ts
 var foo = 123;
@@ -9,7 +9,7 @@ if (true) {
 }
 console.log(foo); // 456
 ```
-This is because `{` does not create a new *variable scope*. The variable `foo` is the same inside the if *block* as it is outside the if block. This is a common source of errors in JavaScript programming. This is why TypeScript (and ES6) introduces the `let` keyword to allow you to define variables with true *block scope*. That is if you use `let` instead of `var` you get a true unique element disconnected from what you might have defined outside the scope. The same example is demonstrated with `let`:
+Bunun nedeni ise `{` yeni bir *değişken faaliyet alanı* yaratmaz. foo değişkeni, if *bloğunun* içinde olduğu gibi if bloğunun dışında da aynıdır. Bu, JavaScript programlamada yaygın bir hata kaynağıdır. Bu nedenle TypeScript (ve ES6) size değişkenleri doğru *blok faaliyet alan*'ları ile tanımlayabilmeniz için `let` anahtar sözcüğünü sunar. Yani, `var` yerine `let` kullanırsanız, faaliyet alanının dışında tanımladıklarınızdan kopuk eşsiz bir eleman elde edersiniz. Aynı örneğin `let` ile gösterimi :
 
 ```ts
 let foo = 123;
@@ -19,7 +19,7 @@ if (true) {
 console.log(foo); // 123
 ```
 
-Another place where `let` would save you from errors is loops.
+`let`'in sizi hatalardan kurtaracağı bir başka yer ise döngülerdir.
 ```ts
 var index = 0;
 var array = [1, 2, 3];
@@ -28,10 +28,10 @@ for (let index = 0; index < array.length; index++) {
 }
 console.log(index); // 0
 ```
-In all sincerity we find it better to use `let` whenever possible as it leads to lesser surprises for new and existing multi-lingual developers.
+Samimiyetle, yeni ve mevcut çok dilli geliştiriciler için `let` kullanımını, daha az sürprizlerle karşılaşacaklarından uygun buluyoruz.
 
-#### Functions create a new scope
-Since we mentioned it, we'd like to demonstrate that functions create a new variable scope in JavaScript. Consider the following:
+#### Fonksiyonlar yeni faaliyet alanı oluşturur
+Bahsettiğimizden beri, JavaScript'te fonksiyonların yeni bir değişken faaliyet alanı oluşturduğunu göstermek istiyoruz. Aşağıdaki gösterimi inceleyelim:
 
 ```ts
 var foo = 123;
@@ -41,23 +41,23 @@ function test() {
 test();
 console.log(foo); // 123
 ```
-This behaves as you would expect. Without this it would be very difficult to write code in JavaScript.
+Bu beklediğiniz gibi davranıyor. Aksi takdirde JavaScript'de kod yazmak çok zor olurdu.
 
-#### Generated JS
-The JS generated by TypeScript is simple renaming of the `let` variable if a similar name already exists in the surrounding scope. E.g. the following is generated as is with a simple replacement of `var` with `let`:
+#### Üretilmiş JS
+TypeScript tarafından üretilen JS basitçe, let değişkenini çevreleyen faaliyet alanında benzer bir isim zaten varsa yeniden adlandırılmasıdır. Örneğin aşağıdaki `var` değişkeninin `let` ile basit bir yer değiştirmesi ile üretilir:
 
 ```ts
 if (true) {
     let foo = 123;
 }
 
-// becomes //
+// şu hale gelir //
 
 if (true) {
     var foo = 123;
 }
 ```
-However if the variable name is already taken by the surrounding scope then a new variable name is generated as shown (notice `_foo`):
+Ancak değişken ismi çevreleyen faaliyet alanı tarafından zaten alındıysa, yeni değişken ismi gösterildiği gibi üretilir (bakınız `_foo`):
 
 ```ts
 var foo = '123';
@@ -65,37 +65,37 @@ if (true) {
     let foo = 123;
 }
 
-// becomes //
+// şu hale gelir //
 
 var foo = '123';
 if (true) {
-    var _foo = 123; // Renamed
+    var _foo = 123; // yeniden adlandırılır
 }
 ```
 
-#### let in closures
-A common programming interview question for a JavaScript developer is what is the log of this simple file:
+#### kapsanımlar içindeki let
+Bir JavaScript geliştirici için alışılageldik bir programlama sorusu, bu basit dosya ne çıktı üretir:
 
 ```ts
 var funcs = [];
-// create a bunch of functions
+// birkaç fonksiyon oluştur
 for (var i = 0; i < 3; i++) {
     funcs.push(function() {
         console.log(i);
     })
 }
-// call them
+// ve onları çağır
 for (var j = 0; j < 3; j++) {
     funcs[j]();
 }
 ```
-One would have expected it to be `0,1,2`. Surprisingly it is going to be `3` for all three functions. Reason is that all three functions are using the variable `i` from the outer scope and at the time we execute them (in the second loop) the value of `i` will be `3` (that's the termination condition for the first loop).
+Birileri bunun `0,1,2` olmasını beklerdi. Şaşırtıcı bir şekilde her üç işlev için `3` olacak. Bunun nedeni, her üç işlevin de `i` değişkenini dış faaliyet alanında kullanıyor olması ve o anda bunları çalıştırdığımızda (ikinci döngü içinde) `i`'nin değerinin `3` olması (bu, ilk döngü için sonlandırma koşuludur).
 
-A fix would be to create a new variable in each loop specific to that loop iteration. As we've learnt before we can create a new variable scope by creating a new function and immediately executing it (i.e. the IIFE pattern from classes `(function() { /* body */ })();`) as shown below:
+Doğrusu, o döngü tekrarlamasına özgü her döngüde yeni bir değişken oluşturmak olacaktır. Daha önce öğrendiğimiz gibi, yeni bir fonksiyon oluşturup onu anında çalıştırarak yeni bir değişken faaliyet alanı oluşturabiliriz, (örneğin sınıflardaki IIFE kalıbı `(function() { /* body */ })();`) aşağıda gösterildiği gibi:
 
 ```ts
 var funcs = [];
-// create a bunch of functions
+// birkaç fonksiyon oluştur
 for (var i = 0; i < 3; i++) {
     (function() {
         var local = i;
@@ -104,35 +104,35 @@ for (var i = 0; i < 3; i++) {
         })
     })();
 }
-// call them
+// ve onları çağır
 for (var j = 0; j < 3; j++) {
     funcs[j]();
 }
 ```
-Here the functions close over (hence called a `closure`) the *local* variable (conveniently named `local`) and use that instead of the loop variable `i`.
+Burada fonksiyonlar, *yerel* değişkeni (uygun isimlendirmesi `yerel`) kapatıyor (dolayısıyla `kapsanım` denir) ve bunu, döngü değişkeni `i` yerine kullanıyor.
 
-> Note that closures come with a performance impact (they need to store the surrounding state).
+> Kapsanımların performans etkisine sahip olduğunu unutmayın (çevreleyen durumu tutmak zorundalar).
 
-The ES6 `let` keyword in a loop would have the same behavior as the previous example:
+Döngü içerisindeki ES6 `let` anahtar sözcüğü, önceki örnekteki gibi aynı davranışa sahip olurdu:
 
 ```ts
 var funcs = [];
-// create a bunch of functions
-for (let i = 0; i < 3; i++) { // Note the use of let
+// birkaç fonksiyon oluştur
+for (let i = 0; i < 3; i++) { // let kullanımını unutmayın
     funcs.push(function() {
         console.log(i);
     })
 }
-// call them
+// ve onları çağır
 for (var j = 0; j < 3; j++) {
     funcs[j]();
 }
 ```
 
-Using a `let` instead of `var` creates a variable `i` unique to each loop iteration.
+`var` yerine `let` kullanılması, her döngü tekrarlanmasında eşsiz bir `i` değişkeni yaratır.
 
-#### Summary
-`let` is extremely useful to have for the vast majority of code. It can greatly enhance your code readability and decrease the chance of a programming error.
+#### Özet
+`let` kodun büyük çoğunluğuna hakim olmak için son derece kullanışlıdır. Kodunuzun okunabilirliğini büyük ölçüde artırabilir ve programlama hatalarının olasılığını azaltır.
 
 
 

From 2d9fff2287b1047653cec16f5beb0115ca4782a9 Mon Sep 17 00:00:00 2001
From: DorukUlucay <doruk.ulucay@cronom.com>
Date: Mon, 6 Feb 2017 21:09:14 +0200
Subject: [PATCH 35/74] promises.md and readme.md ready for review

---
 README.md       |  24 +++++------
 docs/promise.md | 105 ++++++++++++++++++++++++------------------------
 2 files changed, 65 insertions(+), 64 deletions(-)

diff --git a/README.md b/README.md
index 456d71e34..8b4025b6a 100644
--- a/README.md
+++ b/README.md
@@ -10,19 +10,19 @@ Typescript kullanılırken genel olarak karşılaşılan hatalarla ilgilenmektey
 * Bu harika kitap için teşekkürler. Kitaptan pek çok şey öğrendim. ([link](https://www.gitbook.com/book/basarat/typescript/discussions/21#comment-1468279131934))
 * Muhtemelen mevcut en iyi Typescript kitabı. İyi iş. ([link](https://twitter.com/thelondonjs/status/756419561570852864))
 * Açıklama ve örneklerin isabetliliğine ve açıklığına bayıldım. ([link](https://twitter.com/joe_mighty/status/758290957280346112))
-* For the low, low price of free, you get pages of pure awesomeness. Chock full of source code examples and clear, concise explanations, TypeScript Deep Dive will help you learn TypeScript development. ([link](https://www.nativescript.org/blog/details/free-book-typescript-deep-dive))
+* Hiç ücret ödemeden sayfalar dolusu mükemmeliğe sahip oluyorsunuz. Tam kaynak kodlar, temiz ve isabetli açıklamalarla Typescript Deep Dive, Typescript geliştirmeyi öğrenmenize yardım edecek. ([link](https://www.nativescript.org/blog/details/free-book-typescript-deep-dive))
 * Kocaman bir teşekkür! **Best TypeScript 2 detailed explanation!** ([link](https://www.gitbook.com/book/basarat/typescript/discussions/38))
-* This gitbook got my project going pronto. Fluent easy read 5 stars. ([link](https://twitter.com/thebabellion/status/779888195559235584))
-* I recommend the online #typescript book by @basarat you'll love it.([link](https://twitter.com/markpieszak/status/788099306590969860))
-* I've always found this by @basarat really helpful. ([link](https://twitter.com/Brocco/status/789887640656945152))
-* We must highlight TypeScript Deep Dive, an open source book.([link](https://www.siliconrepublic.com/enterprise/typescript-programming-javascript))
-* Great online resource for learning. ([link](https://twitter.com/rdfuhr/status/790193307708076035))
-* Thank you for putting this book together, and for all your hard work within the TypeScript community. ([link](https://github.com/basarat/typescript-book/pull/183#issuecomment-257799713))
-* TypeScript Deep Dive is one of the best technical texts I've read in a while. ([link](https://twitter.com/borekb/status/794287092272599040))
-* Thanks @basarat for the TypeScript Deep Dive Book. Help me a lot with my first TypeScript project. ([link](https://twitter.com/betolinck/status/797901548562960384))
-* Thanks to @basarat for this great #typescript learning resource. ([link](https://twitter.com/markuse1501/status/799116176815230976))
-* Guyz excellent book on Typescript(@typescriptlang) by @basarat ([link](https://twitter.com/deeinlove/status/813245965507260417))
-* Leaning on the legendary @basarat's "TypeScript Deep Dive" book heavily at the moment ([link](https://twitter.com/sitapati/status/814379404956532737))
+* Bu git kitabı sayesinde, projemi hızlıca tamamladım. Akıcı, Kolay. 5 yıldız. ([link](https://twitter.com/thebabellion/status/779888195559235584))
+* @basarat'ın yazdığı online #typescript kitabını öneriyorum. Bunu seveceksin. ([link](https://twitter.com/markpieszak/status/788099306590969860))
+* @basarat'ın bu kaynağını her zaman çok faydalı buldum. ([link](https://twitter.com/Brocco/status/789887640656945152))
+* Bir açık kaynak kitap olan TypeScript Deep Dive'ın altını çizmeliyiz. ([link](https://www.siliconrepublic.com/enterprise/typescript-programming-javascript))
+* Öğrenmek için harika bir online kaynak. ([link](https://twitter.com/rdfuhr/status/790193307708076035))
+* Bu harika kitabu hazırlandığın için ve Typescript komünitesine olan katkılarından dolayı teşekkürler. ([link](https://github.com/basarat/typescript-book/pull/183#issuecomment-257799713))
+* TypeScript Deep Dive uzun zamandır okuduğum en iyi teknik metinlerden biri. ([link](https://twitter.com/borekb/status/794287092272599040))
+* TypeScript Deep Dive kitabı için @basarat'a teşekkürler. İlk Typescript ptojemde bana oldukça yardımcı oldu. ([link](https://twitter.com/betolinck/status/797901548562960384))
+* Bu harika #typescript kaynağı için @basarat'a teşekkürler. ([link](https://twitter.com/markuse1501/status/799116176815230976))
+* Typescript üzerine @basarat'tan harika bir kitap (@typescriptlang) ([link](https://twitter.com/deeinlove/status/813245965507260417))
+* @basarat'ın efsanevi TypeScript Deep Dive kitabını okumaktayım. ([link](https://twitter.com/sitapati/status/814379404956532737))
 * numTimesPointedPeopleToBasaratsTypeScriptBook++; ([link](https://twitter.com/brocco/status/814227741696462848))
 
 ## Başlamak için
diff --git a/docs/promise.md b/docs/promise.md
index fb4e7f57b..70da2b614 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -1,10 +1,10 @@
 ## Promise
 
-Promise, pek çok modern Javascript motorunda bulunan ve rahatlıkla polyfill edilebilen bir sınıftır. Promise'lerin öncelikli amacı Async/Callback stili yazılmış koda senkronize stilde hata yakalama fonksiyonunu kazandırmaktır.
+Promise, pek çok modern Javascript motorunda bulunan ve rahatlıkla polyfill edilebilen bir sınıftır. Promise'lerin öncelikli amacı Async/Callback tarzı yazılmış koda senkronize stilde hata yakalama fonksiyonunu kazandırmaktır.
 
-### Callback style code
+### Callback tarzı kod
 
-Promise'in sağladığı kolaylıkları daha iyi anlamak için sadece Callback kullanarak Async kod yazan bir örnek görelim. Bir JSON dosyasından asenkron bir şekilde dosya okuma örneğini değerlendirelim. Senkronize bir vesiyonu oldukça kolay olacaktır:
+Promise'in sağladığı kolaylıkları daha iyi anlamak için sadece Callback kullanarak Async çalışan bir örnek görelim. Bir JSON dosyasından Async bir şekilde dosya okuma örneğini değerlendirelim. Sync bir versiyonu oldukça kolay olacaktır:
 
 ```ts
 import fs = require('fs');
@@ -16,7 +16,7 @@ function loadJSONSync(filename: string) {
 // geçerli json dosyası
 console.log(loadJSONSync('good.json'));
 
-// olmayan json dosyası. bu yüzden fs.readFilesync hata verir
+// var olmayan json dosyası. bu yüzden fs.readFilesync hata verir
 try {
     console.log(loadJSONSync('absent.json'));
 }
@@ -33,7 +33,7 @@ catch (err) {
 }
 ```
 
-Bu basit `loadJSONSync` fonksiyonunun üç davranışı vardır. Geçerli bir dönüş değeri, bir dosya sistemi hatası ya da JSON.parse hatası. Bu hataları diğer senkronize çalışan dillerde yaptığımız gibi basit try/catch bloğu ile yakalıyoruz. Şimdi bu fonksiyonun düzgün çalışan bir asenkron versiyonunu yapalım. Düzgün bir ilk deneme (with a trivial error checking) aşağıdaki şekilde olacaktır.
+Bu basit `loadJSONSync` fonksiyonunun üç davranışı vardır. Geçerli bir dönüş değeri, bir dosya sistemi hatası ya da JSON.parse hatası. Bu hataları diğer Sync çalışan dillerde yaptığımız gibi basit try/catch bloğu ile yakalıyoruz. Şimdi bu fonksiyonun düzgün çalışan bir Async versiyonunu yapalım. Düzgün bir ilk deneme (küçük bir hata yakalama mekanizması ile) aşağıdaki şekilde olacaktır.
 
 ```ts
 import fs = require('fs');
@@ -47,12 +47,12 @@ function loadJSON(filename: string, cb: (error: Error, data: any) => void) {
 }
 ```
 
-Yeteri kadar basit, bir callback alır, bulduğu dosya sistemi hatalarını callback'e iletir. Eğer dosya sistemi hatası yok ise JSON.parse işleminin sonucunu döndürür. Callback'lere dayalı asenkron fonksiyonlarla çalışılırken unutulmaması gereken noktalar:
+Yeteri kadar basit, bir callback alır, bulduğu dosya sistemi hatalarını callback'e iletir. Eğer dosya sistemi hatası yok ise JSON.parse işleminin sonucunu döndürür. Callback'lere dayalı Async fonksiyonlarla çalışılırken unutulmaması gereken noktalar:
 
 1. Bir callback'i asla iki defa çağırmamak
 2. Asla hata fırlatmamak
 
-Bu basit fonksiyon 2. noktada çalışmakta problem yaşıyor. Aslında eğer geçersiz JSON verilir ise, JSON.parse hata verir, callback hiçbir zaman çağırılmaz ve uygulama çöker. Bu durum aşağıdaki örnekte gösterilmiştir.
+Bu basit fonksiyon 2. noktada problem yaşıyor. Aslında eğer geçersiz JSON verilir ise, JSON.parse hata verir, callback hiçbir zaman çağırılmaz ve uygulama çöker. Bu durum aşağıdaki örnekte gösterilmiştir.
 
 ```ts
 import fs = require('fs');
@@ -73,7 +73,7 @@ loadJSON('invalid.json', function (err, data) {
 });
 ```
 
-Bu durumu düzeltmek için naifçe bir çaba, JSON.parse'ı bir try/catch'e almak olurdu, aşağıdaki örnekteki gibi:
+Bu durumu düzeltmek için naifçe bir çaba, JSON.parse'ı bir try/catch'e almak olurdu. Aşağıdaki örnekteki gibi:
 
 ```ts
 import fs = require('fs');
@@ -102,7 +102,7 @@ loadJSON('invalid.json', function (err, data) {
 });
 ```
 
-Yine de bu kodda yakalaması zor bir hata var. Eğer `JSON.parse` değil de callback(`cb`) hata fırlatırsa, biz bunu `try`/`catch` ile sarmaladığımız için `catch` çalışır ve callback'i bir daha çağırırız. Bu örnekte callback iki defa çağırılır! Bu aşağıdaki örnekte gösterilmiştir:
+Yine de bu kodda yakalaması zor bir hata var. Eğer `JSON.parse` değil de callback(`cb`) hata fırlatırsa, biz bunu `try`/`catch` ile sarmaladığımız için `catch` çalışır ve callback'i bir daha çağırırız. Bu örnekte callback iki defa çağırılır! Bu, aşağıdaki örnekte gösterilmiştir:
 
 ```ts
 import fs = require('fs');
@@ -168,7 +168,7 @@ function loadJSON(filename: string, cb: (error: Error) => void) {
     });
 }
 ```
-Bunu birkaç kez yaptıktan sonra çok daha kolay olmakla beraber basit bir hata yakalama için bu çok fazla boilerplate kod yazmak anlamına geliyor. Şimdi promise'leri kullanarak javascript'te asenkron kodla uğraşmanın daha iyi bir yolunu bulalım.
+Bu, birkaç kez yaptıktan sonra çok daha kolay olmakla beraber, basit bir hata yakalama için çok fazla boilerplate kod yazmak anlamına geliyor. Şimdi promise'leri kullanarak javascript'te asenkron kodla uğraşmanın daha iyi bir yolunu bulalım.
 
 
 ## Bir Promise oluşturmak
@@ -177,7 +177,7 @@ Bir promise `pending`(çalışmaya devam ediyor), `resolved`(çalışması sonla
 
 ![](https://raw.githubusercontent.com/basarat/typescript-book/master/images/promise%20states%20and%20fates.png)
 
-Bir promise oluşturalım. Bunun için promise ctor'u üzerinde `new` kelimesini çalıştırmak yeterli. `resolve` and `reject` fonksiyonları promise'in durumunu almak için constructor'a geçilir.
+Bir promise oluşturalım. Bunun için promise yapıcı metodu (constructor) üzerinde `new` kelimesini çalıştırmak yeterli. `resolve` and `reject` fonksiyonları promise'in durumunu almak için yapıcı metoda geçilir.
 
 ```ts
 const promise = new Promise((resolve, reject) => {
@@ -185,7 +185,7 @@ const promise = new Promise((resolve, reject) => {
 });
 ```
 
-### Promise'in sonucuna abone olmak
+### Promise'in sonucunu gözlemlemek
 
 Promise'in sonucu `.then`(eğer sonlanmış ise) veya `.catch`(eğer reddedilmiş ise) metotları ile gözlemlenebilir.
 
@@ -213,9 +213,9 @@ promise.catch((err) => {
 });
 ```
 
-> TIP: Promise Shortcuts
-* Quickly creating an already resolved promise : `Promise.resolve(result)`
-* Quickly creating an already rejected promise : `Promise.reject(error)`
+> İPUCU: Promise Kısayolları
+* Hızlı bir şekilde çözülmüş bir promise yaratmak : `Promise.resolve(result)`
+* Hızlı bir şekilde reddedilmiş bir promise yaratmak : `Promise.reject(error)`
 
 ### Promise'lerin zincirlenebilmesi
 Promise'lerin zincirlenebilir olması **en önemli özelliğidir**. Bir Promise'iniz olduğunda, `then` fonksiyonunu kullanarak promise zinciri yaratabilirsiniz.
@@ -230,7 +230,7 @@ Promise.resolve(123)
     })
     .then((res) => {
         console.log(res); // 456
-        return Promise.resolve(123); // Bir promise dmndürüyor olduğumuza dikkat edin
+        return Promise.resolve(123); // Bir promise döndürüyor olduğumuza dikkat edin
     })
     .then((res) => {
         console.log(res); // Bu `then`'in çözümlenmiş değer ile çağırıldığına dikkat edin.   
@@ -238,7 +238,7 @@ Promise.resolve(123)
     })
 ```
 
-* you can aggregate the error handling of any preceding portion of the chain with a single `catch`
+* zincirin herhangi bir kısmında gerçekleşen bir hatayı tek bir `catch` ile yakalayabilirsiniz.
 
 ```ts
 // Reddedilen bir promise yaratın
@@ -295,12 +295,12 @@ Promise.resolve(123)
     })
 ```
 
-The fact that:
+Gerçek şu ki:
 
-* errors jump to the tailing `catch` (and skip any middle `then` calls) and
-* synchronous errors also get caught by any tailing `catch`.
+* hatalar, sıradaki ilk `catch`'e gider (aradaki `then`'leri atlayarak) ve
+* senkronizasyon hatası da sıradaki ilk `catch` ile yakalanır
 
-effectively provides us with an async programming paradigm that allows better error handling than raw callbacks. More on this below.
+Bu da, bize sadece callback kullanımına kıyasla daha iyi bir hata yakalama sağlayan, efektif bir asenkron programlama paradigması kazandırır. Bu örnek üzerine daha fazla bilgi aşağıdadır.
 
 
 ### TypeScript ve Promise'ler
@@ -309,43 +309,44 @@ Typescript ile ilgili harika olan şey, bir promise chain içerisinde gerçekle
 ```ts
 Promise.resolve(123)
     .then((res)=>{
-         // res is inferred to be of type `number`
+         // res'in `number` olduğuna karar verilir
          return true;
     })
     .then((res) => {
-        // res is inferred to be of type `boolean`
+        // res'in `boolean` tipinde olduğuna karar verilir
 
     });
 ```
 
-Of course it also understands unwrapping any function calls that might return a promise:
+Bu yapı tabii ki promise döndürme ihtimali olan fonksiyon çağrılarını da anlar:
+
 
 ```ts
 function iReturnPromiseAfter1Second():Promise<string> {
     return new Promise((resolve)=>{
-        setTimeout(()=>resolve("Hello world!"), 1000);
+        setTimeout(()=>resolve("Merhaba Dünya!"), 1000);
     });
 }
 
 Promise.resolve(123)
     .then((res)=>{
-         // res is inferred to be of type `number`
-         return iReturnPromiseAfter1Second(); // We are returning `Promise<string>`
+         // res'in `number` olduğuna karar verilir
+         return iReturnPromiseAfter1Second(); // Bir promise döndürüyoruz `Promise<string>`
     })
     .then((res) => {
-        // res is inferred to be of type `string`
-        console.log(res); // Hello world!
+        // res'in `string` olduğuna karar verilir
+        console.log(res); // Merhaba Dünya!
     });
 ```
 
 
-### Converting a callback style function to return a promise
+### Callback tarzı yazılmış bir fonksiyonu Promise döndüren bir fonksiyona çevirmek
 
-Just wrap the function call in a promise and
-- `reject` if an error occurs,
-- `resolve` if it is all good.
+Fonksiyon çağırımını bir promise ile sarmalayın ve
+- herhangi bir hata olursa `reject`,
+- olmazsa `resolve` döndürün.
 
-E.g. let's wrap `fs.readFile`
+Örnek olarak `fs.readFile` sarmalayalım:
 
 ```ts
 import fs = require('fs');
@@ -360,33 +361,33 @@ function readFileAsync(filename:string):Promise<any> {
 ```
 
 
-### Revisiting the JSON example
+### JSON örneğine geri dönüş
 
-Now let's revisit our `loadJSON` example and rewrite an async version that uses promises. All that we need to do is read the file contents as a promise, then parse them as JSON and we are done. This is illustrated in the below example:
+Şimdi `loadJSON` örneğimize geri dönelim ve promise'leri kullanan async bir versiyonunu yazalım. Yapmamız gereken tek şey dosya içeriğini bir promise olarak okumak ve okuma bittiğinde JSON olarak parse etmek. Bu, aşağıdaki örnekte gösterilmiştir:
 
 ```ts
 function loadJSONAsync(filename: string): Promise<any> {
-    return readFileAsync(filename) // Use the function we just wrote
+    return readFileAsync(filename) // yazmış olduğumuz fonksiyonu kullanıyoruz
                 .then(function (res) {
                     return JSON.parse(res);
                 });
 }
 ```
 
-Usage (notice how similar it is to the original `sync` version introduced at the start of this section 🌹):
+Kullanım (bu bölümün başında yapmış olduğumuz `sync` versiyona ne kadar benzediğine dikkat edin 🌹):
 ```ts
-// good json file
+// geçerli json dosyası
 loadJSONAsync('good.json')
     .then(function (val) { console.log(val); })
     .catch(function (err) {
-        console.log('good.json error', err.message); // never called
+        console.log('good.json error', err.message); // hiç çağırılmadı
     })
 
-// non-existent json file
+// var olmayan json dosyası
     .then(function () {
         return loadJSONAsync('absent.json');
     })
-    .then(function (val) { console.log(val); }) // never called
+    .then(function (val) { console.log(val); }) // hiç çağırılmadı
     .catch(function (err) {
         console.log('absent.json error', err.message);
     })
@@ -395,31 +396,31 @@ loadJSONAsync('good.json')
     .then(function () {
         return loadJSONAsync('invalid.json');
     })
-    .then(function (val) { console.log(val); }) // never called
+    .then(function (val) { console.log(val); }) // hiç çağırılmadı
     .catch(function (err) {
         console.log('bad.json error', err.message);
     });
 ```
 
-The reason why this function was simpler is because the "`loadFile`(async) + `JSON.parse` (sync) => `catch`" consolidation was done by the promise chain. Also the callback was not called by *us* but called by the promise chain so we didn't have the chance of making the mistake of wrapping it in a `try/catch`.
+Bu fonksiyonun daha basit olmasının sebebi "`loadFile`(async) + `JSON.parse` (sync) => `catch`" kısmının promise zinciri tarafından üstlenmilmiş olmasıdır. Ayrıca callback *bizim tarafımızdan değil*, promise zinciri tarafından çağırıldığı için `try/catch` bloğu ile sarmalama hatasına düşmemiş olduk.
 
-### Parallel control flow
-We have seen how trivial doing a serial sequence of async tasks is with promises. It is simply a matter of chaining `then` calls.
+### Paralel akış kontrolü
+Promise kullanarak asenkron işler yapmanın ne kadar kolay olduğunu gördük. Aslında bu sadece `then` çağırımlarını birbirine bağlamaktan ibaretti.
 
-However you might potentially want to run a series of async tasks and then do something with the results of all of these tasks. `Promise` provides a static `Promise.all` function that you can use to wait for `n` number of promises to complete. You provide it with an array of `n` promises and it gives you array of `n` resolved values. Below we show Chaining as well as Parallel:
+Yine de birden fazla asenkron işi gerçekleştirip aldığınız sonuçla başka bir iş yapmak isteyebilirsiniz. `Promise`, vermiş olduğunuz `n` sayıdaki promise'in tamamlanmasını bekleyip, toplam sonucu döndüren statik bir `Promise.all` fonksiyonuna sahiptir. Bu fonksiyona `n` sayıda promise içeren bir dizi verirsiniz ve bu fonksiyon da size `n` sayıda çözümlenmiş sonuç döndürür. Aşağıda paralel'in yanı sıra zincirlemeyi de gösteriyoruz:
 
 ```ts
-// an async function to simulate loading an item from some server
+// bir sunucudan, bir nesnenin yüklenmesini simüle eden asenkton bir fonksiyon
 function loadItem(id: number): Promise<{id: number}> {
     return new Promise((resolve)=>{
         console.log('loading item', id);
-        setTimeout(() => { // simulate a server delay
+        setTimeout(() => { // sunucu gecikmesini simüle ediyoruz
             resolve({ id: id });
         }, 1000);
     });
 }
 
-// Chaining
+// zincirleme
 let item1, item2;
 loadItem(1)
     .then((res) => {
@@ -429,14 +430,14 @@ loadItem(1)
     .then((res) => {
         item2 = res;
         console.log('done');
-    }); // overall time will be around 2s
+    }); // toplam geçen zaman 2 saniye civarında olacaktır
 
 // Parallel
 Promise.all([loadItem(1),loadItem(2)])
     .then((res) => {
         [item1,item2] = res;
         console.log('done')
-    }); // overall time will be around 1s
+    }); //  toplam geçen zaman 1 saniye civarında olacaktır
 ```
 
 

From 4d7ade4c2879ff3f7adbfab64c491ac59d670ce4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Atar?= <ugur.atar@metry.io>
Date: Wed, 8 Feb 2017 00:04:01 +0100
Subject: [PATCH 36/74] Update async-await.md

issue nr: #16
---
 docs/async-await.md | 36 +++++++++++++++++-------------------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/docs/async-await.md b/docs/async-await.md
index 85e4a5a7c..99bb168f5 100644
--- a/docs/async-await.md
+++ b/docs/async-await.md
@@ -1,9 +1,8 @@
-## Async Await
-
-As a thought experiment imagine the following, a way to tell the JavaScript runtime to pause the executing of code on the `await` keyword when used on a promise and resume *only* once (and if) the promise returned from the function is settled.
+## Asenkron Bekleme
+Şöyle bir deney kurguladığımızı farzedelim, Javascript çalışma zamanında `await` anahtar kelimesi bir `promise`(söz) ile birlikte görüldüğü anda çalışmayı duraksayabiliyor ve sadece verilen sözün sonuca ulaşması tamamlandıktan sonra -sadece bir kerelik- çalışmaya kaldığı yerden devam ediyor.
 
 ```ts
-// Not actual code. A thought experiment
+//Aşağıda gördüğünüz gerçek bir kod parçası değildir
 async function foo() {
     try {
         var val = await getMeAPromise();
@@ -13,28 +12,27 @@ async function foo() {
         console.log('Error: ', err.message);
     }
 }
-```
 
-When the promise settles execution continues,
-* if it was fulfilled then await will return the value,
-* if it's rejected an error will be thrown synchronously which we can catch.
-
-This suddenly (and magically) makes asynchronous programming as easy as synchronous programming.  Three things are needed for this though experiment are.
+```
+Verilen söz bir sonuca ulaştığında program çalışmaya devam eder,
+* Eğer verilen söz yerine getirildiyse `await` verilen sözün sonucunu dönecektir,
+* Eğer verilen söz yerine getirilmediyse (reddedildiyse), çalışma zamanında yakalayabileceğimiz bir hata senkron olarak fırlatılacaktır  
 
-* Ability to *pause function* execution.
-* Ability to *put a value inside* the function.
-* Ability to *throw an exception inside* the function.
+Bu yaklaşım asenkron programlamayı bir anda senkron programlama gibi kolay bir hale getiriyor.Bu deney için üç bileşen gereklidir.  
+* *Fonksiyonları duraksatabilme* kabiliyeti.
+* Fonksiyonun içerisine *bir değer koyabilme* kabiliyeti.
+* Fonksiyonun içerisinden *bir istisna fırlatabilme* kabiliyeti.
 
-This is exactly what generators allowed us to do! The thought experiment *is actually real* and is the `async`/`await` implementation in TypeScript / JavaScript. Under the covers it just uses generators.
+İşte bu saydıklarımız tam olarak *oluşturucular*ın yapmamıza olanak tanıdığı şey. Aslında farzedilen deney bir kurgu değil gerçeğin ta kendisidir ve  Javascript / Typescript dünyasında `asenkron`/`bekle` implementasyonu olarak ifade edilir. Perdenin arkasında oluşturucuları kullanır.
 
-### Generated JavaScript
 
-You don't have to understand this, but its fairly simple if you've [read up on generators][generators]. The function `foo` can be simply wrapped up as follows:
+### Oluşturulmuş JavaScript
+Bunu tamamen anlamak zorunda değilsiniz ama [oluşturucuları][generators] okursanız oldukça basit olduğunu göreceksiniz. `foo` fonksiyonu aşağıdaki gibi basit bir şekilde paketlenebilir:
 
 ```ts
-const foo = wrapToReturnPromise(function* () {
+const foo = sozAlmakicinPaketle(function* () {
     try {
-        var val = yield getMeAPromise();
+        var val = yield banaSozVer();
         console.log(val);
     }
     catch(err) {
@@ -42,7 +40,7 @@ const foo = wrapToReturnPromise(function* () {
     }
 })
 ```
+`sozAlmakicinPaketle`'nin `oluşturucuyu` almak için sadece oluşturucu fonksiyonu çağırdığı bir durumda; daha sonra `generator.next()` ifadesi çağırılır, eğer dönen değer bir `söz` ise, `generator.next(result)` veya `generator.throw(error)` ifadelerinden biri duruma göre yakalanarak işlem sonlandırılır. 
 
-where the `wrapToReturnPromise` just executes the generator function to get the `generator` and then use `generator.next()`, if the value is a `promise` it would `then`+`catch` the promise and depending upon the result call `genertor.next(result)` or `genertor.throw(error)`. That's it!
 
 [generators]:./generators.md

From df3124b71606e21175521d496c33b8357c940e68 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Wed, 8 Feb 2017 19:29:39 +0300
Subject: [PATCH 37/74] classes.md first commit

---
 docs/classes.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/docs/classes.md b/docs/classes.md
index a1f400e91..355d8d45f 100644
--- a/docs/classes.md
+++ b/docs/classes.md
@@ -1,10 +1,10 @@
-### Classes
-The reason why it's important to have classes in JavaScript as a first class item is that:
-1. [Classes offer a useful structural abstraction](./tips/classesAreUseful.md)
-1. Provides a consistent way for developers to use classes instead of every framework (emberjs,reactjs etc) coming up with their own version.
-1. Object Oriented Developers already understand classes.
+### Sınıflar
+JavaScript'teki yüksek öncelikli öğeler olan sınıflara sahip olmak şu nedenlerden ötürü önemlidir:
+1. [Sınıflar, soyutlama için faydalı bir yapı sunarlar.](./tips/classesAreUseful.md)
+2. Geliştiricilere, kendi sürümleriyle gelen frameworkler (emberjs,reactjs etc) yerine, sınıfları kullanabilmeleri için tutarlı bir yöntem sağlar. 
+3. Nesneye yönelik geliştiriciler halihazırda sınıf kavramına aşinalar.
 
-Finally JavaScript developers can *have `class`*. Here we have a basic class called Point:
+Sonunda JavaScript geliştiricileri de artık *`class`*'ları kullanabilirler. Point adında basit bir örnek sınıfımız var: 
 ```ts
 class Point {
     x: number;
@@ -22,7 +22,7 @@ var p1 = new Point(0, 10);
 var p2 = new Point(10, 20);
 var p3 = p1.add(p2); // {x:10,y:30}
 ```
-This class generates the following JavaScript on ES5 emit:
+Bu sınıf, ES5'te aşağıdaki gibi bir JavaScript'i üretir:
 ```ts
 var Point = (function () {
     function Point(x, y) {
@@ -37,7 +37,7 @@ var Point = (function () {
 ```
 This is a fairly idiomatic traditional JavaScript class pattern now as a first class language construct.
 
-### Inheritance
+### Kalıtım
 Classes in TypeScript (like other languages) support *single* inheritance using the `extends` keyword as shown below:
 
 ```ts

From 3a8f3c6e1e15b3a3f17baef5766fcfc6aed4e040 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Atar?= <ugur.atar@metry.io>
Date: Wed, 8 Feb 2017 19:13:57 +0100
Subject: [PATCH 38/74] Update async-await.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Async Await çevirisi için çeşitli düzeltmeler, türkçeleştirmeler, düşük cümleleri adam etmeler falan.
---
 docs/async-await.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/async-await.md b/docs/async-await.md
index 99bb168f5..e80032dd9 100644
--- a/docs/async-await.md
+++ b/docs/async-await.md
@@ -1,5 +1,5 @@
 ## Asenkron Bekleme
-Şöyle bir deney kurguladığımızı farzedelim, Javascript çalışma zamanında `await` anahtar kelimesi bir `promise`(söz) ile birlikte görüldüğü anda çalışmayı duraksayabiliyor ve sadece verilen sözün sonuca ulaşması tamamlandıktan sonra -sadece bir kerelik- çalışmaya kaldığı yerden devam ediyor.
+Şöyle bir deney kurguladığımızı varsayalım, Javascript çalışma zamanında `await` anahtar kelimesi bir `promise`(söz) ile birlikte görüldüğü anda kodun çalışması duraksayabilir ve sadece verilen sözün sonuca ulaşması tamamlandıktan sonra -sadece bir kerelik- çalışmaya kaldığı yerden devam eder.
 
 ```ts
 //Aşağıda gördüğünüz gerçek bir kod parçası değildir
@@ -23,7 +23,7 @@ Bu yaklaşım asenkron programlamayı bir anda senkron programlama gibi kolay bi
 * Fonksiyonun içerisine *bir değer koyabilme* kabiliyeti.
 * Fonksiyonun içerisinden *bir istisna fırlatabilme* kabiliyeti.
 
-İşte bu saydıklarımız tam olarak *oluşturucular*ın yapmamıza olanak tanıdığı şey. Aslında farzedilen deney bir kurgu değil gerçeğin ta kendisidir ve  Javascript / Typescript dünyasında `asenkron`/`bekle` implementasyonu olarak ifade edilir. Perdenin arkasında oluşturucuları kullanır.
+İşte bu saydıklarımız tam olarak *oluşturucular*ın yapmamıza olanak tanıdığı şey. Aslında bahsettiğimiz deney bir kurgu değil gerçeğin ta kendisidir ve  Javascript / Typescript dünyasında `asenkron`/`bekle` uyarlaması olarak ifade edilir.Bu uyarlama perdenin arkasında oluşturucuları kullanır.
 
 
 ### Oluşturulmuş JavaScript
@@ -40,7 +40,7 @@ const foo = sozAlmakicinPaketle(function* () {
     }
 })
 ```
-`sozAlmakicinPaketle`'nin `oluşturucuyu` almak için sadece oluşturucu fonksiyonu çağırdığı bir durumda; daha sonra `generator.next()` ifadesi çağırılır, eğer dönen değer bir `söz` ise, `generator.next(result)` veya `generator.throw(error)` ifadelerinden biri duruma göre yakalanarak işlem sonlandırılır. 
+`sozAlmakicinPaketle`'nin `oluşturucuyu` almak için sadece oluşturucu fonksiyonu çağırdığı bir durumda; daha sonra `generator.next()` ifadesi çağırılır, eğer dönen değer bir `söz` ise, `generator.next(result)` veya `generator.throw(error)` ifadelerinden biri duruma göre `then` veya `catch` ile yakalanarak işlem sonlandırılır. 
 
 
 [generators]:./generators.md

From e471804dcfcebd9fc00e06c07a07228e38f96d27 Mon Sep 17 00:00:00 2001
From: DorukUlucay <doruk.ulucay@cronom.com>
Date: Sat, 11 Feb 2017 00:24:09 +0200
Subject: [PATCH 39/74] fix errors from review of pr #38

---
 docs/promise.md | 64 ++++++++++++++++++++++++-------------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/docs/promise.md b/docs/promise.md
index 70da2b614..d3336a610 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -1,10 +1,10 @@
 ## Promise
 
-Promise, pek çok modern Javascript motorunda bulunan ve rahatlıkla polyfill edilebilen bir sınıftır. Promise'lerin öncelikli amacı Async/Callback tarzı yazılmış koda senkronize stilde hata yakalama fonksiyonunu kazandırmaktır.
+Promise, pek çok modern Javascript motorunda bulunan ve rahatlıkla polyfill edilebilen bir sınıftır. Promise'lerin öncelikli amacı Asenkron/Callback tarzı yazılmış koda senkronize stilde hata yakalama fonksiyonunu kazandırmaktır.
 
 ### Callback tarzı kod
 
-Promise'in sağladığı kolaylıkları daha iyi anlamak için sadece Callback kullanarak Async çalışan bir örnek görelim. Bir JSON dosyasından Async bir şekilde dosya okuma örneğini değerlendirelim. Sync bir versiyonu oldukça kolay olacaktır:
+Promise'in sağladığı kolaylıkları daha iyi anlamak için sadece Callback kullanarak asenkron çalışan bir örnek görelim. Bir JSON dosyasından asenkron bir şekilde dosya okuma örneğini değerlendirelim. Bunun senkronize bir versiyonu oldukça kolay olacaktır:
 
 ```ts
 import fs = require('fs');
@@ -16,7 +16,7 @@ function loadJSONSync(filename: string) {
 // geçerli json dosyası
 console.log(loadJSONSync('good.json'));
 
-// var olmayan json dosyası. bu yüzden fs.readFilesync hata verir
+// var olmayan json dosyası. Bu yüzden fs.readFilesync hata verir
 try {
     console.log(loadJSONSync('absent.json'));
 }
@@ -24,7 +24,7 @@ catch (err) {
     console.log('absent.json error', err.message);
 }
 
-// geçersiz json dosyası. dosya var ama içindeki JSON geçersiz. bu yüzden JSON.parse hata verir
+// geçersiz json dosyası. Dosya var ama içindeki JSON geçersiz. Bu yüzden JSON.parse hata verir.
 try {
     console.log(loadJSONSync('invalid.json'));
 }
@@ -33,7 +33,7 @@ catch (err) {
 }
 ```
 
-Bu basit `loadJSONSync` fonksiyonunun üç davranışı vardır. Geçerli bir dönüş değeri, bir dosya sistemi hatası ya da JSON.parse hatası. Bu hataları diğer Sync çalışan dillerde yaptığımız gibi basit try/catch bloğu ile yakalıyoruz. Şimdi bu fonksiyonun düzgün çalışan bir Async versiyonunu yapalım. Düzgün bir ilk deneme (küçük bir hata yakalama mekanizması ile) aşağıdaki şekilde olacaktır.
+Bu basit `loadJSONSync` fonksiyonunun üç davranışı vardır. Geçerli bir dönüş değeri, bir dosya sistemi hatası ya da JSON.parse hatası. Bu hataları diğer senkronize çalışan dillerde yaptığımız gibi basit try/catch bloğu ile yakalıyoruz. Şimdi bu fonksiyonun düzgün çalışan bir asenkron versiyonunu yapalım. Düzgün bir ilk deneme (küçük bir hata yakalama mekanizması ile) aşağıdaki şekilde olacaktır.
 
 ```ts
 import fs = require('fs');
@@ -47,12 +47,12 @@ function loadJSON(filename: string, cb: (error: Error, data: any) => void) {
 }
 ```
 
-Yeteri kadar basit, bir callback alır, bulduğu dosya sistemi hatalarını callback'e iletir. Eğer dosya sistemi hatası yok ise JSON.parse işleminin sonucunu döndürür. Callback'lere dayalı Async fonksiyonlarla çalışılırken unutulmaması gereken noktalar:
+Yeteri kadar basit, bir callback alır, bulduğu dosya sistemi hatalarını callback'e iletir. Eğer dosya sistemi hatası yok ise JSON.parse işleminin sonucunu döndürür. Callback'lere dayalı asenkron fonksiyonlarla çalışılırken unutulmaması gereken noktalar:
 
 1. Bir callback'i asla iki defa çağırmamak
 2. Asla hata fırlatmamak
 
-Bu basit fonksiyon 2. noktada problem yaşıyor. Aslında eğer geçersiz JSON verilir ise, JSON.parse hata verir, callback hiçbir zaman çağırılmaz ve uygulama çöker. Bu durum aşağıdaki örnekte gösterilmiştir.
+Bu basit fonksiyon 2. noktada problem yaşıyor. Aslında eğer geçersiz JSON verilir ise, JSON.parse hata verir, callback hiçbir zaman çağrılmaz ve uygulama çöker. Bu durum aşağıdaki örnekte gösterilmiştir.
 
 ```ts
 import fs = require('fs');
@@ -102,7 +102,7 @@ loadJSON('invalid.json', function (err, data) {
 });
 ```
 
-Yine de bu kodda yakalaması zor bir hata var. Eğer `JSON.parse` değil de callback(`cb`) hata fırlatırsa, biz bunu `try`/`catch` ile sarmaladığımız için `catch` çalışır ve callback'i bir daha çağırırız. Bu örnekte callback iki defa çağırılır! Bu, aşağıdaki örnekte gösterilmiştir:
+Yine de bu kodda yakalaması zor bir hata var. Eğer `JSON.parse` değil de callback(`cb`) hata fırlatırsa, biz bunu `try`/`catch` ile sarmaladığımız için `catch` çalışır ve callback'i bir daha çağrırız. Bu örnekte callback iki defa çağrılır! Bu, aşağıdaki örnekte gösterilmiştir:
 
 ```ts
 import fs = require('fs');
@@ -123,9 +123,9 @@ function loadJSON(filename: string, cb: (error: Error) => void) {
     });
 }
 
-// düzgün bir dosya ama hatalı bir callback... tekrar çağırılıyor
+// düzgün bir dosya ama hatalı bir callback... tekrar çağrılıyor
 loadJSON('good.json', function (err, data) {
-    console.log('callback çağırıldı');
+    console.log('callback çağrıldı');
 
     if (err) console.log('Error:', err.message);
     else {
@@ -139,8 +139,8 @@ loadJSON('good.json', function (err, data) {
 
 ```bash(konsol)
 $ node asyncbadcatchdemo.js
-callback çağırıldı
-callback çağırıldı
+callback çağrıldı
+callback çağrıldı
 Error: Cannot read property 'bar' of undefined
 ```
 
@@ -194,10 +194,10 @@ const promise = new Promise((resolve, reject) => {
     resolve(123);
 });
 promise.then((res) => {
-    console.log('I get called:', res === 123); // Ben çağırıldım. Sonuç: true
+    console.log('I get called:', res === 123); // Ben çağrıldım. Sonuç: true
 });
 promise.catch((err) => {
-    // Burası hiç çağırılmadı
+    // Burası hiç çağrılmadı
 });
 ```
 
@@ -206,10 +206,10 @@ const promise = new Promise((resolve, reject) => {
     reject(new Error("Çok kötü bir şey oldu."));
 });
 promise.then((res) => {
-    // Burası hiç çağırılmadı
+    // Burası hiç çağrılmadı
 });
 promise.catch((err) => {
-    console.log('Çağırıldım :', err.message); // Çağırıldım : "Çok kötü bir şey oldu"
+    console.log('çağrıldım :', err.message); // çağrıldım : "Çok kötü bir şey oldu"
 });
 ```
 
@@ -220,7 +220,7 @@ promise.catch((err) => {
 ### Promise'lerin zincirlenebilmesi
 Promise'lerin zincirlenebilir olması **en önemli özelliğidir**. Bir Promise'iniz olduğunda, `then` fonksiyonunu kullanarak promise zinciri yaratabilirsiniz.
 
-* Zincirdeki herhangi bir fonksiyondan bir promise döndürürseniz, `.then` sadece fonksiyon çözümlendiğinde çağırılır.
+* Zincirdeki herhangi bir fonksiyondan bir promise döndürürseniz, `.then` sadece fonksiyon çözümlendiğinde çağrılır.
 
 ```ts
 Promise.resolve(123)
@@ -233,7 +233,7 @@ Promise.resolve(123)
         return Promise.resolve(123); // Bir promise döndürüyor olduğumuza dikkat edin
     })
     .then((res) => {
-        console.log(res); // Bu `then`'in çözümlenmiş değer ile çağırıldığına dikkat edin.   
+        console.log(res); // Bu `then`'in çözümlenmiş değer ile çağrıldığına dikkat edin.   
         return 123;
     })
 ```
@@ -244,15 +244,15 @@ Promise.resolve(123)
 // Reddedilen bir promise yaratın
 Promise.reject(new Error('kötü bir şey oldu'))
     .then((res) => {
-        console.log(res); // çağırılmadı
+        console.log(res); // çağrılmadı
         return 456;
     })
     .then((res) => {
-        console.log(res); // çağırılmadı
+        console.log(res); // çağrılmadı
         return 123;
     })
     .then((res) => {
-        console.log(res); // çağırılmadı
+        console.log(res); // çağrılmadı
         return 123;
     })
     .catch((err) => {
@@ -266,7 +266,7 @@ Promise.reject(new Error('kötü bir şey oldu'))
 // Reddedilecek bir promise yaratalım
 Promise.reject(new Error('kötü bir şey oldu'))
     .then((res) => {
-        console.log(res); // çağırılmadı
+        console.log(res); // çağrılmadı
         return 456;
     })
     .catch((err) => {
@@ -287,7 +287,7 @@ Promise.resolve(123)
         return 456;
     })
     .then((res) => {
-        console.log(res); // hiç çağırılmadı
+        console.log(res); // hiç çağrılmadı
         return Promise.resolve(789);
     })
     .catch((err) => {
@@ -342,7 +342,7 @@ Promise.resolve(123)
 
 ### Callback tarzı yazılmış bir fonksiyonu Promise döndüren bir fonksiyona çevirmek
 
-Fonksiyon çağırımını bir promise ile sarmalayın ve
+Fonksiyon çağrımını bir promise ile sarmalayın ve
 - herhangi bir hata olursa `reject`,
 - olmazsa `resolve` döndürün.
 
@@ -363,7 +363,7 @@ function readFileAsync(filename:string):Promise<any> {
 
 ### JSON örneğine geri dönüş
 
-Şimdi `loadJSON` örneğimize geri dönelim ve promise'leri kullanan async bir versiyonunu yazalım. Yapmamız gereken tek şey dosya içeriğini bir promise olarak okumak ve okuma bittiğinde JSON olarak parse etmek. Bu, aşağıdaki örnekte gösterilmiştir:
+Şimdi `loadJSON` örneğimize geri dönelim ve promise'leri kullanan asenkron bir versiyonunu yazalım. Yapmamız gereken tek şey dosya içeriğini bir promise olarak okumak ve okuma bittiğinde JSON olarak parse etmek. Bu, aşağıdaki örnekte gösterilmiştir:
 
 ```ts
 function loadJSONAsync(filename: string): Promise<any> {
@@ -374,20 +374,20 @@ function loadJSONAsync(filename: string): Promise<any> {
 }
 ```
 
-Kullanım (bu bölümün başında yapmış olduğumuz `sync` versiyona ne kadar benzediğine dikkat edin 🌹):
+Kullanım (bu bölümün başında yapmış olduğumuz `senkronize` versiyona ne kadar benzediğine dikkat edin 🌹):
 ```ts
 // geçerli json dosyası
 loadJSONAsync('good.json')
     .then(function (val) { console.log(val); })
     .catch(function (err) {
-        console.log('good.json error', err.message); // hiç çağırılmadı
+        console.log('good.json error', err.message); // hiç çağrılmadı
     })
 
 // var olmayan json dosyası
     .then(function () {
         return loadJSONAsync('absent.json');
     })
-    .then(function (val) { console.log(val); }) // hiç çağırılmadı
+    .then(function (val) { console.log(val); }) // hiç çağrılmadı
     .catch(function (err) {
         console.log('absent.json error', err.message);
     })
@@ -396,21 +396,21 @@ loadJSONAsync('good.json')
     .then(function () {
         return loadJSONAsync('invalid.json');
     })
-    .then(function (val) { console.log(val); }) // hiç çağırılmadı
+    .then(function (val) { console.log(val); }) // hiç çağrılmadı
     .catch(function (err) {
         console.log('bad.json error', err.message);
     });
 ```
 
-Bu fonksiyonun daha basit olmasının sebebi "`loadFile`(async) + `JSON.parse` (sync) => `catch`" kısmının promise zinciri tarafından üstlenmilmiş olmasıdır. Ayrıca callback *bizim tarafımızdan değil*, promise zinciri tarafından çağırıldığı için `try/catch` bloğu ile sarmalama hatasına düşmemiş olduk.
+Bu fonksiyonun daha basit olmasının sebebi "`loadFile`(async) + `JSON.parse` (sync) => `catch`" kısmının promise zinciri tarafından üstlenmilmiş olmasıdır. Ayrıca callback *bizim tarafımızdan değil*, promise zinciri tarafından çağrıldığı için `try/catch` bloğu ile sarmalama hatasına düşmemiş olduk.
 
 ### Paralel akış kontrolü
-Promise kullanarak asenkron işler yapmanın ne kadar kolay olduğunu gördük. Aslında bu sadece `then` çağırımlarını birbirine bağlamaktan ibaretti.
+Promise kullanarak asenkron işler yapmanın ne kadar kolay olduğunu gördük. Aslında bu sadece `then` çağrımlarını birbirine bağlamaktan ibaretti.
 
 Yine de birden fazla asenkron işi gerçekleştirip aldığınız sonuçla başka bir iş yapmak isteyebilirsiniz. `Promise`, vermiş olduğunuz `n` sayıdaki promise'in tamamlanmasını bekleyip, toplam sonucu döndüren statik bir `Promise.all` fonksiyonuna sahiptir. Bu fonksiyona `n` sayıda promise içeren bir dizi verirsiniz ve bu fonksiyon da size `n` sayıda çözümlenmiş sonuç döndürür. Aşağıda paralel'in yanı sıra zincirlemeyi de gösteriyoruz:
 
 ```ts
-// bir sunucudan, bir nesnenin yüklenmesini simüle eden asenkton bir fonksiyon
+// bir sunucudan, bir nesnenin yüklenmesini simüle eden asenkron bir fonksiyon
 function loadItem(id: number): Promise<{id: number}> {
     return new Promise((resolve)=>{
         console.log('loading item', id);

From d4b134a6c8a758c635896bc12da0b6e143ca3bbc Mon Sep 17 00:00:00 2001
From: Ozgun Bal <ozgunbal@gmail.com>
Date: Fri, 3 Feb 2017 12:13:16 +0300
Subject: [PATCH 40/74] =?UTF-8?q?#5=20Ok=20fonksiyonlar=C4=B1=20=C3=A7evir?=
 =?UTF-8?q?isi=20tamamland=C4=B1=20Terimler=20s=C3=B6zl=C3=BC=C4=9F=C3=BC?=
 =?UTF-8?q?=20g=C3=BCncellendi?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 GLOSSARY.md             |  4 ++-
 docs/arrow-functions.md | 68 ++++++++++++++++++++---------------------
 2 files changed, 37 insertions(+), 35 deletions(-)

diff --git a/GLOSSARY.md b/GLOSSARY.md
index 475f7b080..af4f169e5 100644
--- a/GLOSSARY.md
+++ b/GLOSSARY.md
@@ -14,12 +14,14 @@ Fakat bazı terimlerin Türkçe çevrimi, cümleyi anlamsız bir hale getirebilm
 | İngilizce        | Türkçe           |
 | ------------------------------------- |---------------------------------------|
 | Hello world!     | Merhaba dünya! |
-| Issue | Görev|
+| Issue | Görev |
 | Contributor | Katkıda bulunan kişi |
 | Object | Nesne |
 | Event | Olay |
 | String | Karakter dizimi |
 | Escape character (`\`) | Kaçış karakteri |
+| Inheritance | Kalıtım |
+| Callback | Geri çağırım |
 
 # Terim açıklamaları
 * Duck Typing: Eğer bir ördek gibi yürüyor ve bir ördek gibi "vak"lıyorsa, o zaman bu bir ördektir. Bir nesne yapısal olarak tüm üyelere sahipse, diğer şeylerin de (ne olduğu önemli değil) var olduğu kabul edilir.
diff --git a/docs/arrow-functions.md b/docs/arrow-functions.md
index c63706f78..28c5fa3e3 100644
--- a/docs/arrow-functions.md
+++ b/docs/arrow-functions.md
@@ -1,21 +1,21 @@
-* [Arrow Functions](#arrow-functions)
-* [Tip: Arrow Function Need](#tip-arrow-function-need)
-* [Tip: Arrow Function Danger](#tip-arrow-function-danger)
-* [Tip: Libraries that use `this`](#tip-arrow-functions-with-libraries-that-use-this)
-* [Tip: Arrow Function inheritance](#tip-arrow-functions-and-inheritance)
+* [Ok Fonksiyonları](#arrow-functions)
+* [Tüyo: Ok Fonksiyonu Gereksinimi](#tip-arrow-function-need)
+* [Tüyo: Tehlikeli Ok Fonksiyonu Kullanımı](#tip-arrow-function-danger)
+* [Tüyo: `this` kullanan kütüphaneler](#tip-arrow-functions-with-libraries-that-use-this)
+* [Tüyo: Arrow Function Kalıtımı](#tip-arrow-functions-and-inheritance)
 
-### Arrow Functions
+### Ok Fonksiyonları
 
-Lovingly called the *fat arrow* (because `->` is a thin arrow and `=>` is a fat arrow) and also called a *lambda function* (because of other languages). Another commonly used feature is the fat arrow function `()=>something`. The motivation for a *fat arrow* is:
-1. You don't need to keep typing `function`
-2. It lexically captures the meaning of `this`
-2. It lexically captures the meaning of `arguments`
+*Kalın ok* (çünkü `->` ince ok, `=>` ise kalın oktur) veya *lambda fonksiyonu* (diğer dillerde geçtiği şekliyle) olarak isimlendirilir. `()=>something`, kalın ok fonksiyonunun çokça kullanılan bir özelliğidir. Kalın ok fonksiyonunun kullanılmasının nedenleri:
+1. `function` yazmanıza gerek olmaz.
+2. Anlam olarak `this` sözcüğünü içerir.
+3. Anlam olarak `arguments` sözcüğünü içerir.
 
-For a language that claims to be functional, in JavaScript you tend to be typing `function` quite a lot. The fat arrow makes it simple for you to create a function
+İşlevsel (fonksiyonel) olduğunu iddia eden bir dil olarak JavaScript'te fazlasıyla `function` yazma eğiliminde olursunuz. Kalın ok size kolay bir şekilde fonksiyon yaratmanızı sağlar.
 ```ts
 var inc = (x)=>x+1;
 ```
-`this` has traditionally been a pain point in JavaScript. As a wise man once said "I hate JavaScript as it tends to lose the meaning of `this` all too easily". Fat arrows fix it by capturing the meaning of `this` from the surrounding context. Consider this pure JavaScript class:
+`this` geleneksek olarak Javascript'te sıkıntılı bir konudur. Bilge bir adam der ki, "`this`, çok kolay bir biçimde anlamını yitirdiği için Javascript'ten nefret ettim." Kalın ok bu durumu `this`'in anlamını etrafındaki içerikle yansıtarak düzeltti. Şu saf Javascript sınıfına bakarsak:
 
 ```ts
 function Person(age) {
@@ -27,9 +27,9 @@ function Person(age) {
 var person = new Person(1);
 setTimeout(person.growOld,1000);
 
-setTimeout(function() { console.log(person.age); },2000); // 1, should have been 2
+setTimeout(function() { console.log(person.age); },2000); // 1, ama 2 olmalıydı
 ```
-If you run this code in the browser `this` within the function is going to point to `window` because `window` is going to be what executes the `growOld` function. Fix is to use an arrow function:
+Eğer bu kodu tarayıcıda koşturursanız, fonksiyon içindeki `this`, `window`'u işaret eder çünkü `growOld` fonksiyonunu `window` çalıştıracaktır. Bunu düzeltmek için ok fonksiyonu kullanın:
 ```ts
 function Person(age) {
     this.age = age;
@@ -42,13 +42,13 @@ setTimeout(person.growOld,1000);
 
 setTimeout(function() { console.log(person.age); },2000); // 2
 ```
-The reason why this works is the reference to `this` is captured by the arrow function from outside the function body. This is equivalent to the following JavaScript code (which is what you would write yourself if you didn't have TypeScript):
+Bunun işe yaramasının sebebi, ok fonksiyonunun `this` referansını fonksiyon gövdesinin dışından almasıdır. Buna eşdeğer Javascript kodu (TypeScript kullanmadan da yazabilirsiniz) ise aşağıdaki gibidir:
 ```ts
 function Person(age) {
     this.age = age;
-    var _this = this;  // capture this
+    var _this = this;  // this'i referans alır
     this.growOld = function() {
-        _this.age++;   // use the captured this
+        _this.age++;   // referans alınan this kullanılır
     }
 }
 var person = new Person(1);
@@ -56,7 +56,7 @@ setTimeout(person.growOld,1000);
 
 setTimeout(function() { console.log(person.age); },2000); // 2
 ```
-Note that since you are using TypeScript you can be even sweeter in syntax and combine arrows with classes:
+Ayrıca artık TypeScript kullandığınız için, daha güzel bir sözdizimi ile ok fonksiyonlarını sınıflar ile kullanabilirsiniz: 
 ```ts
 class Person {
     constructor(public age:number) {}
@@ -70,51 +70,51 @@ setTimeout(person.growOld,1000);
 setTimeout(function() { console.log(person.age); },2000); // 2
 ```
 
-#### Tip: Arrow Function Need
-Beyond the terse syntax, you only *need* to use the fat arrow if you are going to give the function to someone else to call. Effectively:
+#### Tüyo: Ok Fonksiyonu Gereksinimi
+Kısa ve öz sözdiziminin dışında, sadece fonksiyonunuz başkası tarafından çağrılacaksa, kalın ok kullanmanız *gereklidir*. Örneğin:
 ```ts
 var growOld = person.growOld;
-// Then later someone else calls it:
+// Ve sonra başkası çağırdığında:
 growOld();
 ```
-If you are going to call it yourself, i.e.
+Eğer fonksiyonu kendiniz çağıracaksanız, örneğin;
 ```ts
 person.growOld();
 ```
-then `this` is going to be the correct calling context (in this example `person`).
+İşte o zaman `this` doğru bir içeriği çağırmış olur (`person` örneğindeki gibi).
 
-#### Tip: Arrow Function Danger
+#### Tüyo: Tehlikeli Ok Fonksiyonu Kullanımı
 
-In fact if you want `this` *to be the calling context* you should *not use the arrow function*. This is the case with callbacks used by libraries like jquery, underscore, mocha and others. If the documentation mentions functions on `this` then you should probably just use a `function` instead of a fat arrow. Similarly if you plan to use `arguments` don't use an arrow function.
+Aslında `this`'i *ilgili içeriği çağırmak için* istiyorsanız, *ok fonksiyonu kullanmamalısınız*. jquery, underscore, mocha gibi geri çağırımlar (callback) kullanan kütüphaneler bu duruma örnektir. Eğer dökümanında fonksiyonlarda `this` kullanımından bahsediyorsa, o zaman kalın ok yerine muhtemelen `function` kullanmanız gerekiyor. Aynı şekilde eğer `arguments` kullanmayı düşünüyorsanız da, kalın ok fonksiyonu kullanmamalısınız.
 
-#### Tip: Arrow functions with libraries that use `this`
-Many libraries do this e.g. `jQuery` iterables (one example http://api.jquery.com/jquery.each/) will use `this` to pass you the object that it is currently iterating over. In this case if you want to access the library passed `this` as well as the surrounding context just use a temp variable like `_self` like you would in the absence of arrow functions.
+#### Tüyo: Ok fonksiyonları ve `this` kullanan kütüphaneler
+Birçok kütüphane bunu yapmaktadır. Örneğin, `jQuery` yineleyicileri (iterable) (bir örneği http://api.jquery.com/jquery.each/) o an yinelenmekte olan nesneye `this`'i iletecektir. Bu durumda, `this`'i ve çevreleyen içeriğini ileten bir kütüphaneye erişmek istiyorsanız, benzeri bir geçici değişken kullanın: 
 
 ```ts
 let _self = this;
 something.each(function() {
-    console.log(_self); // the lexically scoped value
-    console.log(this); // the library passed value
+    console.log(_self); // sözcük anlamı olarak kapsamın değeri
+    console.log(this); // kütüphanenin ilettiği değer
 });
 ```
 
-#### Tip: Arrow functions and inheritance
+#### Tip: Ok fonksiyonları ve kalıtım
 
-If you have an instance method as an arrow function then it goes on `this`. Since there is only one `this` such functions cannot participate in a call to `super` (`super` only works on prototype members). You can easily get around it by creating a copy of the method before overriding it in the child.
+Ok fonksiyonu ile yazılıp `this` ile devam eden, bir sınıfa ait bir metodunuz var. Sadece tek bir `this` olduğundan,  bu tip fonksiyonlar `super`'i (`super` sadece prototip üyelerinde çalışır) çağıramazlar. Alt sınıf metodun üzerinden geçmeden önce, metodun kopyasını yaratarak bunun üstesinden gelebilirsiniz.
 
 ```ts
 class Adder {
     constructor(public a: number) {}
-    // This function is now safe to pass around
+    // Bu fonksiyon şu an çağrılabilmeye uygun
     add = (b: string): string => {
         return this.a + b;
     }
 }
 
 class ExtendedAdder extends Adder {
-    // Create a copy of parent before creating our own
+    // Kendi metodundan önce üst sınıfınkinin bir kopyasını yarat
     private superAdd = this.add;
-    // Now create our override
+    // Şimdi onun üzerinden geçen kendi metodunu yarat
     add = (b: string): string => {
         return this.superAdd(b);
     }

From 4c452048b63cb68150d952ddaac593c92d7f280c Mon Sep 17 00:00:00 2001
From: Ozgun Bal <ozgunbal@gmail.com>
Date: Mon, 6 Feb 2017 16:17:42 +0300
Subject: [PATCH 41/74] =?UTF-8?q?Ok=20fonksiyonlar=C4=B1=20=C3=A7evirisini?=
 =?UTF-8?q?=20yorumlardan=20sonra=20d=C3=BCzelttim?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/arrow-functions.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/arrow-functions.md b/docs/arrow-functions.md
index 28c5fa3e3..1aa3ba376 100644
--- a/docs/arrow-functions.md
+++ b/docs/arrow-functions.md
@@ -1,12 +1,12 @@
 * [Ok Fonksiyonları](#arrow-functions)
-* [Tüyo: Ok Fonksiyonu Gereksinimi](#tip-arrow-function-need)
-* [Tüyo: Tehlikeli Ok Fonksiyonu Kullanımı](#tip-arrow-function-danger)
-* [Tüyo: `this` kullanan kütüphaneler](#tip-arrow-functions-with-libraries-that-use-this)
-* [Tüyo: Arrow Function Kalıtımı](#tip-arrow-functions-and-inheritance)
+* [İpucu: Ok Fonksiyonu Gereksinimi](#tip-arrow-function-need)
+* [İpucu: Tehlikeli Ok Fonksiyonu Kullanımı](#tip-arrow-function-danger)
+* [İpucu: `this` kullanan kütüphaneler](#tip-arrow-functions-with-libraries-that-use-this)
+* [İpucu: Arrow Function Kalıtımı](#tip-arrow-functions-and-inheritance)
 
 ### Ok Fonksiyonları
 
-*Kalın ok* (çünkü `->` ince ok, `=>` ise kalın oktur) veya *lambda fonksiyonu* (diğer dillerde geçtiği şekliyle) olarak isimlendirilir. `()=>something`, kalın ok fonksiyonunun çokça kullanılan bir özelliğidir. Kalın ok fonksiyonunun kullanılmasının nedenleri:
+*Kalın ok* (çünkü `->` ince ok (thin arrow), `=>` ise kalın oktur (fat arrow)) veya *lambda fonksiyonu* (diğer dillerde geçtiği şekliyle) olarak isimlendirilir. `()=>something`, kalın ok fonksiyonunun çokça kullanılan bir özelliğidir. Kalın ok fonksiyonunun kullanılmasının nedenleri:
 1. `function` yazmanıza gerek olmaz.
 2. Anlam olarak `this` sözcüğünü içerir.
 3. Anlam olarak `arguments` sözcüğünü içerir.
@@ -15,7 +15,7 @@
 ```ts
 var inc = (x)=>x+1;
 ```
-`this` geleneksek olarak Javascript'te sıkıntılı bir konudur. Bilge bir adam der ki, "`this`, çok kolay bir biçimde anlamını yitirdiği için Javascript'ten nefret ettim." Kalın ok bu durumu `this`'in anlamını etrafındaki içerikle yansıtarak düzeltti. Şu saf Javascript sınıfına bakarsak:
+`this` genel olarak Javascript'te sıkıntılı bir konudur. Bilge bir adam der ki, "`this`, çok kolay bir biçimde anlamını yitirdiği için Javascript'ten nefret ettim." Kalın ok bu durumu `this`'in anlamını etrafındaki içerikle yansıtarak düzeltti. Şu saf Javascript sınıfına bakarsak:
 
 ```ts
 function Person(age) {
@@ -29,7 +29,7 @@ setTimeout(person.growOld,1000);
 
 setTimeout(function() { console.log(person.age); },2000); // 1, ama 2 olmalıydı
 ```
-Eğer bu kodu tarayıcıda koşturursanız, fonksiyon içindeki `this`, `window`'u işaret eder çünkü `growOld` fonksiyonunu `window` çalıştıracaktır. Bunu düzeltmek için ok fonksiyonu kullanın:
+Eğer bu kodu tarayıcıda çalıştırırsanız, fonksiyon içindeki `this`, `window`'u işaret eder çünkü `growOld` fonksiyonunu `window` yürütecektir. Bunu düzeltmek için ok fonksiyonu kullanın:
 ```ts
 function Person(age) {
     this.age = age;
@@ -70,7 +70,7 @@ setTimeout(person.growOld,1000);
 setTimeout(function() { console.log(person.age); },2000); // 2
 ```
 
-#### Tüyo: Ok Fonksiyonu Gereksinimi
+#### İpucu: Ok Fonksiyonu Gereksinimi
 Kısa ve öz sözdiziminin dışında, sadece fonksiyonunuz başkası tarafından çağrılacaksa, kalın ok kullanmanız *gereklidir*. Örneğin:
 ```ts
 var growOld = person.growOld;
@@ -83,11 +83,11 @@ person.growOld();
 ```
 İşte o zaman `this` doğru bir içeriği çağırmış olur (`person` örneğindeki gibi).
 
-#### Tüyo: Tehlikeli Ok Fonksiyonu Kullanımı
+#### İpucu: Tehlikeli Ok Fonksiyonu Kullanımı
 
 Aslında `this`'i *ilgili içeriği çağırmak için* istiyorsanız, *ok fonksiyonu kullanmamalısınız*. jquery, underscore, mocha gibi geri çağırımlar (callback) kullanan kütüphaneler bu duruma örnektir. Eğer dökümanında fonksiyonlarda `this` kullanımından bahsediyorsa, o zaman kalın ok yerine muhtemelen `function` kullanmanız gerekiyor. Aynı şekilde eğer `arguments` kullanmayı düşünüyorsanız da, kalın ok fonksiyonu kullanmamalısınız.
 
-#### Tüyo: Ok fonksiyonları ve `this` kullanan kütüphaneler
+#### İpucu: Ok fonksiyonları ve `this` kullanan kütüphaneler
 Birçok kütüphane bunu yapmaktadır. Örneğin, `jQuery` yineleyicileri (iterable) (bir örneği http://api.jquery.com/jquery.each/) o an yinelenmekte olan nesneye `this`'i iletecektir. Bu durumda, `this`'i ve çevreleyen içeriğini ileten bir kütüphaneye erişmek istiyorsanız, benzeri bir geçici değişken kullanın: 
 
 ```ts
@@ -98,7 +98,7 @@ something.each(function() {
 });
 ```
 
-#### Tip: Ok fonksiyonları ve kalıtım
+#### İpucu: Ok fonksiyonları ve kalıtım
 
 Ok fonksiyonu ile yazılıp `this` ile devam eden, bir sınıfa ait bir metodunuz var. Sadece tek bir `this` olduğundan,  bu tip fonksiyonlar `super`'i (`super` sadece prototip üyelerinde çalışır) çağıramazlar. Alt sınıf metodun üzerinden geçmeden önce, metodun kopyasını yaratarak bunun üstesinden gelebilirsiniz.
 

From 63c8334d8629fd452e0783c41921cf7c4c3defcb Mon Sep 17 00:00:00 2001
From: Ozgun Bal <ozgunbal@gmail.com>
Date: Mon, 13 Feb 2017 11:43:36 +0300
Subject: [PATCH 42/74] =?UTF-8?q?#5=20Ok=20fonksiyonlar=C4=B1=20=C3=A7evir?=
 =?UTF-8?q?isi,=20yorumlar=20sonras=C4=B1=20ekleme?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/arrow-functions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/arrow-functions.md b/docs/arrow-functions.md
index 1aa3ba376..2862a349c 100644
--- a/docs/arrow-functions.md
+++ b/docs/arrow-functions.md
@@ -100,7 +100,7 @@ something.each(function() {
 
 #### İpucu: Ok fonksiyonları ve kalıtım
 
-Ok fonksiyonu ile yazılıp `this` ile devam eden, bir sınıfa ait bir metodunuz var. Sadece tek bir `this` olduğundan,  bu tip fonksiyonlar `super`'i (`super` sadece prototip üyelerinde çalışır) çağıramazlar. Alt sınıf metodun üzerinden geçmeden önce, metodun kopyasını yaratarak bunun üstesinden gelebilirsiniz.
+Diyelim ki ok fonksiyonu ile yazılıp `this` ile devam eden, bir sınıfa ait bir metodunuz var. Sadece tek bir `this` olduğundan,  bu tip fonksiyonlar `super`'i (`super` sadece prototip üyelerinde çalışır) çağıramazlar. Alt sınıf metodun üzerinden geçmeden önce, metodun kopyasını yaratarak bunun üstesinden gelebilirsiniz.
 
 ```ts
 class Adder {

From 7ee3e9794c048eadb63e8effeda6785c2b78b675 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Atar?= <ugur.atar@metry.io>
Date: Mon, 13 Feb 2017 18:59:20 +0100
Subject: [PATCH 43/74] Update arrow-functions.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Ok fonksiyonları dökümanında, sayfa içi linklerin düzenlenmesi.
---
 docs/arrow-functions.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/arrow-functions.md b/docs/arrow-functions.md
index 2862a349c..3927869b0 100644
--- a/docs/arrow-functions.md
+++ b/docs/arrow-functions.md
@@ -1,8 +1,8 @@
-* [Ok Fonksiyonları](#arrow-functions)
-* [İpucu: Ok Fonksiyonu Gereksinimi](#tip-arrow-function-need)
-* [İpucu: Tehlikeli Ok Fonksiyonu Kullanımı](#tip-arrow-function-danger)
-* [İpucu: `this` kullanan kütüphaneler](#tip-arrow-functions-with-libraries-that-use-this)
-* [İpucu: Arrow Function Kalıtımı](#tip-arrow-functions-and-inheritance)
+* [Ok Fonksiyonları](#ok-fonksiyonları)
+* [İpucu: Ok Fonksiyonu Gereksinimi](#İpucu-ok-fonksiyonu-gereksinimi)
+* [İpucu: Tehlikeli Ok Fonksiyonu Kullanımı](#İpucu-tehlikeli-ok-fonksiyonu-kullanımı)
+* [İpucu: `this` kullanan kütüphaneler](#İpucu-ok-fonksiyonları-ve-this-kullanan-kütüphaneler)
+* [İpucu: Arrow Function Kalıtımı](#İpucu-ok-fonksiyonları-ve-kalıtım)
 
 ### Ok Fonksiyonları
 

From d515e7659e47435b065eb608ce4e3834ad8509d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Atar?= <ugur.atar@metry.io>
Date: Mon, 13 Feb 2017 23:20:25 +0100
Subject: [PATCH 44/74] Update arrow-functions.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Ok fonksiyonları link metni düzeltme.
---
 docs/arrow-functions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/arrow-functions.md b/docs/arrow-functions.md
index 3927869b0..443f7fd00 100644
--- a/docs/arrow-functions.md
+++ b/docs/arrow-functions.md
@@ -2,7 +2,7 @@
 * [İpucu: Ok Fonksiyonu Gereksinimi](#İpucu-ok-fonksiyonu-gereksinimi)
 * [İpucu: Tehlikeli Ok Fonksiyonu Kullanımı](#İpucu-tehlikeli-ok-fonksiyonu-kullanımı)
 * [İpucu: `this` kullanan kütüphaneler](#İpucu-ok-fonksiyonları-ve-this-kullanan-kütüphaneler)
-* [İpucu: Arrow Function Kalıtımı](#İpucu-ok-fonksiyonları-ve-kalıtım)
+* [İpucu: Ok Fonksiyonu Kalıtımı](#İpucu-ok-fonksiyonları-ve-kalıtım)
 
 ### Ok Fonksiyonları
 

From c32f2fd8be449d12f8ff84a438e87bca51f32ede Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Tue, 14 Feb 2017 13:07:39 +0300
Subject: [PATCH 45/74] #4 Future JavaScript Now - Classes cevisi tamamlandi

---
 docs/classes-emit.md          | 58 ++++++++++++++++-----------------
 docs/classes-extensibility.md |  8 ++---
 docs/classes-super.md         | 21 ++++++------
 docs/classes.md               | 60 +++++++++++++++++------------------
 4 files changed, 74 insertions(+), 73 deletions(-)

diff --git a/docs/classes-emit.md b/docs/classes-emit.md
index df4a81eb2..6b39ac6d5 100644
--- a/docs/classes-emit.md
+++ b/docs/classes-emit.md
@@ -1,5 +1,5 @@
-#### What's up with the IIFE
-The js generated for the class could have been:
+#### IIFE Nedir Ne Değildir?
+Sınıf için üretilen js şöyle olabilirdi:
 ```ts
 function Point(x, y) {
     this.x = x;
@@ -10,7 +10,7 @@ Point.prototype.add = function (point) {
 };
 ```
 
-The reason its wrapped in an Immediately-Invoked Function Expression (IIFE) i.e.
+Sebebi  Anlık-Çağrılan Fonksiyon İfadesi (Immediately-Invoked Function Expression) (IIFE) ile sarmalanmıştır, yani:
 
 ```ts
 (function () {
@@ -21,7 +21,7 @@ The reason its wrapped in an Immediately-Invoked Function Expression (IIFE) i.e.
 })();
 ```
 
-has to do with inheritance. It allows TypeScript to capture the base class as a variable `_super` e.g.
+kalıtım ile yapar. TypeScript'in üst sınıfını `_super` değişkeni olarak yakalamasına olanak tanır örnegin :
 
 ```ts
 var Point3D = (function (_super) {
@@ -38,10 +38,10 @@ var Point3D = (function (_super) {
 })(Point);
 ```
 
-Notice that the IIFE allows TypeScript to easily capture the base class `Point` in a `_super` variable and that is used consistently in the class body.
+Dikkat edin IIFE, TypeScript'in kolayca üst sınıf `Point` içerisindeki `_super` değişkenini yakalamasına izin verir ve sınıfın ana bloğunda sürekli olarak kullanılır.
 
 ### `__extends`
-You will notice that as soon as you inherit a class TypeScript also generates the following function:
+Şunu farkedeceksiniz ki bir sınıftan kalıtım yaptığınız anda TypeScript ayrıca aşağıdaki fonksiyonu da oluşturur:
 ```ts
 var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
@@ -50,58 +50,58 @@ var __extends = this.__extends || function (d, b) {
     d.prototype = new __();
 };
 ```
-Here `d` refers to the derived class and `b` refers to the base class. This function does two things:
-1. copies the static members of the base class onto the child class i.e. `for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];`
-1. sets up the child class function's prototype to optionally lookup members on the parent's `proto` i.e. effectively `d.prototype.__proto__ = b.prototype`
+Burada `d` türetilmiş sınıfı ve `b` üst sınıfı ifade eder. Bu fonksiyon iki şey yapar:
+1. `for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];` yani üst sınıfının statik elemanlarını alt sınıfının üzerine kopyalar 
+1. `d.prototype.__proto__ = b.prototype` yani etkin biçimde, alt sınıfının fonksiyonlarının prototiplerini isteğe bağlı olarak arama elemanlarına üst sınıfının `proto`'ları üzerinde atama yapar
 
-People rarely have trouble understanding 1, but many people struggle with 2. So an explanation is in order.
+İnsanlar nadiren 1'i anlamakta zorlanırlar, ancak birçok kişi 2 ile mücadele verir. Bu yüzden sırası ile açıklamaları.
 
 #### `d.prototype.__proto__ = b.prototype`
 
-After having tutored many people about this I find the following explanation to be simplest. First we will explain how the code from `__extends` is equivalent to the simple `d.prototype.__proto__ = b.prototype`, and then why this line in itself is significant. To understand all this you need to know these things:
+Birçok insana bu konuyu anlattıktan sonra aşağıdaki açıklamayı en basit buluyorum. Öncelikle `__extends`'deki kodun nasıl basit `d.prototype.__proto__ = b.prototype`'a eşit olduğunu açıklayacağız, ve sonrasında kendi içindeki bu satırın neden değerli olduğunu. Bunu tamamen anlayabilmeniz için şunları bilmeniz gerekir:
 
 1. `__proto__`
 1. `prototype`
-1. effect of `new` on `this` inside the called function
-1. effect of `new` on `prototype` and `__proto__`
+1. çağrılan fonksiyon içerisinde `new`'ın `this` üzerindeki etkisi
+1. `new`'ın `prototype` ve `__proto__` üzerindeki etkisi
 
-All objects in JavaScript contain a `__proto__` member. This member is often not accessible in older browsers (sometimes documentation refers to this magical property as `[[prototype]]`). It has one objective: If a property is not found on an object during lookup (e.g. `obj.property`) then it is looked up at `obj.__proto__.property`. If it is still not found then `obj.__proto__.__proto__.property` till either: *it is found* or *the latest `.__proto__` itself is null*. This explains why JavaScript is said to support *prototypal inheritance* out of the box. This is shown in the following example, which you can run in the chrome console or nodejs:
+JavaScript'teki tüm nesneler `__proto__` elemanını içerir. Bu eleman eski tarayıcılar tarafından sıklıkla erişilemez durumdadır (bazen dökümantasyon bu sihirli özelliği `[[prototype]]` olarak ifade eder). Bunun tek bir görevi vardır: Eğer arama sırasında nesne üzerinde özellik bulunamazsa (örneğin `obj.property`) `obj.__proto__.property`'e bakacaktır. Eğer hala bulunamadıysa ozaman `obj.__proto__.__proto__.property`'a ta ki ikiside: *it is found* veya *the latest `.__proto__` itself is null* olana kadar. Bu JavaScript'in *prototipsel kalıtım(prototypal inheritance)* işlevselliğine neden destek dediğini açıklar. Bu aşağıdaki örnekte, chrome konsolunda veya nodejs'te çalıştırılacak şekilde gösterilmiştir:
 
 ```ts
 var foo = {}
 
-// setup on foo as well as foo.__proto__
+//  foo.__proto__'da olduğu gibi foo üzerinde hazırlanışı
 foo.bar = 123;
 foo.__proto__.bar = 456;
 
 console.log(foo.bar); // 123
-delete foo.bar; // remove from object
+delete foo.bar; // nesneden çıkar
 console.log(foo.bar); // 456
-delete foo.__proto__.bar; // remove from foo.__proto__
+delete foo.__proto__.bar; // foo.__proto__'dan çıkar
 console.log(foo.bar); // undefined
 ```
 
-Cool so you understand `__proto__`. Another useful information is that all `function`s in JavaScript have a property called `prototype` and that it has a member `constructor` pointing back to the function. This is shown below:
+`__proto__`'yu anlıyorsun harika. Başka bir yararlı bilgi ise, JavaScript içerisindeki tüm `fonksiyon`'lar `prototype` diye adlandırılan özelliğe sahiptir ve fonksiyonu geri işaret eden `constructor` elemanına sahiptir. Aşağıda gösterilmiştir:
 
 ```ts
 function Foo() { }
-console.log(Foo.prototype); // {} i.e. it exists and is not undefined
-console.log(Foo.prototype.constructor === Foo); // Has a member called `constructor` pointing back to the function
+console.log(Foo.prototype); // {} yani zaten var ve tanımlanmamış
+console.log(Foo.prototype.constructor === Foo); // `constructor` adında fonksiyonu geri işaret eden elemana sahip
 ```
 
-Now let's look at *effect of `new` on `this` inside the called function*. Basically `this` inside the called function is going to point to the newly created object that will be returned from the function. It's simple to see if you mutate a property on `this` inside the function:
+Şimdi hadi *çağrılan fonksiyon içerisinde `new`'ın `this` üzerindeki etkisi*'ne bakalım. Aslında çağrılan fonksiyon içerisindeki `this`, fonksiyondan geri dönecek yeni yaratılmış nesneyi işaret edecektir. Eğer fonksiyon içerisindeki `this` üzerinde özelliği değiştirirseniz bunu görmek çok basittir:
 
 ```ts
 function Foo() {
     this.bar = 123;
 }
 
-// call with the new operator
+// new operatörü ile çağrımı
 var newFoo = new Foo();
 console.log(newFoo.bar); // 123
 ```
 
-Now the only other thing you need to know is that calling `new` on a function copies the `prototype` of the function into the `__proto__` of the newly created object that is returned from the function call. Here is the code you can run to completely understand it:
+Şimdi öğrenmeniz gereken diğer son şey ise,fonksiyon üzerinde `new`'ı çağırmak, fonksiyon çağrısından dönen yeni yaratılmış nesnenin `__proto__`'su içindeki `prototype`'ı kopyalar. İşte çalıştırıp tamamen anlayabilmeniz için gereken kod bu:
 
 ```ts
 function Foo() { }
@@ -111,7 +111,7 @@ var foo = new Foo();
 console.log(foo.__proto__ === Foo.prototype); // True!
 ```
 
-That's it. Now look at the following straight out of `__extends`. I've taken the liberty to number these lines:
+İşte bu. Şimdi `__extends`'e göz atın. Bu satırları numaralandırma özgürlüğünü kendimde buldum:
 
 ```ts
 1  function __() { this.constructor = d; }
@@ -119,13 +119,13 @@ That's it. Now look at the following straight out of `__extends`. I've taken the
 3   d.prototype = new __();
 ```
 
-Reading this function in reverse the `d.prototype = new __()` on line 3 effectively means `d.prototype = {__proto__ : __.prototype}` (because of the effect of `new` on `prototype` and `__proto__`), combining it with the previous line (i.e. line 2 `__.prototype = b.prototype;`) you get `d.prototype = {__proto__ : b.prototype}`.
+Bu fonksiyonu satır 3 üzerindeki `d.prototype = new __()` tersten okumanın etkili anlamı `d.prototype = {__proto__ : __.prototype}` (`new`'ın `prototype` ve `__proto__` üzerindeki etkisi yüzünden), önceki satırdaki (yani satır 2 `__.prototype = b.prototype;`) ile birleştirme sonucunda `d.prototype = {__proto__ : b.prototype}` alırsınız.
 
-But wait, we wanted `d.prototype.__proto__` i.e. just the proto changed and maintain the old `d.prototype.constructor`. This is where the significance of the first line (i.e. `function __() { this.constructor = d; }`) comes in. Here we will effectively have `d.prototype = {__proto__ : __.prototype, d.constructor = d}` (because of the effect of `new` on `this` inside the called function). So, since we restore `d.prototype.constructor`, the only thing we have truly mutated is the `__proto__` hence `d.prototype.__proto__ = b.prototype`.
+Ama durun, biz `d.prototype.__proto__` istedik yani sadece prototip değişsin ve eski `d.prototype.constructor` sürsün. Burası tam olarak ilk satırın değerinin işin içine girdiği yer (yani `function __() { this.constructor = d; }`). Burada etkili şekilde `d.prototype = {__proto__ : __.prototype, d.constructor = d}`'a (çağrılan fonksiyon içerisinde `new`'ın `this` üzerindeki etkisi yüzünden) sahip olacağız. Yani, `d.prototype.constructor`'i eski haline getirdiğimizden beri, gerçekten değiştirdiğimiz tek şey `__proto__`, bu nedenle `d.prototype.__proto__ = b.prototype`.
 
-#### `d.prototype.__proto__ = b.prototype` significance
+#### `d.prototype.__proto__ = b.prototype` değeri
 
-The significance is that it allows you to add member functions to a child class and inherit others from the base class. This is demonstrated by the following simple example:
+Değer şu ki, bu sizin fonksiyon elemanlarınızı alt sınıfa eklemenize ve diğerlerini üst sınıflardan almanıza izin verir. Bunun gösterimi aşağıdaki basit örnekte yapılmıştır:
 
 ```ts
 function Animal() { }
@@ -139,4 +139,4 @@ var bird = new Bird();
 bird.walk();
 bird.fly();
 ```
-Basically `bird.fly` will be looked up from `bird.__proto__.fly` (remember that `new` makes the `bird.__proto__` point to `Bird.prototype`) and `bird.walk` (an inherited member) will be looked up from `bird.__proto__.__proto__.walk` (as `bird.__proto__ == Bird.prototype` and `bird.__proto__.__proto__` == `Animal.prototype`).
+Aslında `bird.fly` `bird.__proto__.fly`'da aranacaktır (remember that `new`'ın `bird.__proto__`'nun `Bird.prototype`'u işaret ettireceğini hatırlayın) ve `bird.walk` (türetilen eleman) `bird.__proto__.__proto__.walk`'da aranacaktır (`bird.__proto__ == Bird.prototype` ve `bird.__proto__.__proto__` == `Animal.prototype` gibi).
diff --git a/docs/classes-extensibility.md b/docs/classes-extensibility.md
index f07e07e1a..7cd2a8f91 100644
--- a/docs/classes-extensibility.md
+++ b/docs/classes-extensibility.md
@@ -1,10 +1,10 @@
-#### Class extensibility
+#### Sınıf genişletilebilirliği
 
-People often add properties to classes from other JavaScript libraries. Here is a simple JavaScript example of this:
+İnsanlar sıklıkla diğer JavaScript kitaplıklarındaki sınıflara özellikler ekler. İşte basit bir JavaScript örneği:
 
 ```js
-// Original Library
+// Asıl Kütüphane
 function Foo {}
 
-// Third party extension to add new member properties
+// Yeni eleman özellikleri eklemek için üçüncü taraf (third party) uzantısı 
 ```
diff --git a/docs/classes-super.md b/docs/classes-super.md
index e53d67e91..47ff27bf3 100644
--- a/docs/classes-super.md
+++ b/docs/classes-super.md
@@ -1,23 +1,23 @@
 #### `super`
 
-Note that if you call `super` on a child class it is redirected to the `prototype` as shown below:
+Dikkat edin eğer alt sınıfınızda `super`çağrırsanız bu sizi aşağıda gösterildiği gibi `prototype`'a yönlendirecektir:
 
 ```ts
 class Base {
-    log() { console.log('hello world'); }
+    log() { console.log('merha dünya'); }
 }
 
 class Child extends Base {
     log() { super.log() };
 }
 ```
-generates:
+şunu üretir:
 
 ```js
 var Base = (function () {
     function Base() {
     }
-    Base.prototype.log = function () { console.log('hello world'); };
+    Base.prototype.log = function () { console.log('merha dünya'); };
     return Base;
 })();
 var Child = (function (_super) {
@@ -30,13 +30,13 @@ var Child = (function (_super) {
 })(Base);
 
 ```
-Notice `_super.prototype.log.call(this)`.
+`_super.prototype.log.call(this)`'e dikkat.
 
-This means that you cannot use `super` on member properties. Instead you should just use `this`.
+Bunun anlamı eleman özelliklerinizde `super`'i kullanamazsınız. Bunun yerine sadece `this` kullanmalısınız.
 
 ```ts
 class Base {
-    log = () => { console.log('hello world'); }
+    log = () => { console.log('merhaba dünya'); }
 }
 
 class Child extends Base {
@@ -44,18 +44,19 @@ class Child extends Base {
 }
 ```
 
-Notice since there is only one `this` shared between the `Base` and the `Child` class you need to use *different* names (here `log` and `logWorld`).
+`Base` ve `Child` sınıf arasında paylaşılan tek bir tane `this` olduğundan *farklı* adları kullanmanız gerektiğine dikkat edin (işte `log` ve `logWorld`).
 
-Also Note that TypeScript will warn you if you try to misuse `super`:
+Ayrıca, `super`'i yanlış kullanmaya çalışırsanız TypeScript sizi uyaracaktır:
 
 ```ts
 module quz {
     class Base {
-        log = () => { console.log('hello world'); }
+        log = () => { console.log('merhaba dünya'); }
     }
 
     class Child extends Base {
         // ERROR : only `public` and `protected` methods of base class are accessible via `super`
+        // HATA : sadece üst sınıfın `public` ve `protected` metotları `super` ile erişilebilirdir
         logWorld() { super.log() };
     }
 }
diff --git a/docs/classes.md b/docs/classes.md
index 355d8d45f..33c6b4f20 100644
--- a/docs/classes.md
+++ b/docs/classes.md
@@ -35,10 +35,10 @@ var Point = (function () {
     return Point;
 })();
 ```
-This is a fairly idiomatic traditional JavaScript class pattern now as a first class language construct.
+Şimdi bu, birinci sınıf dil yapısı olarak yeterince deyimsel bir geleneksel JavaScript sınıfı kalıbıdır.
 
 ### Kalıtım
-Classes in TypeScript (like other languages) support *single* inheritance using the `extends` keyword as shown below:
+Aşağıda gösterildiği gibi, TypeScript'teki sınıflar `extends` anahtar sözcüğü ile *tekil* kalıtımı destekler (diğer diller gibi):
 
 ```ts
 class Point3D extends Point {
@@ -53,12 +53,12 @@ class Point3D extends Point {
     }
 }
 ```
-If you have a constructor in your class then you *must* call the parent constructor from your constructor (TypeScript will point this out to you). This ensures that the stuff that it needs to set on `this` gets set. Followed by the call to `super` you can add any additional stuff you want to do in your constructor (here we add another member `z`).
+Eğer sınıfınızda yapıcı (constructor) metodunuz varsa, yapıcı metodunuzda üst sınıfınızın yapıcı metodunu çağırmak *zorundasınız* (TypeScript bunu size belirtecektir). Bu `this` üzerinde atanması gereken şeylerin atanmasını sağlar. Sonrasında, `super`'in çağırılmasıyla yapıcı metodunuzda yapmak istediğiniz şeyleri ekleyebilirsiniz (Burada `z` adında başka bir eleman ekliyoruz).
 
-Note that you override parent member functions easily (here we override `add`) and still use the functionality of the super class in your members (using `super.` syntax).
+Üst eleman fonksiyonlarını kolayca geçersiz kılabileceğinizi (`add`'i burada geçersiz kılıyoruz) ve hala elemanlarınızdaki üst sınıflarınızın işlevselliklerini kullanabileceğinizi göz önünde bulundurun (`super.` sözdizimi kullanarak).
 
-### Statics
-TypeScript classes support `static` properties that are shared by all instances of the class. A natural place to put (and access) them is on the class itself and that is what TypeScript does:
+### Statikler (Static)
+TypeScript sınıfları, sınıfın tüm örnekleri tarafından paylaşılan `static` özellikleri destekler.Statik özellikleri koymak (ve erişmek) için en doğal yer sınıfın içerisidir ve TypeScript'in yaptığı şey şöyledir:
 
 ```ts
 class Something {
@@ -73,21 +73,21 @@ var s2 = new Something();
 console.log(Something.instances); // 2
 ```
 
-You can have static members as well as static functions.
+Statik fonksiyonlarınız olduğu gibi statik elemanlarınız da olabilir.
 
-### Access Modifiers
-TypeScript supports access modifiers `public`,`private` and `protected` which determine the accessibility of a `class` member as shown below:
+### Erişim Belirleyiciler
+TypeScript, aşağıda gösterildiği gibi bir `sınıf` elemanının erişilebilirliğini belirleyen `public`,`private` and `protected` erişim belirleyicilerini destekler.
 
-| accessible on   | `public` | `protected` | `private` |
+| erişilebilir    | `public` | `protected` | `private` |
 |-----------------|----------|-------------|-----------|
-| class           | yes      | yes         | yes       |
-| class children  | yes      | yes         | no        |
-| class instances | yes      | no          | no        |
+| sınıf           | evet     | evet        | evet      |
+| alt sınıf       | evet     | evet        | hayır     |
+| sınıf örneği    | evet     | hayır       | hayır     |
 
 
-If an access modifier is not specified it is implicitly `public` as that matches the *convenient* nature of JavaScript 🌹.
+Eğer bir erişim belirleyici tanımlanmazsa, o JavaScript'in *kullanışlı* doğasına uyduğu için `public` olarak üstü kapalı şekilde belirlenir 🌹.
 
-Note that at runtime (in the generated JS) these have no significance but will give you compile time errors if you use them incorrectly. An example of each is shown below:
+Çalışma zamanında (üretilen JS'te) bunlar önemsizdir, ancak hatalı kullanırsanız derleme zamanı hataları verecektir. Her biri için örnek gösterim aşağıdadır:
 
 ```ts
 class FooBase {
@@ -96,13 +96,13 @@ class FooBase {
     protected z: number;
 }
 
-// EFFECT ON INSTANCES
+// ÖRNEKLERDEKİ ETKİ
 var foo = new FooBase();
 foo.x; // okay
 foo.y; // ERROR : private
 foo.z; // ERROR : protected
 
-// EFFECT ON CHILD CLASSES
+// ALT SINIFLARDAKİ ETKİ
 class FooChild extends FooBase {
     constructor() {
       super();
@@ -113,26 +113,26 @@ class FooChild extends FooBase {
 }
 ```
 
-As always these modifiers work for both member properties and member functions.
+Her zaman olduğu gibi, bu belirleyiciler hem eleman özellikleri hem de eleman fonksiyonları için çalışır.
 
-### Abstract
-`abstract` can be thought of as an access modifier. We present it separately because opposed to the previously mentioned modifiers it can be on a `class` as well as any member of the class. Having an `abstract` modifier primarily means that such functionality *cannot be directly invoked* and a child class must provide the functionality.
+### Abstract (Soyut)
+`abstract` erişim belirleyici olarak düşünülebilir. Ayrı olarak ele almaktayız, çünkü daha önce bahsedilen belirleyicilerle birlikte bir `sınıfın` yanı sıra, sınıfın herhangi bir elemanı da olabilir. `abstract` bir belirleyiciye sahip olmak, öncelikle bu işlevselliği *doğrudan çağrılamaz* ve bir alt sınıfı fonksiyonları sağlamalıdır demektir.
 
-* `abstract` **classes** cannot be directly instantiated. Instead the user must create some `class` that inherit from the `abstract class`.
-* `abstract` **members** cannot be directly accessed and a child class must provide the functionality.
+* `abstract` **sınıflar** doğrudan örneklenemezler. Bunun yerine kullanıcı `abstract sınıf`'tan türemiş `sınıf` yaratmalıdır.
+* `abstract` **elemanlar** doğrudan erişilemez ve alt sınıf, fonksiyonları sağlamalıdır.
 
-### Constructor is optional
+### Yapıcı Metot (Constructor) İsteğe Bağlıdır
 
-The class does not need to have a constructor. e.g. the following is perfectly fine. 
+Sınıfın yapıcı metoda sahip olması gerekmez. Sıradaki örnek bunun için güzel bir örnektir. 
 
 ```ts
 class Foo {}
 var foo = new Foo();
 ```
 
-### Define using constructor
+### Yapıcı Metot kullanım tanımı
 
-Having a member in a class and initializing it like below:
+Sınıfta bir elemana sahip olmak ve onu aşağıdaki gibi yüklenmesi:
 
 ```ts
 class Foo {
@@ -142,7 +142,7 @@ class Foo {
     }
 }
 ```
-is such a common pattern that TypeScript provides a shorthand where you can prefix the member with an *access modifier* and it is automatically declared on the class and copied from the constructor. So the previous example can be re-written as (notice `public x:number`):
+bu TypeScript'in elemanı *erişim belirleyici* ile ön ek olarak sağladığı yaygın bir kalıptır, sınıf üzerinde otomatik olarak deklare edilir ve yapıcı metotdan kopyalanır. Yani önceki örnek şu şekilde tekrar yazılabilir (dikkat `public x:number`):
 
 ```ts
 class Foo {
@@ -151,12 +151,12 @@ class Foo {
 }
 ```
 
-### Property initializer
-This is a nifty feature supported by TypeScript (from ES7 actually). You can initialize any member of the class outside the class constructor, useful to provide default (notice `members = []`)
+### Özellik yükleyici
+Bu TypeScript tarafından desteklenen havalı bir özelliktir (ES7'nin aslında). Sınıfın yapıcı metodu dışında herhangi bir sınıf elemanını yükleyebilirsiniz, varsayılanı sağlamak için kullanışlıdır (dikkat `members = []`)
 
 ```ts
 class Foo {
-    members = [];  // Initialize directly
+    members = [];  // Direk olarak yüklenir
     add(x) {
         this.members.push(x);
     }

From cebbe0e5956be5730028c93a9b986c4e5c72dfa3 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Wed, 15 Feb 2017 09:39:39 +0300
Subject: [PATCH 46/74] @ozgunbal review sonrasi degisiklikler

---
 docs/classes-emit.md          | 22 +++++++++++-----------
 docs/classes-extensibility.md |  2 +-
 docs/classes.md               |  2 +-
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/docs/classes-emit.md b/docs/classes-emit.md
index 6b39ac6d5..8c7deca07 100644
--- a/docs/classes-emit.md
+++ b/docs/classes-emit.md
@@ -1,4 +1,4 @@
-#### IIFE Nedir Ne Değildir?
+#### IIFE Nedir, Ne Değildir?
 Sınıf için üretilen js şöyle olabilirdi:
 ```ts
 function Point(x, y) {
@@ -10,7 +10,7 @@ Point.prototype.add = function (point) {
 };
 ```
 
-Sebebi  Anlık-Çağrılan Fonksiyon İfadesi (Immediately-Invoked Function Expression) (IIFE) ile sarmalanmıştır, yani:
+Bunun sebebi Anlık-Çağrılan Fonksiyon İfadesi (Immediately-Invoked Function Expression) (IIFE) ile sarmalanmış olmasıdır, yani:
 
 ```ts
 (function () {
@@ -41,7 +41,7 @@ var Point3D = (function (_super) {
 Dikkat edin IIFE, TypeScript'in kolayca üst sınıf `Point` içerisindeki `_super` değişkenini yakalamasına izin verir ve sınıfın ana bloğunda sürekli olarak kullanılır.
 
 ### `__extends`
-Şunu farkedeceksiniz ki bir sınıftan kalıtım yaptığınız anda TypeScript ayrıca aşağıdaki fonksiyonu da oluşturur:
+Şunu fark edeceksiniz ki bir sınıftan türettiğinizde TypeScript ayrıca aşağıdaki fonksiyonu da oluşturur:
 ```ts
 var __extends = this.__extends || function (d, b) {
     for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
@@ -58,14 +58,14 @@ Burada `d` türetilmiş sınıfı ve `b` üst sınıfı ifade eder. Bu fonksiyon
 
 #### `d.prototype.__proto__ = b.prototype`
 
-Birçok insana bu konuyu anlattıktan sonra aşağıdaki açıklamayı en basit buluyorum. Öncelikle `__extends`'deki kodun nasıl basit `d.prototype.__proto__ = b.prototype`'a eşit olduğunu açıklayacağız, ve sonrasında kendi içindeki bu satırın neden değerli olduğunu. Bunu tamamen anlayabilmeniz için şunları bilmeniz gerekir:
+Birçok insana bu konuyu anlattıktan sonra aşağıdaki açıklamanın en basiti olduğunu düşünüyorum. Öncelikle `__extends`'deki kodun nasıl basit `d.prototype.__proto__ = b.prototype`'a eşit olduğunu açıklayacağız, ve sonrasında kendi içindeki bu satırın neden önemli olduğunu. Bunu tamamen anlayabilmeniz için şunları bilmeniz gerekir:
 
 1. `__proto__`
 1. `prototype`
 1. çağrılan fonksiyon içerisinde `new`'ın `this` üzerindeki etkisi
 1. `new`'ın `prototype` ve `__proto__` üzerindeki etkisi
 
-JavaScript'teki tüm nesneler `__proto__` elemanını içerir. Bu eleman eski tarayıcılar tarafından sıklıkla erişilemez durumdadır (bazen dökümantasyon bu sihirli özelliği `[[prototype]]` olarak ifade eder). Bunun tek bir görevi vardır: Eğer arama sırasında nesne üzerinde özellik bulunamazsa (örneğin `obj.property`) `obj.__proto__.property`'e bakacaktır. Eğer hala bulunamadıysa ozaman `obj.__proto__.__proto__.property`'a ta ki ikiside: *it is found* veya *the latest `.__proto__` itself is null* olana kadar. Bu JavaScript'in *prototipsel kalıtım(prototypal inheritance)* işlevselliğine neden destek dediğini açıklar. Bu aşağıdaki örnekte, chrome konsolunda veya nodejs'te çalıştırılacak şekilde gösterilmiştir:
+JavaScript'teki tüm nesneler `__proto__` elemanını içerir. Bu eleman eski tarayıcılar tarafından sıklıkla erişilemez durumdadır (bazen dökümantasyon bu sihirli özelliği `[[prototype]]` olarak ifade eder). Bunun tek bir görevi vardır: Eğer arama sırasında nesne üzerinde özellik bulunamazsa (örneğin `obj.property`) `obj.__proto__.property`'e bakacaktır. Eğer hala bulunamadıysa ozaman `obj.__proto__.__proto__.property`'a ta ki ikisi de: *it is found* veya *the latest `.__proto__` itself is null* olana kadar. Bu JavaScript'in *prototipsel kalıtım(prototypal inheritance)* işlevselliğine neden destek verdiğini açıklar. Chrome konsolunda veya nodejs'te çalışan bir örneği şekilde gösterilmiştir:
 
 ```ts
 var foo = {}
@@ -81,7 +81,7 @@ delete foo.__proto__.bar; // foo.__proto__'dan çıkar
 console.log(foo.bar); // undefined
 ```
 
-`__proto__`'yu anlıyorsun harika. Başka bir yararlı bilgi ise, JavaScript içerisindeki tüm `fonksiyon`'lar `prototype` diye adlandırılan özelliğe sahiptir ve fonksiyonu geri işaret eden `constructor` elemanına sahiptir. Aşağıda gösterilmiştir:
+`__proto__`'yu anlıyorsun, harika. Başka bir yararlı bilgi ise, JavaScript içerisindeki tüm `fonksiyon`'lar `prototype` diye adlandırılan özelliğe sahiptir ve fonksiyonu geri işaret eden `constructor` elemanına sahiptir. Aşağıda gösterilmiştir:
 
 ```ts
 function Foo() { }
@@ -101,7 +101,7 @@ var newFoo = new Foo();
 console.log(newFoo.bar); // 123
 ```
 
-Şimdi öğrenmeniz gereken diğer son şey ise,fonksiyon üzerinde `new`'ı çağırmak, fonksiyon çağrısından dönen yeni yaratılmış nesnenin `__proto__`'su içindeki `prototype`'ı kopyalar. İşte çalıştırıp tamamen anlayabilmeniz için gereken kod bu:
+Şimdi öğrenmeniz gereken son bir şey ise, fonksiyon üzerinde `new`'ı çağırmak, fonksiyon çağrısından dönen yeni yaratılmış nesnenin `__proto__`'su içindeki `prototype`'ı kopyalar. İşte çalıştırıp tamamen anlayabilmeniz için gereken kod bu:
 
 ```ts
 function Foo() { }
@@ -121,11 +121,11 @@ console.log(foo.__proto__ === Foo.prototype); // True!
 
 Bu fonksiyonu satır 3 üzerindeki `d.prototype = new __()` tersten okumanın etkili anlamı `d.prototype = {__proto__ : __.prototype}` (`new`'ın `prototype` ve `__proto__` üzerindeki etkisi yüzünden), önceki satırdaki (yani satır 2 `__.prototype = b.prototype;`) ile birleştirme sonucunda `d.prototype = {__proto__ : b.prototype}` alırsınız.
 
-Ama durun, biz `d.prototype.__proto__` istedik yani sadece prototip değişsin ve eski `d.prototype.constructor` sürsün. Burası tam olarak ilk satırın değerinin işin içine girdiği yer (yani `function __() { this.constructor = d; }`). Burada etkili şekilde `d.prototype = {__proto__ : __.prototype, d.constructor = d}`'a (çağrılan fonksiyon içerisinde `new`'ın `this` üzerindeki etkisi yüzünden) sahip olacağız. Yani, `d.prototype.constructor`'i eski haline getirdiğimizden beri, gerçekten değiştirdiğimiz tek şey `__proto__`, bu nedenle `d.prototype.__proto__ = b.prototype`.
+Ama durun, biz `d.prototype.__proto__` istedik yani sadece prototip değişsin ve eski `d.prototype.constructor` sürsün. Burası tam olarak ilk satırın öneminin işin içine girdiği yer (yani `function __() { this.constructor = d; }`). Burada etkili şekilde `d.prototype = {__proto__ : __.prototype, d.constructor = d}`'a (çağrılan fonksiyon içerisinde `new`'ın `this` üzerindeki etkisi yüzünden) sahip olacağız. Yani, `d.prototype.constructor`'i eski haline getirdiğimizden beri, gerçekten değiştirdiğimiz tek şey `__proto__`, bu nedenle `d.prototype.__proto__ = b.prototype`.
 
-#### `d.prototype.__proto__ = b.prototype` değeri
+#### `d.prototype.__proto__ = b.prototype` önemi
 
-Değer şu ki, bu sizin fonksiyon elemanlarınızı alt sınıfa eklemenize ve diğerlerini üst sınıflardan almanıza izin verir. Bunun gösterimi aşağıdaki basit örnekte yapılmıştır:
+Önemi şu ki, bu sizin fonksiyon elemanlarınızı alt sınıfa eklemenize ve diğerlerini üst sınıflardan almanıza izin verir. Bunun gösterimi aşağıdaki basit örnekte yapılmıştır:
 
 ```ts
 function Animal() { }
@@ -139,4 +139,4 @@ var bird = new Bird();
 bird.walk();
 bird.fly();
 ```
-Aslında `bird.fly` `bird.__proto__.fly`'da aranacaktır (remember that `new`'ın `bird.__proto__`'nun `Bird.prototype`'u işaret ettireceğini hatırlayın) ve `bird.walk` (türetilen eleman) `bird.__proto__.__proto__.walk`'da aranacaktır (`bird.__proto__ == Bird.prototype` ve `bird.__proto__.__proto__` == `Animal.prototype` gibi).
+Aslında `bird.fly` `bird.__proto__.fly`'da aranacaktır (`new`'ın `bird.__proto__`'nun `Bird.prototype`'u işaret ettireceğini hatırlayın) ve `bird.walk` (türetilen eleman) `bird.__proto__.__proto__.walk`'da aranacaktır (`bird.__proto__ == Bird.prototype` ve `bird.__proto__.__proto__` == `Animal.prototype` gibi).
diff --git a/docs/classes-extensibility.md b/docs/classes-extensibility.md
index 7cd2a8f91..8684c193d 100644
--- a/docs/classes-extensibility.md
+++ b/docs/classes-extensibility.md
@@ -1,6 +1,6 @@
 #### Sınıf genişletilebilirliği
 
-İnsanlar sıklıkla diğer JavaScript kitaplıklarındaki sınıflara özellikler ekler. İşte basit bir JavaScript örneği:
+İnsanlar sıklıkla diğer JavaScript kütüphanelerindeki sınıflara özellikler ekler. İşte basit bir JavaScript örneği:
 
 ```js
 // Asıl Kütüphane
diff --git a/docs/classes.md b/docs/classes.md
index 33c6b4f20..a581f4405 100644
--- a/docs/classes.md
+++ b/docs/classes.md
@@ -35,7 +35,7 @@ var Point = (function () {
     return Point;
 })();
 ```
-Şimdi bu, birinci sınıf dil yapısı olarak yeterince deyimsel bir geleneksel JavaScript sınıfı kalıbıdır.
+Şimdi bu, birinci sınıf dil yapısı olarak yeterince geleneksel bir JavaScript sınıfı kalıbıdır.
 
 ### Kalıtım
 Aşağıda gösterildiği gibi, TypeScript'teki sınıflar `extends` anahtar sözcüğü ile *tekil* kalıtımı destekler (diğer diller gibi):

From e9a8aa21549acf877342f1ae419f1f81124fdb32 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Wed, 15 Feb 2017 09:42:38 +0300
Subject: [PATCH 47/74] @ozgunbal review sonrasi degisiklikler

---
 docs/classes.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/classes.md b/docs/classes.md
index a581f4405..600f185a5 100644
--- a/docs/classes.md
+++ b/docs/classes.md
@@ -156,7 +156,7 @@ Bu TypeScript tarafından desteklenen havalı bir özelliktir (ES7'nin aslında)
 
 ```ts
 class Foo {
-    members = [];  // Direk olarak yüklenir
+    members = [];  // Doğrudan yüklenir
     add(x) {
         this.members.push(x);
     }

From 7cf668000d40596390a8f23a7f5da60df9cb9983 Mon Sep 17 00:00:00 2001
From: Ozgun Bal <ozgunbal@gmail.com>
Date: Fri, 17 Feb 2017 17:12:43 +0300
Subject: [PATCH 48/74] =?UTF-8?q?#10=20for...of=20=C3=A7eviri=20tamamland?=
 =?UTF-8?q?=C4=B1?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/for...of.md | 41 +++++++++++++++++++++++------------------
 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/docs/for...of.md b/docs/for...of.md
index 321f35699..3fc8a5017 100644
--- a/docs/for...of.md
+++ b/docs/for...of.md
@@ -1,5 +1,5 @@
 ### for...of
-A common error experienced by beginning JavaScript developers is that `for...in` for an array does not iterate over the array items. Instead it iterates over the *keys* of the object passed in. This is demonstrated in the below example. Here you would expect `9,2,5` but you get the indexes `0,1,2`:
+Dizi öğelerinin yinelenmesi için `for...in` kullanılması, Javascript'e yeni başlayan geliştiricilerin karşılaştıkları yaygın bir hatadır. Dizi elemanları yerine verilen nesnenin *anahtarlarını*(*keys*) yineler. Aşağıdaki örnekte gösterilmiştir. `9,2,5` beklemenize rağmen, çıkan sonuç `0,1,2` dizinleridir:
 
 ```ts
 var someArray = [9, 2, 5];
@@ -8,7 +8,7 @@ for (var item in someArray) {
 }
 ```
 
-This is one of the reasons why `for...of` exists in TypeScript (and ES6). The following iterates over the array correctly logging out the members as expected:
+`for...of`'un TypeScript'te (ve ES6'da) olma sebeplerinden biri, işte budur. Örneğin, sıradaki dizi doğru bir biçimde yinelenmekte ve elemanları beklenildiği gibi çıkmaktadır:
 
 ```ts
 var someArray = [9, 2, 5];
@@ -17,45 +17,50 @@ for (var item of someArray) {
 }
 ```
 
-Similarly TypeScript has no trouble going through a string character by character using `for...of`:
+TypeScript, karakter dizimindeki karakterleri yinelemek için de `for...of` kullanmanıza imkan sağlar:
 
 ```ts
-var hello = "is it me you're looking for?";
-for (var char of hello) {
-    console.log(char); // is it me you're looking for?
+var selam = "naber?";
+for (var char of selam) {
+    console.log(char); 
 }
+// 'n'
+// 'a'
+// 'b'
+// 'e'
+// 'r'
+// '?'
 ```
 
-#### JS Generation
-For pre ES6 targets TypeScript will generate the standard `for (var i = 0; i < list.length; i++)` kind of loop. For example here's what gets generated for our previous example:
+#### JS Oluşturulması
+TypeScript, ES6 öncesi için `for (var i = 0; i < list.length; i++)` benzeri standart bir döngü oluşturur. Önceki örneğimizin Javascript'te oluşturulmuş hali, şu şekildedir:
 ```ts
 var someArray = [9, 2, 5];
 for (var item of someArray) {
     console.log(item);
 }
 
-// becomes //
+// şuna dönüşür //
 
 for (var _i = 0; _i < someArray.length; _i++) {
     var item = someArray[_i];
     console.log(item);
 }
 ```
-You can see that using `for...of` makes *intent* clearer and also decreases the amount of code you have to write (and variable names you need to come up with).
+Gördüğünüz gibi `for...of` kullandığınızda *maksadınız* daha açıktır. Ayrıca yazdığınız kod miktarı (ve kullandığınız değişken isimleri) azalır.
 
-#### Limitations
-If you are not targeting ES6 or above, the generated code assumes the property `length` exists on the object and that the object can be indexed via numbers e.g. `obj[2]`. So it is only supported on `string` and `array` for these legacy JS engines.
+#### Kısıtlamalar
+Eğer ES6 veya üstünü hedeflemiyorsanız, oluşturulan kod, nesnede `length` özelliği olduğunu varsayar ve nesneye dizin kullanarak erişir, örneğin; `obj[2]`. Bu yüzden eski JS motorları sadece `string` ve `array` destekler.
 
-If TypeScript can see that you are not using an array or a string it will give you a clear error *"is not an array type or a string type"*;
+Eğer dizi veya karakter dizimi kullanmazsınız, TypeScript bunu görür ve *"dizi veya karakter dizimi tipinde değil"* hatası verir;
 ```ts
 let articleParagraphs = document.querySelectorAll("article > p");
-// Error: Nodelist is not an array type or a string type
+//Hata: Nodelist is not an array type or a string type
 for (let paragraph of articleParagraphs) {
     paragraph.classList.add("read");
 }
 ```
+`for...of`'u sadece dizi veya karakter dizimi olduğunu *bildiğiniz* şeylerde kullanın. Bu kısıtlamanın TypeScript'in ileriki sürümlerinde kaldırılabileceğini de göz önünde bulundurunuz.
 
-Use `for...of` only for stuff that *you know* to be an array or a string. Note that this limitation might be removed in a future version of TypeScript.
-
-#### Summary
-You would be surprised at how many times you will be iterating over the elements of an array. The next time you find yourself doing that, give `for...of` a go. You might just make the next person who reviews your code happy.
+#### Özet
+Dizilerde yinelemeyi ne kadar kullandığınızı bilseniz şaşırırsınız. Bir dahaki denemenizde, `for...of`'a bir şans verin. Belki de kodunuzu gözden geçiren bir sonraki kişiyi mutlu edeceksiniz. 
\ No newline at end of file

From 7defced44db404b4b08eaeb2391aa291bd1befbe Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Fri, 3 Mar 2017 11:49:47 +0300
Subject: [PATCH 49/74] =?UTF-8?q?#45=20Common=20Errors=20=C3=A7evirisi?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/errors/main.md | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/docs/errors/main.md b/docs/errors/main.md
index feb6ba356..8c60a2ed3 100644
--- a/docs/errors/main.md
+++ b/docs/errors/main.md
@@ -1,30 +1,30 @@
-# Common Errors
-In this section we explain a number of common error codes that users experience in the real world.
+# Genel Hatalar
+Bu bölümde kullanıcıların gerçek hayatta deneyimledikleri birkaç genel hata kodunu açıklayacağız.
 
 ## TS2304
-Samples:
-> `Cannot find name ga`
+Örnek:
+> `Cannot find name ga (ga ismi bulunamıyor)`
 
-You are probably using a third party library (e.g. google analytics) and don't have it `declare`d. TypeScript tries to save you from *spelling mistakes* and *using variables without declaring them* so you need to be explicit on anything that is *available at runtime* because of you including some external library ([more on how to fix it][ambient]).
+Muhtemelen `declare (deklare)` etmediğiniz üçüncü parti bir kütüphane (örneğin google analytics) kullanıyorsunuz. TypeScript sizi *yazım hatalarından* ve *değişkenleri deklare etmeden kullanmanızdan* korumaya çalışır, yani *çalışma zamanında varolan* harhangi bir şeye açık olmalısınız çünkü bazı dış kütüphaneleri dahil ediyorsunuz ([nasıl düzeltileceğine dair dahası][ambient]).
 
 ## TS2307
-Samples:
-> `Cannot find module 'underscore'`
+Örnek:
+> `Cannot find module 'underscore' ('underscrore' modülü bulunamıyor)`
 
-You are probably using a third party library (e.g. underscore) as a *module* ([more on modules][modules]) and don't have the ambient declaration file for it ([more on ambient declarations][ambient]).
+Muhtemelen *modül* ([modüllere (modules) dair dahası][modules]) olarak üçüncü parti bir kütüphane (örneğin underscore) kullanıyorsunuz ve bunun için içsel deklarasyon dosyanız yok ([içsel deklarasyona dair dahası][ambient]).
 
 ## TS1148
-Sample:
-> Cannot compile modules unless the '--module' flag is provided
+Örnek:
+> Cannot compile modules unless the '--module' flag is provided ('--module' işareti sağlanmadığı sürece modüller derlenemez)
 
-Checkout the [section on modules][modules].
+[Modüller (modules) bölümü][modules]'ne göz atın.
 
-## For search indexing
-You can ignore reading this. This section is for search engine indexing.
+## Arama indekslemesi için
+Bu kısmı görmezden gelebilirsiniz. Bu kısım arama motoru indekslemesi için.
 
-> Other modules that people tend to use and get errors:
-* Cannot find name $
-* Cannot find module jquery
+> Kullanıcıların kullanmayı sevdiği ve hata vermeye eğilimli diğer modüller:
+* Cannot find name $ ($ ismi bulunamıyor)
+* Cannot find module jquery (jquery modülü bulunamıyor)
 
 [ambient]: ../types/ambient/d.ts.md
 [modules]: ../project/modules.md

From 091aa68075693a2c546044a62f4ed85d7d108daa Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Sat, 4 Mar 2017 15:45:25 +0300
Subject: [PATCH 50/74] =?UTF-8?q?@uguratar=20review=20sonras=C4=B1=20bir?=
 =?UTF-8?q?=20ka=C3=A7=20d=C3=BCzeltme?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/errors/main.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/errors/main.md b/docs/errors/main.md
index 8c60a2ed3..d99e4d3b9 100644
--- a/docs/errors/main.md
+++ b/docs/errors/main.md
@@ -1,17 +1,17 @@
-# Genel Hatalar
+# Sıkça Karşılaşılan Hatalar
 Bu bölümde kullanıcıların gerçek hayatta deneyimledikleri birkaç genel hata kodunu açıklayacağız.
 
 ## TS2304
 Örnek:
 > `Cannot find name ga (ga ismi bulunamıyor)`
 
-Muhtemelen `declare (deklare)` etmediğiniz üçüncü parti bir kütüphane (örneğin google analytics) kullanıyorsunuz. TypeScript sizi *yazım hatalarından* ve *değişkenleri deklare etmeden kullanmanızdan* korumaya çalışır, yani *çalışma zamanında varolan* harhangi bir şeye açık olmalısınız çünkü bazı dış kütüphaneleri dahil ediyorsunuz ([nasıl düzeltileceğine dair dahası][ambient]).
+Muhtemelen `deklare (declare)` etmediğiniz üçüncü parti bir kütüphane (örneğin google analytics) kullanıyorsunuz. TypeScript sizi *yazım hatalarından* ve *değişkenleri deklare etmeden kullanmanızdan* korumaya çalışır, yani *çalışma zamanında varolan* harhangi bir şeye açık olmalısınız çünkü bazı dış kütüphaneleri dahil ediyorsunuz ([nasıl düzeltileceğine dair daha fazla bilgi][ambient]).
 
 ## TS2307
 Örnek:
 > `Cannot find module 'underscore' ('underscrore' modülü bulunamıyor)`
 
-Muhtemelen *modül* ([modüllere (modules) dair dahası][modules]) olarak üçüncü parti bir kütüphane (örneğin underscore) kullanıyorsunuz ve bunun için içsel deklarasyon dosyanız yok ([içsel deklarasyona dair dahası][ambient]).
+Muhtemelen üçüncü parti bir kütüphaneyi (örneğin underscore) *modül* ([modüllere (modules) dair daha fazla bilgi][modules]) olarak kullanıyorsunuz ve bunun için içsel deklarasyon dosyanız yok ([çsel deklarasyona dair daha fazla bilgi][ambient]).
 
 ## TS1148
 Örnek:

From 3dd8d4ce4558b9a8c79e5c9e301bc6cc9c1d1532 Mon Sep 17 00:00:00 2001
From: Murat Mustafa Dinler <m.mustafadinler@gmail.com>
Date: Sun, 5 Mar 2017 13:20:40 +0300
Subject: [PATCH 51/74] @ozgunbal review sonrasi duzeltme

---
 docs/errors/main.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/errors/main.md b/docs/errors/main.md
index d99e4d3b9..6c7f7fd51 100644
--- a/docs/errors/main.md
+++ b/docs/errors/main.md
@@ -11,7 +11,7 @@ Muhtemelen `deklare (declare)` etmediğiniz üçüncü parti bir kütüphane (ö
 Örnek:
 > `Cannot find module 'underscore' ('underscrore' modülü bulunamıyor)`
 
-Muhtemelen üçüncü parti bir kütüphaneyi (örneğin underscore) *modül* ([modüllere (modules) dair daha fazla bilgi][modules]) olarak kullanıyorsunuz ve bunun için içsel deklarasyon dosyanız yok ([çsel deklarasyona dair daha fazla bilgi][ambient]).
+Muhtemelen üçüncü parti bir kütüphaneyi (örneğin underscore) *modül* ([modüllere (modules) dair daha fazla bilgi][modules]) olarak kullanıyorsunuz ve bunun için içsel deklarasyon dosyanız yok ([içsel deklarasyona dair daha fazla bilgi][ambient]).
 
 ## TS1148
 Örnek:

From b7e52b2cb101feeaf6161df5ca9c4aed16be56e0 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Mon, 6 Mar 2017 10:37:18 +0300
Subject: [PATCH 52/74] @ozgunbal review sonrasi duzeltmeler

---
 docs/errors/main.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/errors/main.md b/docs/errors/main.md
index d99e4d3b9..6c7f7fd51 100644
--- a/docs/errors/main.md
+++ b/docs/errors/main.md
@@ -11,7 +11,7 @@ Muhtemelen `deklare (declare)` etmediğiniz üçüncü parti bir kütüphane (ö
 Örnek:
 > `Cannot find module 'underscore' ('underscrore' modülü bulunamıyor)`
 
-Muhtemelen üçüncü parti bir kütüphaneyi (örneğin underscore) *modül* ([modüllere (modules) dair daha fazla bilgi][modules]) olarak kullanıyorsunuz ve bunun için içsel deklarasyon dosyanız yok ([çsel deklarasyona dair daha fazla bilgi][ambient]).
+Muhtemelen üçüncü parti bir kütüphaneyi (örneğin underscore) *modül* ([modüllere (modules) dair daha fazla bilgi][modules]) olarak kullanıyorsunuz ve bunun için içsel deklarasyon dosyanız yok ([içsel deklarasyona dair daha fazla bilgi][ambient]).
 
 ## TS1148
 Örnek:

From 2462fa1bb86e8724486caf3383f991eec7e1ec73 Mon Sep 17 00:00:00 2001
From: Ozgun Bal <ozgunbal@gmail.com>
Date: Mon, 6 Mar 2017 10:43:42 +0300
Subject: [PATCH 53/74] =?UTF-8?q?#44=20Future=20JavaScript:=20Now=20=C3=A7?=
 =?UTF-8?q?evirisi=20tamamland=C4=B1?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/future-javascript.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/future-javascript.md b/docs/future-javascript.md
index 389d125f4..f3677e9f9 100644
--- a/docs/future-javascript.md
+++ b/docs/future-javascript.md
@@ -1,4 +1,4 @@
-# Future JavaScript: Now
-One of the main selling points of TypeScript is that it allows you to use a bunch of features from ES6 and beyond in current (ES3 and ES5 level) JavaScript engines (like current browsers and NodeJS). Here we deep dive into why these features are useful followed by how these features are implemented in TypeScript.
+# Geleceğin Javascript'i: Şimdi
+Typescript'in istenilen bir ürün olmasının nedenlerinden biri ES6 ve güncel (ES3 ve ES5 seviyesi) Javascript motorlarının (güncel tarayıcılar ve NodeJS) ötesindeki özellikleri desteklemesidir. Neden bu özelliklerin faydalı olduğunu ve sonra Typescript'te nasıl uygulandıklarını derinlemesine inceleyeceğiz.
 
-Note: Not all of these features are slated for immediate addition to JavaScript but provide great utility to your code organization and maintenance. Also note that you are free to ignore any of the constructs that don't make sense for your project, although you will end up using most of them eventually ;)
+Not: Bu özelliklerin tamamı Javascript'e gözle görülür katkı sağlamasa da kod organizasyonu ve bakımını önemli ölçüde geliştirecektir. Ayrıca bilmenizde fayda var; size mantıklı gelmeyen yapıları yoksaymakta serbestsiniz. Her ne kadar, eninde sonunda çoğunu kullanacak olsanız da ;)

From 597d7d5cd48a4486cfadcea31d979f76e31e938a Mon Sep 17 00:00:00 2001
From: Ozgun Bal <ozgunbal@gmail.com>
Date: Mon, 6 Mar 2017 10:47:12 +0300
Subject: [PATCH 54/74] =?UTF-8?q?=C3=A7eviri=20de=C4=9Fi=C5=9Fikli=C4=9Fi?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/future-javascript.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/future-javascript.md b/docs/future-javascript.md
index f3677e9f9..800e15723 100644
--- a/docs/future-javascript.md
+++ b/docs/future-javascript.md
@@ -1,4 +1,4 @@
 # Geleceğin Javascript'i: Şimdi
-Typescript'in istenilen bir ürün olmasının nedenlerinden biri ES6 ve güncel (ES3 ve ES5 seviyesi) Javascript motorlarının (güncel tarayıcılar ve NodeJS) ötesindeki özellikleri desteklemesidir. Neden bu özelliklerin faydalı olduğunu ve sonra Typescript'te nasıl uygulandıklarını derinlemesine inceleyeceğiz.
+Typescript'in istenilen bir ürün olmasının nedenlerinden biri ES6 ve güncel (ES3 ve ES5 seviyesi) Javascript motorlarının (güncel tarayıcılar ve NodeJS) ötesindeki özellikleri desteklemesidir. Neden bu özelliklerin faydalı olduğunu ve devamında Typescript'te nasıl uygulandıklarını derinlemesine inceleyeceğiz.
 
 Not: Bu özelliklerin tamamı Javascript'e gözle görülür katkı sağlamasa da kod organizasyonu ve bakımını önemli ölçüde geliştirecektir. Ayrıca bilmenizde fayda var; size mantıklı gelmeyen yapıları yoksaymakta serbestsiniz. Her ne kadar, eninde sonunda çoğunu kullanacak olsanız da ;)

From 9de3c00df881386a5d72d7e3af4ec6eef2f6dc1c Mon Sep 17 00:00:00 2001
From: ozgend <revolter00@gmail.com>
Date: Mon, 3 Apr 2017 12:02:35 +0300
Subject: [PATCH 55/74] destructuring cevirisi tamamlandi

---
 docs/destructuring.md | 55 +++++++++++++++++++++++--------------------
 1 file changed, 29 insertions(+), 26 deletions(-)

diff --git a/docs/destructuring.md b/docs/destructuring.md
index cbf98d9a7..4d8447776 100644
--- a/docs/destructuring.md
+++ b/docs/destructuring.md
@@ -1,11 +1,11 @@
-### Destructuring
+### Parçalama (*destructing*)
 
-TypeScript supports the following forms of Destructuring (literally named after de-structuring i.e. breaking up the structure):
+TypeScript aşağıda yer alan parçalama biçimlerini destekler:
 
-1. Object Destructuring
-1. Array Destructuring
+1. Nesne Parçalama
+2. Dizi Parçalama
 
-It is easy to think of destructuring as an inverse of *structuring*. The method of *structuring* in JavaScript is the object literal:
+Parçalamayı oluşturmanın tersi olarak düşünebilirsiniz. JavaScript'te nesneleri oluşturmanın yolu nesne sabitlerini (*object literal*) kullanmaktır;
 
 ```ts
 var foo = {
@@ -14,72 +14,75 @@ var foo = {
     }
 };
 ```
-Without the awesome *structuring* support built into JavaScript, creating new objects on the fly would indeed be very cumbersome. Destructuring brings the same level of convenience to getting data out of a structure.
+Eğer JavaScript'te bu şekildeki *oluşturma* yöntemi olmasaydı, anında yeni nesneler yaratmak oldukca zahmetli ve hantal olurdu.
+Parçalama işlemi de oluşturma ile aynı kullanım kolaylığı ile gerçekleştirilmektedir.
 
-#### Object Destructuring
-Destructuring is useful because it allows you to do in a single line, what would otherwise require multiple lines. Consider the following case:
+#### Nesne Parçalama
+Parçalama işlemi tek satırlık bir kod ile uygulanabildiği için kullanışlı ve kolaydır. Aşağıdaki örneği inceleyelim:
 
 ```ts
 var rect = { x: 0, y: 10, width: 15, height: 20 };
 
-// Destructuring assignment
+// Parçalama ifadesi
 var {x, y, width, height} = rect;
 console.log(x, y, width, height); // 0,10,15,20
 ```
-Here in the absence of destructuring you would have to pick off `x,y,width,height` one by one from `rect`.
+Eğer burada parçalama ifadesi olmasaydı, `x,y,width,height` değişkenlerini `rect` üzerinden teker teker çıkarırdık.
 
-To assign an extracted variable to a new variable name you can do the following:
+Çıkarılan değişkeni yeni bir değişkene atamak aşağıdaki şekilde gerçekleştirilir:
 
 ```ts
-// structure
+// oluşturma
 const obj = {"some property": "some value"};
 
-// destructure
+// parçalama
 const {"some property": someProperty} = obj;
 console.log(someProperty === "some value"); // true
 ```
 
-Additionally you can get *deep* data out of a structure using destructuring. This is shown in the following example:
+Buna ek olarak bir yapının *derin*lerindeki veriye erişmek için parçalama işleminden faydalanabilirsiniz. Aşağıdaki örneği inceleyelim:
 
 ```ts
 var foo = { bar: { bas: 123 } };
 var {bar: {bas}} = foo; // Effectively `var bas = foo.bar.bas;`
 ```
 
-#### Array Destructuring
-A common programming question: "How to swap two variables without using a third one?". The TypeScript solution:
+#### Dizi Parçalama
+Yaygın bir programlama sorusu: "İki değişkenin değeri üçüncü bir değişken kullanmadan nasıl değiştirilir?". TypeScript çözümü:
 
 ```ts
 var x = 1, y = 2;
 [x, y] = [y, x];
 console.log(x, y); // 2,1
 ```
-Note that array destructuring is effectively the compiler doing the `[0], [1], ...` and so on for you. There is no guarantee that these values will exist.
+Buradaki önemli nokta şu; derleyici dizi parçalamayı `[0], [1], ...` şeklinde yaptığından dolayı bu değerlerin var olduğunun bir garantisi bulunmuyor. 
 
-#### Array Destructuring with rest
-You can pick up any number of elements from the array and get *an array* of the remaining elements using array destructuring with rest.
+
+#### Dizi Parçalama ve Kalanlar
+Bir diziden istediğiniz sayıda elemanı alıp, kalanları da yine *bir dizi* formunda alabilirsiniz.
 
 ```ts
 var [x, y, ...remaining] = [1, 2, 3, 4];
 console.log(x, y, remaining); // 1, 2, [3,4]
 ```
 
-#### Array Destructuring with ignores
-You can ignore any index by simply leaving its location empty i.e. `, ,` in the left hand side of the assignment. For example:
+#### Dizi Parçalama ve Atlananlar
+Bir dizi içerisindeki elemanı atlamak için index değerini `, ,` şeklinde boş bırakarak örnekteki gibi ilerleyebilirsiniz:
+
 ```ts
 var [x, , ...remaining] = [1, 2, 3, 4];
 console.log(x, remaining); // 1, [3,4]
 ```
 
-#### JS Generation
-The JavaScript generation for non ES6 targets simply involves creating temporary variables, just like you would have to do yourself without native language support for destructuring e.g.
+#### JS Oluşturulması
+ES6 dışında kalan ortamda JavaScript oluşturulması basitçe geçici değişkenler ile genel uygulanan yaklaşımdaki gibi gerçekleştirilir.
 
 ```ts
 var x = 1, y = 2;
 [x, y] = [y, x];
 console.log(x, y); // 2,1
 
-// becomes //
+// aşağıdaki gibi dönüştürülür //
 
 var x = 1, y = 2;
 _a = [y,x], x = _a[0], y = _a[1];
@@ -87,5 +90,5 @@ console.log(x, y);
 var _a;
 ```
 
-#### Summary
-Destructuring can make your code more readable and maintainable by reducing the line count and making the intent clear. Array destructuring can allow you to use arrays as though they were tuples.
+#### Özet
+Parçalama yaklaşımı, yazılan kod miktarını azaltarak, kod okunabilirliğini arttırır ve bakımını kolaylaştırır. Dizi parçalama işlemi de dizileri birer `tuple` gibi kullanılmasına olanak sağlar.

From 0cac5ecaa119799c07030e4c0eeec81c165d6b34 Mon Sep 17 00:00:00 2001
From: ozgend <revolter00@gmail.com>
Date: Mon, 3 Apr 2017 14:38:53 +0300
Subject: [PATCH 56/74] ceviri duzenleme

---
 docs/destructuring.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/destructuring.md b/docs/destructuring.md
index 4d8447776..e6301082b 100644
--- a/docs/destructuring.md
+++ b/docs/destructuring.md
@@ -44,7 +44,7 @@ Buna ek olarak bir yapının *derin*lerindeki veriye erişmek için parçalama i
 
 ```ts
 var foo = { bar: { bas: 123 } };
-var {bar: {bas}} = foo; // Effectively `var bas = foo.bar.bas;`
+var {bar: {bas}} = foo; // Etkin olarak `var bas = foo.bar.bas;`
 ```
 
 #### Dizi Parçalama

From 28e9f03d65e1555714b99938b6757a04b044c4ca Mon Sep 17 00:00:00 2001
From: Murat Mustafa Dinler <mustafadinler@users.noreply.github.com>
Date: Wed, 5 Apr 2017 10:17:56 +0300
Subject: [PATCH 57/74] Update destructuring.md

---
 docs/destructuring.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/destructuring.md b/docs/destructuring.md
index e6301082b..519ed1b7a 100644
--- a/docs/destructuring.md
+++ b/docs/destructuring.md
@@ -1,4 +1,4 @@
-### Parçalama (*destructing*)
+### Parçalama (*destructuring*)
 
 TypeScript aşağıda yer alan parçalama biçimlerini destekler:
 

From 80b9cc540628efb68e5159f637ed44c69ab47584 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Thu, 11 May 2017 10:12:58 +0300
Subject: [PATCH 58/74] =?UTF-8?q?#59=20Project=20=C3=A7evirisi?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/project/project.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/project/project.md b/docs/project/project.md
index 35ac052ca..c0b82e02a 100644
--- a/docs/project/project.md
+++ b/docs/project/project.md
@@ -1,3 +1,3 @@
-# Project
+# Proje
 
-To create a successful project using TypeScript you need to understand the various project organization language features available. In this section we will cover "compilation context", declaration spaces and modules.
+TypeScript kullanarak başarılı bir proje oluşturmak için, mevcut olan çeşitli proje organizasyonu dil özelliklerini anlamanız gerekir. Bu bölümde, "derleme ortamı(compilation context)", deklarasyon alanları ve modülleri ele alacağız.

From fc043cd3e16564afa1b8d1f70320240d4a1c4946 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Thu, 11 May 2017 12:55:27 +0300
Subject: [PATCH 59/74] =?UTF-8?q?#59=20Project=20=C3=A7evirisi=20d=C3=BCze?=
 =?UTF-8?q?ltme?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/project/project.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/project/project.md b/docs/project/project.md
index c0b82e02a..79a326492 100644
--- a/docs/project/project.md
+++ b/docs/project/project.md
@@ -1,3 +1,3 @@
 # Proje
 
-TypeScript kullanarak başarılı bir proje oluşturmak için, mevcut olan çeşitli proje organizasyonu dil özelliklerini anlamanız gerekir. Bu bölümde, "derleme ortamı(compilation context)", deklarasyon alanları ve modülleri ele alacağız.
+TypeScript kullanarak başarılı bir proje oluşturmak için,proje organizasyonunun daha iyi olmasını sağlayan Typescript özelliklerini iyi anlamak gerekir. Bu bölümde, "derleme ortamı(compilation context)", deklarasyon alanları ve modülleri ele alacağız.

From 904b088613142fb6f2437d3fa6ecf8038ccc3951 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Thu, 11 May 2017 16:35:19 +0300
Subject: [PATCH 60/74] =?UTF-8?q?#54=20Which=20files=3F=20=C3=A7evirisi?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/project/files.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/project/files.md b/docs/project/files.md
index d20ffb31e..1cde79d51 100644
--- a/docs/project/files.md
+++ b/docs/project/files.md
@@ -1,6 +1,6 @@
-## Which files?
+## Hangi dosyalar?
 
-You can either use `files` to be explicit:
+Açık olarak ifade edebilmek için iki şekilde `files` kullanabilirsiniz:
 
 ```json
 {
@@ -10,7 +10,7 @@ You can either use `files` to be explicit:
 }
 ```
 
-or `include` and `exclude` to specify files. e.g.
+veya `include` ve `exclude` ile dosyaları belirtebilirsiniz. Örneğin,
 
 
 ```json
@@ -25,7 +25,7 @@ or `include` and `exclude` to specify files. e.g.
 }
 ```
 
-Some notes:
+Birkaç not:
 
-* if `files` are specified other options are ignored
-* `**/*` (e.g. sample usage `somefolder/**/*`) means all folder and any files (the extensions `.ts`/`.tsx` will be included and even `.js`/`.jsx` if `allowJs` is true)
+* eğer `files` belirtildiyse diğer seçenekler yok sayılır
+* `**/*` (örnek kullanımı `somefolder/**/*`) bütün klasörler ve bazı dosyalar anlamına gelir (`.ts`/`.tsx` dosya uzantıları dahil olacaktır ve eğer `allowJs` true ise `.js`/`.jsx` uzantıları bile bu uzantılara dahil olacaktır)

From 2ca92dae79a21afdb3796639b518e3545cb74db2 Mon Sep 17 00:00:00 2001
From: mustafadinler <m.mustafadinler@gmail.com>
Date: Fri, 12 May 2017 09:38:43 +0300
Subject: [PATCH 61/74] =?UTF-8?q?#51=20Compilation=20Context=20=C3=A7eviri?=
 =?UTF-8?q?si=20ve=20project.md=20dosyas=C4=B1nda=20de=C4=9Fi=C5=9Fiklik?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/project/compilation-context.md | 4 ++--
 docs/project/project.md             | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/project/compilation-context.md b/docs/project/compilation-context.md
index 4d2a555df..0e4670ee7 100644
--- a/docs/project/compilation-context.md
+++ b/docs/project/compilation-context.md
@@ -1,2 +1,2 @@
-## Compilation Context
-The compilation context is basically just a fancy term for grouping of the files that TypeScript will parse and analyze to determine what is valid and what isn't. Along with the information about which files, the compilation context contains information about *which compiler options*. A great way to define this logical grouping (we also like to use the term *project*) is using a `tsconfig.json` file.
+## Derleme İçerigi (Compilation Context) 
+Derleme içeriği temelde, TypeScript'in ayrıştırılacak ve analiz edilecek dosyaların gruplandırılması için neyin geçerli, neyin olmadığını belirlemek için basit bir terimdir. Hangi dosyalarla ilgili olduğu bilgisinin yanısıra, derleme içeriği *hangi derleyici seçenekleri*'nin kullanıldığı hakkında bilgi içerir. Bu mantıksal gruplamayı tanımlamanın en harika yolu `tsconfig.json` dosyası kullanmaktır (biz *project* terimini kullanmayı da seviyoruz).
diff --git a/docs/project/project.md b/docs/project/project.md
index 79a326492..0fd154bf6 100644
--- a/docs/project/project.md
+++ b/docs/project/project.md
@@ -1,3 +1,3 @@
 # Proje
 
-TypeScript kullanarak başarılı bir proje oluşturmak için,proje organizasyonunun daha iyi olmasını sağlayan Typescript özelliklerini iyi anlamak gerekir. Bu bölümde, "derleme ortamı(compilation context)", deklarasyon alanları ve modülleri ele alacağız.
+TypeScript kullanarak başarılı bir proje oluşturmak için,proje organizasyonunun daha iyi olmasını sağlayan Typescript özelliklerini iyi anlamak gerekir. Bu bölümde, "derleme içeriği(compilation context)", deklarasyon alanları ve modülleri ele alacağız.

From 1c00f1c1f02d4f2fa0ddbccd97d7f59b14c5c581 Mon Sep 17 00:00:00 2001
From: Murat Mustafa Dinler <m.mustafadinler@gmail.com>
Date: Tue, 16 May 2017 01:02:39 +0300
Subject: [PATCH 62/74] Declaration Spaces #52 cevirisi yapildi

---
 docs/project/declarationspaces.md | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/docs/project/declarationspaces.md b/docs/project/declarationspaces.md
index cf1d4ed2a..4fd5abcf1 100644
--- a/docs/project/declarationspaces.md
+++ b/docs/project/declarationspaces.md
@@ -1,16 +1,16 @@
-## Declaration Spaces
+## Deklarasyon Alanları
 
-There are two declaration spaces in TypeScript: The *variable* declaration space and the *type* declaration space. These concepts are explored below.
+TypeScript'te iki deklarasyon alanı vardır: *variable (değişken)* deklarasyon alanı ve *type (tip)* deklarasyon alanı. Bu konseptler aşağıda incelenmiştir.
 
-### Type Declaration Space
-The type declaration space contains stuff that can be used as a type annotation. E.g the following are a few type declarations:
+### Type (Tip) Deklarasyon Alanı
+Type (tip) deklarasyon alanı, tip belirteci olarak kullanılabilecek öğeleri içerir. Aşağıdakiler birkaç tip deklarasyona örnektir:
 
 ```ts
 class Foo { }
 interface Bar { }
 type Bas = {}
 ```
-This means that you can use `Foo`, `Bar`, `Bas` etc. as a type annotation. E.g.:
+Bunun anlamı `Foo`, `Bar`, `Bas` vb. tip belirteci olarak kullanabilirsiniz. Örneğin:
 
 ```ts
 var foo: Foo;
@@ -18,31 +18,31 @@ var bar: Bar;
 var bas: Bas;
 ```
 
-Notice that even though you have `interface Bar`, *you can't use it as a variable* because it doesn't contribute to the *variable declaration space*. This is shown below:
+Dikkat edin `interface Bar`'a sahip olsanız bile *onu değişken olarak kullanamazsınız*, çünkü o *variable (değişken) deklarasyon alanında* tanımlanıp aktarılamamış. Aşağıdaki örnekte gösterilmiştir:
 
 ```ts
 interface Bar {};
 var bar = Bar; // ERROR: "cannot find name 'Bar'"
 ```
 
-The reason why it says `cannot find name` is because the name `Bar` *is not defined* in the *variable* declaration space. That brings us to the next topic "Variable Declaration Space".
+`cannot find name (isim bulunamıyor)` demesinin sebebi ise, `Bar` isminin *variable (değişken)* deklarasyon alanında *tanımlanmamış* olmasıdır. Bu bizi bir sonraki "Variable (Değişken) Deklarasyon Alanı" konusuna götürüyor.
 
-### Variable Declaration Space
-The variable declaration space contains stuff that you can use as a variable. We saw that having `class Foo` contributes a type `Foo` to the *type* declaration space. Guess what?, it also contributes a *variable* `Foo` to the *variable* declaration space as shown below:
+### Variable (Değişken) Deklarasyon Alanı
+Variable (değişken) deklarasyon alanı, değişken belirteci olarak kullanılabilecek öğeleri içerir. `class Foo`'nun tip `Foo` olarak tanımlanıp *tip* deklarasyon alanına aktarılabildiğini gördük. Tahmin edin?, *değişken* `Foo` aynı zamanda *variable (değişken)* deklarasyon alanına aşağıda gösterildiği gibi tanımlanıp aktarıldı:
 
 ```ts
 class Foo { }
 var someVar = Foo;
 var someOtherVar = 123;
 ```
-This is great as sometimes you want to pass classes around as variables. Remember that
+Bazen sınıfları değişkenler olarak aktarmak istediğimiz için bu harika. Şunu hatırlayın
 
-* We couldn't use something like an `interface` that is *only* in the *type* declaration space as a variable.
+* *Sadece* *tip* deklarasyon alanındaki `interface (arayüz)` gibi şeyleri bir değişken olarak kullanamadık.
 
-Similarly something that you declare with `var`, is *only* in the *variable* declaration space and cannot be used as a type annotation:
+`var` olarak tanımladığınız birşey benzer olarak, *sadece* *variable (değişken)* deklarasyon alanı içerisinde olabilir ve tip belirteci olarak kullanılamaz:
 
 ```ts
 var foo = 123;
 var bar: foo; // ERROR: "cannot find name 'foo'"
 ```
-The reason why it says `cannot find name` is because the name `foo` *is not defined* in the *type* declaration space.
+`cannot find name (isim bulunamıyor)` demesinin sebebi ise, `foo` isminin *type (tip)* deklarasyon alanında *tanımlanmamış* olmasıdır.

From 0952912d2344b0888b720e518064cf9e299696c6 Mon Sep 17 00:00:00 2001
From: Mert Susur <mail@mertsusur.com>
Date: Thu, 18 May 2017 14:19:15 +0100
Subject: [PATCH 63/74] Linklere codefiction ekledim

---
 README.md | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 8b4025b6a..3f4cdf4e6 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,9 @@ TypeScript'e Derin Dalış
 
 [![Chat kanalına katılın https://gitter.im/codefiction/typescript-book](https://badges.gitter.im/codefiction/typescript-book.svg)](https://gitter.im/codefiction/typescript-book?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-Typescript kullanılırken genel olarak karşılaşılan hatalarla ilgilenmekteyim. Bu çalışma [StackOverflow](http://stackoverflow.com/tags/typescript/topusers) / [DefinitelyTyped](https://github.com/DefinitelyTyped/) ve [TypeScript community](https://github.com/TypeStrong/) komünitesine bağlı kaynaklar üzerine kuruludur. [Güncellemeleri takip edebilirsiniz](https://twitter.com/basarat) ve [Github'da ★'lamayı unutmayın' ](https://github.com/basarat/typescript-book) 🌹
+Typescript kullanılırken genel olarak karşılaşılan hatalarla ilgilenmekteyim. Bu çalışma [StackOverflow](http://stackoverflow.com/tags/typescript/topusers) / [DefinitelyTyped](https://github.com/DefinitelyTyped/) ve [TypeScript community](https://github.com/TypeStrong/) komünitesine bağlı kaynaklar üzerine kuruludur.
+
+[Github'da ★'lamayı unutmayın' ](https://github.com/Codefiction/typescript-book)
 
 ## Yorumlar
 
@@ -26,19 +28,19 @@ Typescript kullanılırken genel olarak karşılaşılan hatalarla ilgilenmektey
 * numTimesPointedPeopleToBasaratsTypeScriptBook++; ([link](https://twitter.com/brocco/status/814227741696462848))
 
 ## Başlamak için
-Kitabı okumaya [buradan başlayabilirsiniz](http://basarat.gitbooks.io/typescript/content/docs/getting-started.html).
+Kitabı okumaya [buradan başlayabilirsiniz](https://codefiction.gitbooks.io/typescript-kitabi/content).
 
 ## Diğer seçenekler
 Aşağıdakilerden birini indirebilirsiniz
-* [iPad,iPhone,Mac için EPUB](https://www.gitbook.com/download/epub/book/basarat/typescript)
-* [Windows ve diğerleri için PDF](https://www.gitbook.com/download/pdf/book/basarat/typescript)
-* [Kindle için MOBI](https://www.gitbook.com/download/mobi/book/basarat/typescript)
+* [iPad,iPhone,Mac için EPUB](https://www.gitbook.com/download/epub/book/codefiction/typescript)
+* [Windows ve diğerleri için PDF](https://www.gitbook.com/download/pdf/book/codefiction/typescript)
+* [Kindle için MOBI](https://www.gitbook.com/download/mobi/book/codefiction/typescript)
 
 ## Teşekkürler
-[Katkıda bulunan herkese](https://github.com/basarat/typescript-book/graphs/contributors) 🌹
+[Katkıda bulunan herkese](https://github.com/Codefiction/typescript-book/graphs/contributors) 🌹
 
 ## Paylaşın
-Adres: http://basarat.gitbooks.io/typescript/
+Adres: https://codefiction.gitbooks.io/typescript-kitabi/content/
 
 ## Türkçe Çeviri
 Kitabın Türkçe Çevirisi [Codefiction](https://github.com/Codefiction) tarafından yapılmıştır.

From dfd096c7f12ebe75e5d1bca2ba663e30d9529a50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mikail=20=C5=9Eeremet?= <mikail.seremet@gmail.com>
Date: Wed, 12 Apr 2017 10:33:57 +0300
Subject: [PATCH 64/74] Update browser.md

---
 docs/quick/browser.md | 59 +++++++++++++++++++++++++------------------
 1 file changed, 35 insertions(+), 24 deletions(-)

diff --git a/docs/quick/browser.md b/docs/quick/browser.md
index e8cbf52ee..892a7a6d5 100644
--- a/docs/quick/browser.md
+++ b/docs/quick/browser.md
@@ -1,17 +1,17 @@
-# TypeScript in the browser
-If you are using TypeScript to create a web application here are my recommendations:
+# Tarayıcıda TypeScript
+Web uygulaması yaratmak için TypeScript kullanıyorsanız önereceklerim şunlardır:
 
-## General Machine Setup
+## Genel Makine Kurulumu
 
-* Install [NodeJS](https://nodejs.org/en/download/)
+* [NodeJS](https://nodejs.org/en/download/) yüklenir.
 
-## Project Setup
-* Create a project dir
+## Proje Kurulumu
+* Proje yolu oluşturulur.
 ```
-mkdir your-project
-cd your-project
+mkdir proje-adi
+cd proje-adi
 ```
-* Create `tsconfig.json`. We discuss [modules here](../project/external-modules.md). Also good to have it setup for `tsx` compilation out of the box.
+* `tsconfig.json` dosyası oluşturulur. Modüllerden [burada](../project/external-modules.md) bahsedilmektedir. Bunu oluşturmanın başka bir nedeni de 'tsx' derlemesinde gerekli olduğu içindir.
 ```json
 {
     "compilerOptions": {
@@ -26,19 +26,19 @@ cd your-project
     "compileOnSave": false
 }
 ```
-* Create an npm project:
+* Npm projesi oluşturulur:
 ```
 npm init -y
 ```
-* Install TypeScript-nightly, webpack, [`ts-loader`](https://github.com/TypeStrong/ts-loader/), typings
+* TypeScript-nightly, webpack, [`ts-loader`](https://github.com/TypeStrong/ts-loader/), typings yüklenir.
 ```
 npm install typescript@next webpack ts-loader typings --save-dev
 ```
-* Init typings (creates a `typings.json` file for you).
+* Typings başlatılır. (Bir `typings.json` dosyası yaratır.).
 ```
 "./node_modules/.bin/typings" init
 ```
-* Create a `webpack.config.js` to bundle your modules into a single `bundle.js` file that contains all your resources:
+* Tüm kaynaklarınızı içeren tek bir `bundle.js` dosyasına modüllerinizi paketlemek için` webpack.config.js` dosyası oluşturulur: 
 ```js
 module.exports = {
     entry: './src/app.tsx',
@@ -58,7 +58,7 @@ module.exports = {
     }
 }
 ```
-* Setup an npm script to run a build. Also have it run `typings install` on `npm install`. In your `package.json` add a `script` section:
+* Bir yapı çalıştırmak için bir npm komut dosyası kurun. Ayrıca `npm install` üzerinde` typings install` çalıştırın. `Package.json` dosyanıza` script` bölümü ekleyin:
 ```json
 "scripts": {
     "prepublish": "typings install",
@@ -66,16 +66,27 @@ module.exports = {
 },
 ```
 
-Now just run the following (in the directory that contains `webpack.config.js`):
+Şimdi sadece bu komutu çalıştırın. (`webpack.config.js`'nin olduğu konumunda çalıştırılması gerekir):
 
 ```
 npm run watch
 ```
 
-Now if you make edits to your `ts` or `tsx` file webpack will generate `bundle.js` for you. Serve this up using your web server 🌹.
+Şimdi eğer `ts` veya `tsx` dosyasında değişiklik yaparsanız webpack sizin için `bundle.js` dosyası oluşuturacaktır. Web sunucunuz ile bunu sunabilirsiniz.
 
+<<<<<<< HEAD
+<<<<<<< HEAD
 ## More
 If you are going to use React (which I highly recommend you give a look), here are a few more steps:
+=======
+## Fazlası
+Eğer React kullanacaksanız (ki ben kesinlikle bir bakmanızı tavsiye ediyorum) yapılacak bir kaç adım daha var:
+>>>>>>> 8da1b01... Update browser.md
+=======
+## Fazlası
+If you are going to use React (which I highly recommend you give a look), here are a few more steps:
+Eğer React kullanacaksanız (ki ben kesinlikle bir bakmanızı tavsiye ediyorum) yapılacak bir kaç adım daha var:
+>>>>>>> b542eec... Update browser.md
 
 ```
 npm install react react-dom --save-dev
@@ -89,7 +100,7 @@ npm install react react-dom --save-dev
 "./node_modules/.bin/typings" install dt~react-dom --global --save
 ```
 
-A demo `index.html`:
+Demo olarak `index.html`:
 ```
 <html>
     <head>
@@ -104,7 +115,7 @@ A demo `index.html`:
     </body>
 </html>
 ```
-A demo `./src/app.tsx`
+Demo olarak `./src/app.tsx`
 ```ts
 import * as React from "react";
 import * as ReactDOM from "react-dom";
@@ -124,13 +135,13 @@ ReactDOM.render(
 );
 ```
 
-You can clone this demo project here : https://github.com/basarat/react-typescript
+Bu demo projeyi buradan klonlayabilirsiniz : https://github.com/basarat/react-typescript
 
-## Live reload
+## Canlı Yeniden Yükleme (Live Reload)
 
-Add webpack dev server. Super easy: 
+Kolaylıkla webpack developer sunucusu eklenir: 
 
-* Install : `npm install webpack-dev-server` 
-* Add to your `package.json`: `"start":"webpack-dev-server --hot --inline --no-info --content-base ./build"`
+* Yükleme : `npm install webpack-dev-server` 
+* `package.json` içine ekleme : `"start":"webpack-dev-server --hot --inline --no-info --content-base ./build"`
 
-Now when you run `npm start` it will start the webpack dev server with live reload.
+Şimdi `npm start`komutunu çalıştırınca bu artık canlı yeniden yükleme işini yapabilen webpack dev sunucusunu başlatacaktır.

From 2e76775ead4e40deef1ac835de77b9cb6ede50a4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mikail=20=C5=9Eeremet?= <mikail.seremet@gmail.com>
Date: Mon, 22 May 2017 20:33:10 +0300
Subject: [PATCH 65/74] Update browser.md

Cakismayi giderdim sanirim. Bir kontrol edilirse iyi olur.
---
 docs/quick/browser.md | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/docs/quick/browser.md b/docs/quick/browser.md
index 892a7a6d5..b84fdf0f7 100644
--- a/docs/quick/browser.md
+++ b/docs/quick/browser.md
@@ -74,19 +74,9 @@ npm run watch
 
 Şimdi eğer `ts` veya `tsx` dosyasında değişiklik yaparsanız webpack sizin için `bundle.js` dosyası oluşuturacaktır. Web sunucunuz ile bunu sunabilirsiniz.
 
-<<<<<<< HEAD
-<<<<<<< HEAD
-## More
-If you are going to use React (which I highly recommend you give a look), here are a few more steps:
-=======
-## Fazlası
-Eğer React kullanacaksanız (ki ben kesinlikle bir bakmanızı tavsiye ediyorum) yapılacak bir kaç adım daha var:
->>>>>>> 8da1b01... Update browser.md
-=======
+
 ## Fazlası
-If you are going to use React (which I highly recommend you give a look), here are a few more steps:
 Eğer React kullanacaksanız (ki ben kesinlikle bir bakmanızı tavsiye ediyorum) yapılacak bir kaç adım daha var:
->>>>>>> b542eec... Update browser.md
 
 ```
 npm install react react-dom --save-dev

From 376316dc1e149a77dff2b7486cde33c688589b06 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mikail=20=C5=9Eeremet?= <mikail.seremet@gmail.com>
Date: Wed, 31 May 2017 00:45:34 +0300
Subject: [PATCH 66/74] Update browser.md

---
 docs/quick/browser.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/docs/quick/browser.md b/docs/quick/browser.md
index b84fdf0f7..00e0b11ee 100644
--- a/docs/quick/browser.md
+++ b/docs/quick/browser.md
@@ -74,7 +74,6 @@ npm run watch
 
 Şimdi eğer `ts` veya `tsx` dosyasında değişiklik yaparsanız webpack sizin için `bundle.js` dosyası oluşuturacaktır. Web sunucunuz ile bunu sunabilirsiniz.
 
-
 ## Fazlası
 Eğer React kullanacaksanız (ki ben kesinlikle bir bakmanızı tavsiye ediyorum) yapılacak bir kaç adım daha var:
 

From 0a5d451a6274616d506af7fda97734488f80714e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mikail=20=C5=9Eeremet?= <mikail.seremet@gmail.com>
Date: Wed, 31 May 2017 00:49:38 +0300
Subject: [PATCH 67/74] Update browser.md

---
 docs/quick/browser.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/quick/browser.md b/docs/quick/browser.md
index 00e0b11ee..dc5b141db 100644
--- a/docs/quick/browser.md
+++ b/docs/quick/browser.md
@@ -11,7 +11,7 @@ Web uygulaması yaratmak için TypeScript kullanıyorsanız önereceklerim şunl
 mkdir proje-adi
 cd proje-adi
 ```
-* `tsconfig.json` dosyası oluşturulur. Modüllerden [burada](../project/external-modules.md) bahsedilmektedir. Bunu oluşturmanın başka bir nedeni de 'tsx' derlemesinde gerekli olduğu içindir.
+* `tsconfig.json` dosyası oluşturulur. Modülleri [ayrıca](../project/external-modules.md) tartışacağız. Bunu oluşturmanın başka bir nedeni de 'tsx' derlemesinde gerekli olduğu içindir.
 ```json
 {
     "compilerOptions": {
@@ -34,7 +34,7 @@ npm init -y
 ```
 npm install typescript@next webpack ts-loader typings --save-dev
 ```
-* Typings başlatılır. (Bir `typings.json` dosyası yaratır.).
+* Typings başlatılır (sizin için bir typings.json dosyası yaratır).
 ```
 "./node_modules/.bin/typings" init
 ```
@@ -75,7 +75,7 @@ npm run watch
 Şimdi eğer `ts` veya `tsx` dosyasında değişiklik yaparsanız webpack sizin için `bundle.js` dosyası oluşuturacaktır. Web sunucunuz ile bunu sunabilirsiniz.
 
 ## Fazlası
-Eğer React kullanacaksanız (ki ben kesinlikle bir bakmanızı tavsiye ediyorum) yapılacak bir kaç adım daha var:
+Eğer React kullanacaksanız (ki ben kesinlikle bir bakmanızı tavsiye ediyorum) yapılacak birkaç adım daha var:
 
 ```
 npm install react react-dom --save-dev

From d3574543b80db46e696cdbab3dc3e4fd810d035b Mon Sep 17 00:00:00 2001
From: Onur Aykac <onuraykac@gmail.com>
Date: Sun, 10 Sep 2017 03:24:04 +0800
Subject: [PATCH 68/74] =?UTF-8?q?Uyulmas=C4=B1=20gereken=20T=C3=BCrk=C3=A7?=
 =?UTF-8?q?e=20imla=20kurallar=C4=B1na=20dair.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 IMLAKURALLARI.md | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 IMLAKURALLARI.md

diff --git a/IMLAKURALLARI.md b/IMLAKURALLARI.md
new file mode 100644
index 000000000..0fbba0004
--- /dev/null
+++ b/IMLAKURALLARI.md
@@ -0,0 +1,10 @@
+# Kısaca, Türkçe dil kuralları üzerine
+## Noktalama işaretleri
+* Nokta, virgül, soru işareti, ünlem, noktalı virgül, iki nokta üst üste gibi noktalama işaretlerinden sonra boşluk bırakılır. Öncesinde bir boşluk olmamalıdır.
+* Parantez içinde yazılacak ifade, parantez işaretlerine bitişiktir. İlk parantezden önce boşluk ve sonra parantezden sonra bir boşluk bırakılmalıdır. Örn: Typescript çok güzel (bana göre) bir dildir.
+* Nokta, iki nokta üst üste, soru işareti ve ünlem işaretinden sonraki kelimelerin baş harfi büyük olmalıdır.
+
+## Çeviri
+http://tureng.com/
+https://translate.google.com/
+Deyimler ve teknik terimlerin çevirimi noktasında yardımcı olabilir.
\ No newline at end of file

From ce2b7a8bd7ac98b516ffe75939969b7b8a4e31be Mon Sep 17 00:00:00 2001
From: Onur Aykac <onuraykac@gmail.com>
Date: Sun, 10 Sep 2017 03:24:46 +0800
Subject: [PATCH 69/74] =?UTF-8?q?Birka=C3=A7=20referans=20eklendi.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 GLOSSARY.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/GLOSSARY.md b/GLOSSARY.md
index af4f169e5..4bf9e398a 100644
--- a/GLOSSARY.md
+++ b/GLOSSARY.md
@@ -22,6 +22,9 @@ Fakat bazı terimlerin Türkçe çevrimi, cümleyi anlamsız bir hale getirebilm
 | Escape character (`\`) | Kaçış karakteri |
 | Inheritance | Kalıtım |
 | Callback | Geri çağırım |
+| Optional | İsteğe bağlı | 
+| Type | Tip |
+| Engine | Motor |
 
 # Terim açıklamaları
 * Duck Typing: Eğer bir ördek gibi yürüyor ve bir ördek gibi "vak"lıyorsa, o zaman bu bir ördektir. Bir nesne yapısal olarak tüm üyelere sahipse, diğer şeylerin de (ne olduğu önemli değil) var olduğu kabul edilir.

From 26ca091507aa209cc3d8ec0bdadba3db8c10eeb4 Mon Sep 17 00:00:00 2001
From: Onur Aykac <onuraykac@gmail.com>
Date: Sun, 10 Sep 2017 03:26:28 +0800
Subject: [PATCH 70/74] =?UTF-8?q?Biti=C5=9Fik=20ya=20da=20ayr=C4=B1=20yaz?=
 =?UTF-8?q?=C4=B1mlar?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 IMLAKURALLARI.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/IMLAKURALLARI.md b/IMLAKURALLARI.md
index 0fbba0004..2ef07aed3 100644
--- a/IMLAKURALLARI.md
+++ b/IMLAKURALLARI.md
@@ -4,6 +4,12 @@
 * Parantez içinde yazılacak ifade, parantez işaretlerine bitişiktir. İlk parantezden önce boşluk ve sonra parantezden sonra bir boşluk bırakılmalıdır. Örn: Typescript çok güzel (bana göre) bir dildir.
 * Nokta, iki nokta üst üste, soru işareti ve ünlem işaretinden sonraki kelimelerin baş harfi büyük olmalıdır.
 
+## "Ayrı mı yazmalıyım bitişik mi?"
+* Hiçbir şey
+* Birkaç
+* Bir şey
+* Bir kez
+
 ## Çeviri
 http://tureng.com/
 https://translate.google.com/

From 2a043e4a8e614935ceadbe451d3836f5acfdf654 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Atar?= <ugur.atar@metry.io>
Date: Sun, 24 Sep 2017 01:11:57 +0200
Subject: [PATCH 71/74] =?UTF-8?q?Namespace=20=C3=A7evirisi?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

closes CodeFiction/typescript-book#58
---
 docs/project/namespaces.md | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/docs/project/namespaces.md b/docs/project/namespaces.md
index 3b5e3a7d6..5151ff02d 100644
--- a/docs/project/namespaces.md
+++ b/docs/project/namespaces.md
@@ -1,5 +1,5 @@
-## Namespaces
-Namespaces provide you with a convenient syntax around a common pattern used in JavaScript:
+## Aduzayları (Namespaces)
+Aduzayları, JavaScript'te kullanılan yaygın bir kalıp için uygun sözdizimi sağlar:  
 
 ```ts
 (function(something) {
@@ -8,8 +8,9 @@ Namespaces provide you with a convenient syntax around a common pattern used in
 
 })(something || something = {})
 ```
+Basit olarak anlatmak gerekirse `something || something = {}` ifadesi, anonim fonksiyonun *varolan bir nesneye eklenti yapmasını* (`something ||` kısmı) veya *yeni bir obje yaratarak yaratılan bu yeni objeye eklenti yapılmasına* (`|| something = {}` kısmı) imkan tanır.
+Bunun anlamı şudur, bir çalıştırma sınırıyla ayrılmış iki farklı kod bloğuna sahip olabilirsiniz:
 
-Basically `something || something = {}` allows an anonymous function `function(something) {}` to *add stuff to an existing object* (the `something ||` portion) or *start a new object then add stuff to that object* (the `|| something = {}` portion). This means that you can have two such blocks split by some execution boundary :
 
 ```ts
 (function(something) {
@@ -29,8 +30,7 @@ console.log(something); // {foo:123}
 console.log(something); // {foo:123, bar:456}
 
 ```
-
-This is commonly used in  the JavaScript land for making sure that stuff doesn't leak into the global namespace. With file based modules you don't need to worry about this, but the pattern is still useful for *logical grouping* of a bunch of functions. Therefore TypeScript provides the `namespace` keyword to group these e.g.
+Javascript'te bunun en yaygın kullanım amacı global(küresel) aduzayına bilgi sızmasını önlemektir. Dosya tabanlı modüller kullanıldığında bu konu hakkında endişe etmenize gerek olmamakla birlikte, bu kalıp fonksiyonlarınızı *mantıksal olarak gruplamak* için oldukça kullanışlıdır. Bu tip gruplamaları yapabilmeniz için TypeScript `namespace` anahtar kelimesini sunmaktadır. Ör:
 
 ```ts
 namespace Utility {
@@ -46,7 +46,7 @@ namespace Utility {
 Utility.log('Call me');
 Utility.error('maybe!');
 ```
-The `namespace` keyword generates the same JavaScript that we saw earlier:
+`namespace` anahtar kelimesi ilk bölümde gördüğümüz JavaScript kodunun aynısını üretmektedir.
 
 ```ts
 (function (Utility) {
@@ -55,7 +55,6 @@ The `namespace` keyword generates the same JavaScript that we saw earlier:
 
 })(Utility || (Utility = {}));
 ```
+Bir diğer nokta ise, uzayadları iç içe geçebilirler, bu sayede `namespace Utility.Messaging` gibi bir ifadeyle `Messaging` uzayadını `Utility` uzayadının içine tanımlamak mümkün olmaktadır.
 
-One thing to note is that namespaces can be nested so you can do stuff like `namespace Utility.Messaging` to nest a `Messaging` namespace under `Utility`.
-
-For most projects we recommend using external modules and using `namespace` for quick demos and porting old JavaScript code.
+Örnek proje oluştururken veya eski JavaScript kodunu port ederken  harici modül ve `namespace` kullanımı tavsiye edilmektedir.

From c2b6d6f98f22d28bb3913c8d1df26db41494f2f8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Atar?= <ugur.atar@metry.io>
Date: Sun, 24 Sep 2017 01:18:21 +0200
Subject: [PATCH 72/74] Update namespaces.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Namespaces kısımındaki çeviri hatalarının düzeltilmesi.
---
 docs/project/namespaces.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/project/namespaces.md b/docs/project/namespaces.md
index 5151ff02d..b13f84e7c 100644
--- a/docs/project/namespaces.md
+++ b/docs/project/namespaces.md
@@ -55,6 +55,6 @@ Utility.error('maybe!');
 
 })(Utility || (Utility = {}));
 ```
-Bir diğer nokta ise, uzayadları iç içe geçebilirler, bu sayede `namespace Utility.Messaging` gibi bir ifadeyle `Messaging` uzayadını `Utility` uzayadının içine tanımlamak mümkün olmaktadır.
+Bir diğer nokta ise, aduzaylarının iç içe geçebiliyor olmalarıdır, bu sayede `namespace Utility.Messaging` gibi bir ifadeyle `Messaging` aduzayını `Utility` aduzayının içerisinde tanımlamak mümkün olmaktadır.
 
 Örnek proje oluştururken veya eski JavaScript kodunu port ederken  harici modül ve `namespace` kullanımı tavsiye edilmektedir.

From 4a17539fcf6c478c25ba3a1f84222f6489484d57 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Atar?= <ugur.atar@metry.io>
Date: Sun, 24 Sep 2017 11:14:49 +0200
Subject: [PATCH 73/74] Update GLOSSARY.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Namespace -> Aduzayı eklendi
---
 GLOSSARY.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GLOSSARY.md b/GLOSSARY.md
index 4bf9e398a..0bf09a2a6 100644
--- a/GLOSSARY.md
+++ b/GLOSSARY.md
@@ -25,6 +25,6 @@ Fakat bazı terimlerin Türkçe çevrimi, cümleyi anlamsız bir hale getirebilm
 | Optional | İsteğe bağlı | 
 | Type | Tip |
 | Engine | Motor |
-
+| Namespace | Aduzayı |
 # Terim açıklamaları
 * Duck Typing: Eğer bir ördek gibi yürüyor ve bir ördek gibi "vak"lıyorsa, o zaman bu bir ördektir. Bir nesne yapısal olarak tüm üyelere sahipse, diğer şeylerin de (ne olduğu önemli değil) var olduğu kabul edilir.

From 0c4faa6ca13bf31f32d6939c4b7c0f39d2f2cc78 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?U=C4=9Fur=20Atar?= <ugur.atar@metry.io>
Date: Sun, 24 Sep 2017 11:16:09 +0200
Subject: [PATCH 74/74] Update namespaces.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Whitespace temizliği.
---
 docs/project/namespaces.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/project/namespaces.md b/docs/project/namespaces.md
index b13f84e7c..ef4c60e07 100644
--- a/docs/project/namespaces.md
+++ b/docs/project/namespaces.md
@@ -57,4 +57,4 @@ Utility.error('maybe!');
 ```
 Bir diğer nokta ise, aduzaylarının iç içe geçebiliyor olmalarıdır, bu sayede `namespace Utility.Messaging` gibi bir ifadeyle `Messaging` aduzayını `Utility` aduzayının içerisinde tanımlamak mümkün olmaktadır.
 
-Örnek proje oluştururken veya eski JavaScript kodunu port ederken  harici modül ve `namespace` kullanımı tavsiye edilmektedir.
+Örnek proje oluştururken veya eski JavaScript kodunu port ederken harici modül ve `namespace` kullanılması tavsiye edilmektedir.
