diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
index 3f4ac88fc..fb6bad318 100644
--- a/1-js/01-getting-started/1-intro/article.md
+++ b/1-js/01-getting-started/1-intro/article.md
@@ -10,7 +10,7 @@ Bu dilde yazılan kod kümelerine betik denir. Doğrudan HTML kodu içerisine ya
 
 Komutlar herhangi bir derleme ve hazırlığa gereksinim duymadan doğrudan çalışırlar.
 
-Bu yönden bakınca JavaScript diğer dillere kıyasla oldukça farklıdır. Bkz: [Java](http://en.wikipedia.org/wiki/Java).
+Bu yönden bakınca JavaScript diğer dillere kıyasla oldukça farklıdır. Bkz: [Java](https://en.wikipedia.org/wiki/Java_(programming_language)).
 
 ```smart header="Neden <u>Java</u>Script?"
 JavaScript ilk yazıldığında, başka bir adı vardı: "LiveScript". Ancak Java dili o dönemlerde çok ünlü olduğundan dolayı yeni bir dil ve "küçük kardeş" gibi görünmesi açısından JavaScript olarak değiştirildi.
@@ -72,7 +72,7 @@ Bu engellemeleri şu biçimde sıralayabiliriz :
 
 - Farklı sekmeler birbiri ile iletişime geçemez ve bilgi alışverişi yapamazlar. Bazı sitelerde aynı sekmeler iletişimde bulunabilir, örneğin bir sekmeden JavaScript ile diğer sekmeyi açabilirsiniz. Bu durumda bile, bir sayfa diğerinden farklı alan adı, kural veya kapılarda ise erişemez.
 
-    Bu olaya "Same Origin Policy" (Aynı kaynak kuralı) denir. Bunu çözmek için *her iki sayfa* özel bir JavaScript kodu ile birbirlerini onaylamalıdır. Bu engellemeler yine kullanıcının güvenliği içindir. Kullanıcının açtığı `http://örnekyerlik.com` sitesi diğer sekmede bulunan `http://diğeryerlik.com` sitesinden bilgi çalamamalıdır.
+    Bu olaya "Same Origin Policy" (Aynı kaynak kuralı) denir. Bunu çözmek için *her iki sayfa* özel bir JavaScript kodu ile birbirlerini onaylamalıdır. Bu engellemeler yine kullanıcının güvenliği içindir. Kullanıcının açtığı `http://örnekyerlik.com` sitesi diğer sekmede bulunan `http://gmail.com` sitesinden bilgi çalamamalıdır.
 - JavaScript kolayca bulunduğu sayfadan veri alabilir. Ancak başka site veya alan adlarından veri alması sorunludur. Olanaklı olmasına karşın her iki yanın onayı gereklidir. Yine, bunun nedeni güvenlik sınırlarıdır diyebiliriz.
 
 ![Sınırlamalar](limitations.svg)
diff --git a/1-js/01-getting-started/2-manuals-specifications/article.md b/1-js/01-getting-started/2-manuals-specifications/article.md
index 1c88cd3c2..779b2009b 100644
--- a/1-js/01-getting-started/2-manuals-specifications/article.md
+++ b/1-js/01-getting-started/2-manuals-specifications/article.md
@@ -13,7 +13,7 @@ Son taslağına <https://tc39.es/ecma262/> adresinden erişebilirsiniz.
 
 Daha geniş kitleler tarafından kullanılmayan yeni özelliklere ve önerilere <https://github.com/tc39/proposals> adresinden erişebilirsiniz.
 
-Ayrıca, tarayıcı için geliştirme yapıyorsanız, ikinci [second part](info:browser-environment) bölümünden farklı eğitimlere bakabilirsiniz.
+Ayrıca, tarayıcı için geliştirme yapıyorsanız, [ikinci bölümden](info:browser-environment) farklı eğitimlere bakabilirsiniz.
 
 ## Kılavuz
 
diff --git a/1-js/01-getting-started/4-devtools/article.md b/1-js/01-getting-started/4-devtools/article.md
index 0f19ec1dc..a0fcc82ec 100644
--- a/1-js/01-getting-started/4-devtools/article.md
+++ b/1-js/01-getting-started/4-devtools/article.md
@@ -22,13 +22,13 @@ Geliştirici araçları konsol paneliyle açılacaktır. Aşağıdaki ekranda il
 
 ![chrome](chrome.png)
 
-Chrome'un geliştirme aracı versiyona göre değişiklik gösterecektir. Fakat genel hatları itibariyle bu anda gördüğünüze benzeyecektir.
+Chrome'un geliştirme aracı versiyona göre değişiklik gösterecektir. Fakat genel hatları itibariyle şu anda gördüğünüze benzeyecektir.
 
 - Konsol panelinde kırmızı renk ile hatayı görebilirsiniz. Bu durumda kodunuz bilinmeyen "lalala" komutunda hata vermiş.
 
 - Sağ tarafında hatanın hangi satırda olduğunu görebilirsiniz. Bu alan tıklanabilirdir. Şu anda hata `bug.html:12`'de bulunmaktadır.
 
-Hatanın altında `>` sembolünü görebilirsiniz. Bu "komut satırı"'nı işaret eder. Komutunuzu yazdıktan sonra `key:Enter`'a basarak o satırdaki komutu çalıştırabilirsiniz. Birden fazla satır kod yazabilmek için ise `key:Shift+Enter` tuş kombinasyonunu kullanabilirsiniz.
+Hatanın altında `>` sembolünü görebilirsiniz. Bu, "komut satırı"'nı işaret eder. Komutunuzu yazdıktan sonra `key:Enter`'a basarak o satırdaki komutu çalıştırabilirsiniz. Birden fazla satır kod yazabilmek için ise `key:Shift+Enter` tuş kombinasyonunu kullanabilirsiniz.
 
 Başlangıç için hataları görmek yeterli olacaktır. Daha sonra geliştirme aracını <info:debugging-chrome> bölümünde derinlemesine öğreneceksiniz.
 
diff --git a/1-js/01-getting-started/index.md b/1-js/01-getting-started/index.md
index 881436b93..9727270f3 100644
--- a/1-js/01-getting-started/index.md
+++ b/1-js/01-getting-started/index.md
@@ -1,3 +1,3 @@
 # Giriş
 
-Bu bölümde JavaScript dilini ve geliştirmek için ortam hazırlamayı göreceksiniz.
+Bu bölümde JavaScript dilini ve geliştirmek için gereken ortamı hazırlamayı göreceksiniz.
diff --git a/1-js/02-first-steps/01-hello-world/article.md b/1-js/02-first-steps/01-hello-world/article.md
index 713fd2e78..6be617323 100644
--- a/1-js/02-first-steps/01-hello-world/article.md
+++ b/1-js/02-first-steps/01-hello-world/article.md
@@ -43,7 +43,7 @@ Sağ üst taraftaki "Play" ( Çalıştır ) butonuna basarak örneği çalışt
 
 ## Modern yazım
 
-Bu günlerde `<script>` etiketi genelde özellikler eklenmeden yazılmakta. Fakat eski kodlara baktınızda aşağıdaki gibi kodları görmek mümkündür:
+Bugünlerde `<script>` etiketi genelde özellikler eklenmeden yazılmakta. Fakat eski kodlara baktınızda aşağıdaki gibi kodları görmek mümkündür:
 
  `type` özelliği: <code>&lt;script <u>type</u>=...&gt;</code>
  : Eski HTML4 standardı script etiketi içerisinde tip gelirmeyi zorunlu kılıyordu. Genelde bu `type="text/javascript"` idi. Günümüzde ise HTML standartları `type` özelliğini varsayılan olarak kabul edebiliyor.
@@ -59,7 +59,7 @@ JavaScript kodundan önce ve sonra yazılan yorumlar. Çok eski JavaScript kitap
     //--></script>
     ```
 
-    Bu yorumların amacı <script> etiketini anlamayan tarayıcılarda JavaScript kodunun ekrana yazılmasını engellemektir. <br>Fakat artık neredeyse tüm tarayıcılar `<script>` etiketini anladıklarından bu konuda da bir sıkıntı bulunmamaktadır. <br>Eğer böyle bir kod bloğu görürseniz kod çok eski diyebilirsiniz.
+  Bu yorumların amacı `<script>` etiketini anlamayan tarayıcılarda JavaScript kodunun ekrana yazılmasını engellemektir. Fakat artık neredeyse tüm tarayıcılar `<script>` etiketini anladıklarından bu konuda da bir sıkıntı bulunmamaktadır. Eğer böyle bir kod bloğu görürseniz kod çok eski diyebilirsiniz.
 
 
 ## Dışardan yüklenen Javascript kod dosyaları
@@ -92,7 +92,7 @@ Birkaç kod dosyası eklemek isterseniz aşağıdaki gibi yazabilirsiniz.
 ```smart
 Kural olarak en basit JavaScript kodları doğrudan HTML içerisine yazılır. Daha karmaşık olanlar farklı dosyalarda taşınır.
 
-Ayrı dosyalarda taşınmasının bir diğer güzel yanı tarayıcıların bu dosyaları indirip ön belleğe almasıdır.[cache] https://tr.wikipedia.org/wiki/Web_%C3%B6nbelle%C4%9Fi).
+Ayrı dosyalarda taşınmasının bir diğer güzel yanı tarayıcıların bu dosyaları indirip ön belleğe almasıdır [cache](https://tr.wikipedia.org/wiki/Web_%C3%B6nbelle%C4%9Fi).
 
 Bu olaydan sonra eğer bu kod dosyaları değişmediyse daha sonraki sayfa gösterimlerinde o dosyaları tekrar indirmeyecektir. Yani kod dosyaları sadece bir defa indirilecektir. Bu da web sayfasının veri trafiğinin daha az olmasını ve sayfanın daha hızlı gösterilmesini sağlar.
 ```
diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index 886ccf8b8..aebf08763 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -8,7 +8,7 @@
 
 Şu ana kadar `alert('Merhaba Dünya')` ifadesini gördük ve bunun uyarı mesajı verdiğini biliyorsunuz.
 
-Kodun içerisinde istediğiniz kadar ifadeye. Diğer kod cümlesi bir birinden noktalı virgül ile ayrılır.
+Kodun içerisinde istediğimiz kadar ifadeye sahip olabiliriz. Diğer kod cümlesi bir birinden noktalı virgül ile ayrılır.
 
 Örneğin burada mesaj ikiye ayrılmıştır.
 
@@ -34,7 +34,8 @@ alert('Dünya')
 ```
 JavaScript dilinde bu şekilde satır bırakarak ifadeyi bitirme olayına "üstü kapalı" noktalı virgül denilmektedir. Ayrıca [otomatik noktalı virgül koyma](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion) da denir
 
-**Çoğu durumda yeni satır noktalı virgül anlamına gelir. Unutulmamalı ki çoğu durum her zaman demek değildir.**
+
+**Çoğu durumda yeni satır, noktalı virgül anlamına gelir. Unutulmamalı ki çoğu durum, her zaman anlamına gelmez.**
 
 Aşağıdaki örnekte görüleceği üzeri yeni satır noktalı virgül anlamına gelmemektedir.
 
@@ -99,7 +100,7 @@ Yorum satırları kodun içerisinde herhangi bir yere koyulabilir. Kodun çalı
 
 **Tek satır olarak yazmak istiyorsanız `//` kullanarak yorum yazabilirsiniz** 
 
-Kesik çizgi işaretlerinden sonra istediğiniz yorumu yazabilirsiniz.
+Eğik çizgi işaretlerinden sonra istediğiniz yorumu yazabilirsiniz.
 
 Örneğin:
 ```js run
@@ -109,7 +110,7 @@ alert('Merhaba');
 alert('Dünya'); // Bu yorum ise ifadeyi takip eder
 ```
 
-**Eğer birden çok satırda yorum yazmak istiyorsanız kesik çizgi + yıldız ile ( <code>/&#42;</code> ) yoruma başlayıp yıldız ve kesik çizgi ile bu kod bloğunu bitirebilirsiniz <code>&#42;/</code>.**
+**Eğer birden çok satırda yorum yazmak istiyorsanız eğik çizgi + yıldız ile ( <code>/&#42;</code> ) yoruma başlayıp, yıldız ve eğik çizgi ile bu kod bloğunu bitirebilirsiniz <code>&#42;/</code>.**
 
 Örneğin:
 
@@ -128,9 +129,9 @@ alert('Hello');
 alert('Dünya');
 ```
 
-```smart header="Klavye kısa yollarını kullanın!"
+```smart header="Klavye kısayollarını kullanın!"
 
-Çoğu editör `key:Ctrl+/` kısa yolunu kullanarak tek satır veya `key:Ctrl+Shift+/` kullanarak çok satır yorum yapmanıza yardımcı olur. Mac için `key:Cmd` tuşu windows için ise `key:Ctrl` tuşudur.
+Çoğu editör `key:Ctrl+/` kısayolunu kullanarak tek satır veya `key:Ctrl+Shift+/` kullanarak çok satır yorum yapmanıza yardımcı olur. Mac için `key:Cmd` tuşu windows için ise `key:Ctrl` tuşudur.
 ```
 
 ````warn header="Yorum satırı içerisinde ayrı bir yorum satırı yapılamaz!"
diff --git a/1-js/02-first-steps/03-strict-mode/article.md b/1-js/02-first-steps/03-strict-mode/article.md
index 764221311..99025a03f 100644
--- a/1-js/02-first-steps/03-strict-mode/article.md
+++ b/1-js/02-first-steps/03-strict-mode/article.md
@@ -19,7 +19,7 @@ Bu direktif için kod dosyanızın başına `"use strict"` veya `'use strict'` y
 ...
 ```
 
-Yakında fonksiyonları ( komutları gruplama ) göreceksiniz. 
+Yakında fonksiyonları (komutları gruplama yolu) göreceksiniz. 
 
 `"use strict"` birden çok fonksiyonda kullanılacağı gibi tek fonksiyon için de kullanılabilir. Fakat genelde tüm dosya için kullanılır.
 
diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md
index 62b04414f..b11783cf6 100644
--- a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md
+++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md
@@ -1,5 +1,5 @@
-Genelde tamamı büyük harf değişleri "sabit kodlanmış" değerler için. Veya kod çalışmadan bilinen değerler için kullanılır.
+Genelde "sabit kodlanmış" sabitler için tamamen büyük harf kullanırız. Bir başka deyişle, kod çalışmadan bilinen ve doğrudan koda yazılan değerler için kullanılır.
 
 Bu kod cümlesinde `dogumGunu` tam da bu tanıma uymaktadır. Bundan dolayı büyük harf ile kullanılabilir.
 
-Buna karşı `yaş` değişkeni bir fonksiyonun çıktısına göre değer almaktadır. Bu gün diyelim ki 20 yaşındaysanız bir yıl sonra 21 yaşında olacaksınız demektir. Tabi bu kural kod çalıştığında değişmez. Yani yıla göre değer alacaktır cümlesi değişmeyecektir. Fakat değer değiştiğinden dolayı `dogumGunu` değişkenine göre daha az sabittir. Hesaplanan bir değerdir. Bundan dolayı bunu küçük harfle tutmanız gerekmektedir.
\ No newline at end of file
+Buna karşı `yaş` değişkeni bir fonksiyonun çıktısına göre değer almaktadır. Bugün diyelim ki 20 yaşındaysanız bir yıl sonra 21 yaşında olacaksınız demektir. Tabi bu kural kod çalıştığında değişmez. Yani yıla göre değer alacaktır cümlesi değişmeyecektir. Fakat değer değiştiğinden dolayı `dogumGunu` değişkenine göre daha az sabittir. Hesaplanan bir değerdir. Bundan dolayı bunu küçük harfle tutmanız gerekmektedir.
\ No newline at end of file
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
index dded7e756..ab934ba1b 100644
--- a/1-js/02-first-steps/04-variables/article.md
+++ b/1-js/02-first-steps/04-variables/article.md
@@ -300,7 +300,7 @@ Birkaç kural şu şekildedir:
 
 - İnsan-okuyabilir değişken ismi verin `kullaniciAdi` veya `alisverisSepeti` gibi.
 - `a`, `b`, `c` gibi kısaltmaları kullanmayın. Tabi ne yaptığınızı kesin olarak biliyorsanız kullanabilirsiniz.
-- İsimlerin açıklayıcı olmasına önem verin. Örneğin `veri` ve `deger` adindaki değişkenler birşey ifade etmezler. Tabi eğer kod bloğunda bunların bir anlamı var ise kullanılabilir.
+- İsimlerin açıklayıcı olmasına önem verin. Örneğin `veri` ve `deger` adindaki değişkenler bir şey ifade etmezler. Tabi eğer kod bloğunda bunların bir anlamı var ise kullanılabilir.
 - Bazı tanımları kafanızda takımınızın kullandığı şekil ile uyumlu şekilde oturtun. Örneğin sizeyi ziyaret eden kişi `kullanici` ise kullanıcı ile olan değişkenleri `anlikKullanici` veya `yeniKullanici` gibi kullanın fakat `yeniZiyaretci` veya `yeniCocuk` gibi kullanmayın.
 
 Basit değil mi? Gerçekten öyle, fakat pratikte bu kadar da basit değil. Umarım bunu siz gerçekleştirirsiniz.
diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
index ba255dc89..b8fc65b01 100644
--- a/1-js/02-first-steps/05-types/article.md
+++ b/1-js/02-first-steps/05-types/article.md
@@ -171,7 +171,7 @@ Bir diğer özel değer ise `undefined`dır. Kendi başına `null` gibi bir değ
 
 `undefined` anlam olarak "herhangi bir değer atanmamıştır" anlamına gelir.
 
-Eğer bir değişken tanımlanmış fakat hiç bir değer atanmamışsa tam olarak bu değeri alır.
+Eğer bir değişken tanımlanmış fakat hiçbir değer atanmamışsa tam olarak bu değeri alır.
 
 ```js run
 let x;
diff --git a/1-js/02-first-steps/06-type-conversions/article.md b/1-js/02-first-steps/06-type-conversions/article.md
index 38f894595..e9f123d73 100644
--- a/1-js/02-first-steps/06-type-conversions/article.md
+++ b/1-js/02-first-steps/06-type-conversions/article.md
@@ -62,7 +62,7 @@ Sayısal dönüştürme kuralları:
 |`undefined`|`NaN`|
 |`null`|`0`|
 |<code>true&nbsp;ve&nbsp;false</code> | `1` veya `0` |
-| `string` | Önce başta ve sondaki whitespace'ler silinir. Sonra eğer kalan değerde hiç bir karakter yok ise sonuç `0`. Eğer içerisinde sayısal olmayan bir değer var ise bu durumda `NaN` değeri alınır. |
+| `string` | Önce başta ve sondaki whitespace'ler silinir. Sonra eğer kalan değerde hiçbir karakter yok ise sonuç `0`. Eğer içerisinde sayısal olmayan bir değer var ise bu durumda `NaN` değeri alınır. |
 
 Örnekler:
 
@@ -137,7 +137,7 @@ Dönüştürme işlemi aşağıdaki kuralları kapsar:
 |`undefined`|`NaN`|
 |`null`|`0`|
 |<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
-| `string` | Önce başta ve sondaki whitespace'ler silinir. Sonra eğer kalan değerde hiç bir karakter yok ise sonuç `0`. Eğer içerisinde sayısal olmayan bir değer var ise bu durumda `NaN` değeri alınır. |
+| `string` | Önce başta ve sondaki whitespace'ler silinir. Sonra eğer kalan değerde hiçbir karakter yok ise sonuç `0`. Eğer içerisinde sayısal olmayan bir değer var ise bu durumda `NaN` değeri alınır. |
 
 **`ToBoolean`** -- Lojik operatörlerde otomatik çalışır ayrıca  `Boolean(value)` ile de dönüştürme işlemi yapılabilir.
 
diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index e5940c887..e536e8336 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -52,7 +52,7 @@ alert( '1' + 2 ); // "12"
 alert( 2 + '1' ); // "21"
 ```
 
-Gördüğünüz gibi, ilk operand veya ikinci operandın karakter dizisi olması birşeyi değiştirmiyor. Kural basit, her iki taraftan birisi karakter dizisi ise diğerini de karakter dizisine çevir ve birleştir.
+Gördüğünüz gibi, ilk operand veya ikinci operandın karakter dizisi olması bir şeyi değiştirmiyor. Kural basit, her iki taraftan birisi karakter dizisi ise diğerini de karakter dizisine çevir ve birleştir.
 
 Yani `"+"` işlemi hem birleştirme hem de tip değiştirme yapmaktadır. Bu sadece `"+"` operatörüne has bir olaydır.
 
@@ -67,7 +67,7 @@ alert( '6' / '2' ); // 3
 
 `+` iki formda bulunur. Yukarıda kullandığımız binary form(iki tane operand olma olayı) veya unary form(tek operand olması).
 
-Eğer unary `+` veya tek bir değerle kullanılan `+` işareti sayılar ile birşey yapmaz. Fakat eğer bu bir sayı değilse sayıya çevrilir.
+Eğer unary `+` veya tek bir değerle kullanılan `+` işareti sayılar ile bir şey yapmaz. Fakat eğer bu bir sayı değilse sayıya çevrilir.
 
 
 Örneğin:
@@ -436,4 +436,4 @@ for (*!*a = 1, b = 3, c = a * b*/!*; a < 10; a++) {
 }
 ```
 
-Bu tarz numaralar bir çok JavaScript frameworklerinde kullanılır. Bu yüzden bunladan bahsettik. Ama genelde bunlar kodun okunabilirliğini azaltıyorlar. Bu yüzden kullanmadan önce iyi düşünmek gerekir.
+Bu tarz numaralar birçok JavaScript frameworklerinde kullanılır. Bu yüzden bunladan bahsettik. Ama genelde bunlar kodun okunabilirliğini azaltıyorlar. Bu yüzden kullanmadan önce iyi düşünmek gerekir.
diff --git a/1-js/02-first-steps/08-comparison/article.md b/1-js/02-first-steps/08-comparison/article.md
index 6eb288a59..e2face193 100644
--- a/1-js/02-first-steps/08-comparison/article.md
+++ b/1-js/02-first-steps/08-comparison/article.md
@@ -145,7 +145,7 @@ Sıkı eşitlik kontrolü için `===`: Bu değerler farklıdır, çünkü her bi
     alert( null === undefined ); // false
     ```
 
-Sıkı olmayan eşitlik kontrolüne göre `==`: bunlar birbirlerine eşit fakat başka hiç bir değere eşit değildirler.
+Sıkı olmayan eşitlik kontrolüne göre `==`: bunlar birbirlerine eşit fakat başka hiçbir değere eşit değildirler.
 
 
     ```js run
@@ -170,11 +170,11 @@ Matematiksel olarak yukarıda gördüğünüz örnekler imkansız. En sondaki ö
 
 Bunun nedeni eşitlik kontrolü `==` ve karşılaştırma kontrollerinin `> < >= <=` farklı çalışmasından dolayıdır. Karşılaştırma iki tarafta bulunan değerleri önce sayıya çevirmeye çalışır. Bundan dolayı sonuncu örnekte `null>=0` null `0` a dönüşür. En üst örnekte de `null>0` bunu şekilde çalışır. Bundan dolayı en üstte false, en altta ise true döner.
 
-Diğer bir taraftan eşitlik kontrolü `==`, `undefined`ve `null`için kurala göre bir değişikliğe uğramaz. Sadece birbirleri arasında (`undefined` ile `null`) eşitliğe sahiptirler. Diğer türlü hiç birşeye eşit değildirler. Bundan dolayı `null == 0` false olur.
+Diğer bir taraftan eşitlik kontrolü `==`, `undefined`ve `null`için kurala göre bir değişikliğe uğramaz. Sadece birbirleri arasında (`undefined` ile `null`) eşitliğe sahiptirler. Diğer türlü hiçbir şeye eşit değildirler. Bundan dolayı `null == 0` false olur.
 
 ### Karşılaştırılamaz tanımsız ( undefined )
 
-`undefined` hiç bir zaman karşılaştırma içerisine girmemelidir.
+`undefined` hiçbir zaman karşılaştırma içerisine girmemelidir.
 
 ```js run
 alert( undefined > 0 ); // false (1)
@@ -185,7 +185,7 @@ Neden hep false çıktı?
 
 Bu sonuçları şunlardan dolayı aldık
 - `(1.)` ve `(2.)` örneklerde `false` döndü çünkü `undefined` `NaN` oldu. `Nan` özel bir sayısal değişkendir ve hangi sayı ile karşılaştırılırsa karşılaştırılsın, sonuç `false` çıkar.
-- `(3.)` maddedeki eşitlik kontrolü ise `undefined`'ın sadece `null` ile eşit olabilmesinden dolayıdır. `null` haricinde hiç bir değere eşit değildir.
+- `(3.)` maddedeki eşitlik kontrolü ise `undefined`'ın sadece `null` ile eşit olabilmesinden dolayıdır. `null` haricinde hiçbir değere eşit değildir.
 
 ### Problemlerden Kaçınma
 
@@ -199,5 +199,5 @@ Neden peki bu örnekleri yaptık?  Bu şeyleri her zaman hatırlamamıza gerek v
 - Karşılaştırma operatörleri mantıksal değerler döndürür. (true/false) gibi
 - Karakter dizileri harf harf alfabe sırasına göre kontrol edilir.
 - Karşılaştırmalarda eğer farklı tipler kullanılıyorsa bunlar sayıya işlem yapılmadan sayıya çevirilir. ( Eğer sıkı eşittir kullanıyorsanız çevirilmez)
-- `null` ve `undefined` eşittir. Bu değerler başka hiç bir değere eşit değildirler.
+- `null` ve `undefined` eşittir. Bu değerler başka hiçbir değere eşit değildirler.
 - Değeri `null/undefined` olabilen bir değişken ile `>` veya `<` karşılaştırması yaparken dikkat edin. Ayrı bir `null/undefined` kontrolü yapmakta fayda var.s
diff --git a/1-js/02-first-steps/09-alert-prompt-confirm/article.md b/1-js/02-first-steps/09-alert-prompt-confirm/article.md
index abcb57277..f61104855 100644
--- a/1-js/02-first-steps/09-alert-prompt-confirm/article.md
+++ b/1-js/02-first-steps/09-alert-prompt-confirm/article.md
@@ -2,7 +2,7 @@
 
 Bu bölüm JavaScript'i çevre bağımsız yani tarayıcı veya server farketmeksizin olduğu gibi kapsar.
 
-Fakat şu anda eğitimler tarayıcı üzerinde yapılmaktadır. Bundan dolayı en azından kullanıcı arayüzüne dair fonksiyon bilmenizde fayda var. Bu bölümde tarayıcıda çalışan `aler`, `prompt`, `confirm` fonksiyonları incelenecek.
+Fakat şu anda eğitimler tarayıcı üzerinde yapılmaktadır. Bundan dolayı en azından kullanıcı arayüzüne dair fonksiyon bilmenizde fayda var. Bu bölümde tarayıcıda çalışan `alert`, `prompt`, `confirm` fonksiyonları incelenecek.
 
 ## alert
 
@@ -104,4 +104,4 @@ Yukarıdaki metodlar için iki tane sınırlama vardır.
 1. Bu açılan modal'ın yeri genelde sayfanın ortasıdır.
 2. Ayrıca ekranın stili, bu da tarayıcıdan tarayıcıya değişmektedir. Bunu değiştiremezsiniz.
 
-Bu da herşeyi basite indirgemenin karşılığı. Tabi farklı yollarla daha güzel ekranlar göstermek mümkün fakat görüntü o kadar da önemli değil, işlevsellik önemli derseniz, bu durumda bu metodları kullanabilirsiniz.
+Bu da her şeyi basite indirgemenin karşılığı. Tabi farklı yollarla daha güzel ekranlar göstermek mümkün fakat görüntü o kadar da önemli değil, işlevsellik önemli derseniz, bu durumda bu metodları kullanabilirsiniz.
diff --git a/1-js/02-first-steps/10-ifelse/article.md b/1-js/02-first-steps/10-ifelse/article.md
index f72f3ba0a..416f9c91c 100644
--- a/1-js/02-first-steps/10-ifelse/article.md
+++ b/1-js/02-first-steps/10-ifelse/article.md
@@ -40,7 +40,7 @@ Her `if` kullandığınızda süslü parantez kullanmanız okunurluğu artıraca
 - `0`, boş karakter `""`, `null`, `undefined` ve `NaN` `false` olarak döndürülür. Bunlara `falsy` yani `yanlış` değerler de diyebiliriz.
 - Diğer değerler ise `true` olur ve bunlara `truthy` veya `doğru` değerler de denebilir. ( Not: Bunların tam karşılıklarını bulamadım )
 
-Örneğin aşağıdaki kod satırı hiç bir zaman çalışmayacaktır:
+Örneğin aşağıdaki kod satırı hiçbir zaman çalışmayacaktır:
 
 ```js
 if (0) { // 0 false döndürür
diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
index 1ea4f5be4..e118b8394 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
@@ -4,7 +4,7 @@ Cevap: Önce `1`, sonra `undefined`.
 alert( alert(1) && alert(2) );
 ```
 
-Birinci `alert` `undefined` değeri döndürür. ( sadece değeri gösterir, bundan dolayı birşey döndürmez)
+Birinci `alert` `undefined` değeri döndürür. ( sadece değeri gösterir, bundan dolayı bir şey döndürmez)
 
 Bundan dolayı ilk `yanlışı` bulan `&&` operatörü bu işlem sonrasında durur. Yanlış değeri dönderir ki bu durumda yanlış değer `undefined` dır. Dışarıda bulunan `alert` ise bu değeri uyarı şeklinde ekrana verir.
 
diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 73ff6345f..b9773876f 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -53,7 +53,7 @@ if (saat < 10 || saat > 18) {
   alert( 'Ofis Kapalı' );
 }
 ```
-Bir çok şart cümlesi ile if yapısını kurabilirsiniz.
+Birçok şart cümlesi ile if yapısını kurabilirsiniz.
 
 ```js run
 let saat = 12;
diff --git a/1-js/02-first-steps/12-while-for/7-list-primes/task.md b/1-js/02-first-steps/12-while-for/7-list-primes/task.md
index fb356aec2..1c9b572d8 100644
--- a/1-js/02-first-steps/12-while-for/7-list-primes/task.md
+++ b/1-js/02-first-steps/12-while-for/7-list-primes/task.md
@@ -4,7 +4,7 @@ importance: 3
 
 # Output prime numbers
 
-`1` den büyük olup `1` veya kendisi haricinde hiç bir sayıya kalansız bölünemeyen sayılara [asal sayı](https://tr.wikipedia.org/wiki/Asal_say%C4%B1) denir.
+`1` den büyük olup `1` veya kendisi haricinde hiçbir sayıya kalansız bölünemeyen sayılara [asal sayı](https://tr.wikipedia.org/wiki/Asal_say%C4%B1) denir.
 
 Örneğin `5` bir asal sayıdır. Çünkü `2`,`3` ve `4` e kalansız bölünemez.
 
diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md
index 292a9afa9..16a2aff7b 100644
--- a/1-js/02-first-steps/12-while-for/article.md
+++ b/1-js/02-first-steps/12-while-for/article.md
@@ -184,7 +184,7 @@ for (; i < 3;) {
 ```
 Döngü `while(i<3)` ile aynı oldu.
 
-Aslında herşeyi silebiliriz:
+Aslında her şeyi silebiliriz:
 
 ```js
 for (;;) {
@@ -221,7 +221,7 @@ alert( 'Toplam: ' + toplam );
 
 `break` talimatı `(*)` satırında görüldüğü üzere. Eğer kullanıcı boş değer girerse doğrudan döngü durur ve döngüden sonraki ilk satıra atlar. Yani `alert` çalışır. 
 
-"Sonsuz döngü" + `break` birlikte kullanıldığında başlangıçta koşul kontrol edilmese de olur ama döngü gövdesinde veya sonunda kontrol edilmesi gerekir denen döngüler için güzel bir birliktelik oluşturur. Bu döngü içerisinde bir çok defa koşul kullanılarak döngü kırılabilir.
+"Sonsuz döngü" + `break` birlikte kullanıldığında başlangıçta koşul kontrol edilmese de olur ama döngü gövdesinde veya sonunda kontrol edilmesi gerekir denen döngüler için güzel bir birliktelik oluşturur. Bu döngü içerisinde birçok defa koşul kullanılarak döngü kırılabilir.
 
 ## Bir sonraki tekerrüre geçme  [#continue]
 
@@ -330,7 +330,7 @@ Aşağıdaki gibi:
     // Eğer iptal edildi veya boş bir değer girildiyse dışarıdaki döngüyü de kır.
     if (!giris) *!*break ust_dongu*/!*; // (*)
 
-    // değer ile birşeyler yap.
+    // değer ile bir şeyler yap.
   }
 }
 alert('Bitti!');
diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md
index b4757c99e..d2584eeac 100644
--- a/1-js/02-first-steps/13-switch/article.md
+++ b/1-js/02-first-steps/13-switch/article.md
@@ -34,7 +34,7 @@ switch(x) {
 
 - Eğer eşitlik bulunursa en yakın `break` olan yere kadar çalışmaya devam eder. Eğer `break` yoksa döngüyü kıramayacağından dolayı `switch` sonuna kadar çalışır.
 
-- Eğer hiç bir eşitlik sağlanamazsa `default` içinde olan kod çalışır.
+- Eğer hiçbir eşitlik sağlanamazsa `default` içinde olan kod çalışır.
 
 ## Örnek
 Aşağıda bulunan örnekte çalışacak `case` bloğu vurgulanmıştır.
@@ -61,7 +61,7 @@ Başlangıçta `switch` cümlesi `a` değişkenini ilk önce 3 `case`'i ile kar
 
 `4` ise eşitliği sağlar `4`den itibaren en yakın `break`e kadar olan bölüm çalışır.
 
-**Eğer `break` konulmazsa sonraki `case` de hiç bir kontrol olmadan çalışır**
+**Eğer `break` konulmazsa sonraki `case` de hiçbir kontrol olmadan çalışır**
 
 `break` olmadan yazılmış hali:
 
@@ -161,7 +161,7 @@ switch (arg) {
     break;
 
   case 3:
-    alert( 'Hiç bir zaman çalışmaz!' );
+    alert( 'hiçbir zaman çalışmaz!' );
     break;
   default:
     alert( 'Bilinmeyen bir değer' )
@@ -169,4 +169,4 @@ switch (arg) {
 ```
 1. `0` ve `1` değerleri için ilk `alert` çalışır.
 2. `2` değeri için ikinci `alert` çalışır.
-3. `prompt` her zaman karakter dizisi döndüreceğinden dolayı kontrol eğer `3` şeklinde yapılsaydı bu durumda ekrana mesaj çıkacaktı. Fakat kontrol sayı olan 3 ile yapıldığından dolayı bu ölü koddur ve hiç bir zaman çalışmaz. Bunun yerine `default` kodu çalışacaktır.
+3. `prompt` her zaman karakter dizisi döndüreceğinden dolayı kontrol eğer `3` şeklinde yapılsaydı bu durumda ekrana mesaj çıkacaktı. Fakat kontrol sayı olan 3 ile yapıldığından dolayı bu ölü koddur ve hiçbir zaman çalışmaz. Bunun yerine `default` kodu çalışacaktır.
diff --git a/1-js/02-first-steps/14-function-basics/article.md b/1-js/02-first-steps/14-function-basics/article.md
index 66111b9b5..9dca781e4 100644
--- a/1-js/02-first-steps/14-function-basics/article.md
+++ b/1-js/02-first-steps/14-function-basics/article.md
@@ -4,7 +4,7 @@
 
 Örneğin kullanıcı hesabına giriş yaptığında veya çıktığında güzel görünümlü bir mesaj göstermek istenebilir.
 
-Fonksiyonlar programın "yapı taşıdır". Bir çok defa bu fonksiyonlar çağırılarak tekrardan bu kodları yazmaktan kurtulunur.
+Fonksiyonlar programın "yapı taşıdır". Birçok defa bu fonksiyonlar çağırılarak tekrardan bu kodları yazmaktan kurtulunur.
 
 Aslında var olan `alert(mesaj)`, `prompt(mesaj,varsayilan)` ve `confirm(soru)` gibi fonksiyonları gördük. Fakat artık bunları yazmanın zamanı geldi.
 
@@ -290,7 +290,7 @@ function filmGoster(age) {
 ```
 Yukarıdaki kodda  eğer `yasKontrolu(yas)` `false` dönderir ise  `filmGoster` fonksiyonu `alert`e erişemeyecektir.
 
-````smart header="boş veya birşey döndermeyen fonksiyon `undefined` dönderir"
+````smart header="boş veya bir şey döndermeyen fonksiyon `undefined` dönderir"
 Eğer bir fonksiyon değer döndermiyor ise bu fonksiyon `undefined` dönderiyor ile aynı anlama gelir.
 
 
@@ -311,7 +311,7 @@ alert( biseyYapma() === undefined ); // true
 ```
 ````
 
-````warn header="`return` ve `değer` arasına hiç bir zaman satır eklemeyin"
+````warn header="`return` ve `değer` arasına hiçbir zaman satır eklemeyin"
 
 Uzun `return` ifadelerinde, yeni bir satırda yazmak size kullanışlı gelebilir, örneğin aşağıdaki gibi:
 
@@ -335,14 +335,14 @@ Fonksiyonlar eylemdir. Bundan dolayı isimleri yüklem olmalıdır. Net olmalı
 
 Genel itibari ile eylemi tanımlayan önek kullanmak iyi bir yöntemdir. Bu önekler ile ilgili birlikte kod yazdığınız kişiler ile uyum içerisinde olmalısınız. 
 
-Örneğin `"show"` fonksiyonu her zaman birşeyleri `gösterir`.
+Örneğin `"show"` fonksiyonu her zaman bir şeyleri `gösterir`.
 
 Fonksiyonlar şöyle başlayabilir.
 
 - `"get…"` -- değer dönderir,
-- `"calc…"` -- birşeyler hesaplar,
-- `"create…"` -- birşeyler yaratır,
-- `"check…"` -- birşeyleri kontrol eder ve boolean dönderir.
+- `"calc…"` -- bir şeyler hesaplar,
+- `"create…"` -- bir şeyler yaratır,
+- `"check…"` -- bir şeyleri kontrol eder ve boolean dönderir.
 
 Böyle isimlere örnek:
 
@@ -365,7 +365,7 @@ Bir fonksiyon sadece isminin tanımladığı işi yapmalı.
 Bu kurallar şu şekilde bozulabilir:
 
 - `getAge` -- Eğer bu fonksiyon içeride `alert` ile yaş gösteriyor ise yanlış olur. Bu fonksiyonun sadece yaşı alıp döndermesi gerekmekte.
-- `createForm` -- Eğer dökümanı değiştiriyorsa veya forma birşey ekliyorsa yanlış olur. ( Sadece formu yaratmalı ve geri dönmelidir )
+- `createForm` -- Eğer dökümanı değiştiriyorsa veya forma bir şey ekliyorsa yanlış olur. ( Sadece formu yaratmalı ve geri dönmelidir )
 - `checkPermission` -- Eğer `izin verildi/reddedildi` gibi mesajları bu fonksiyon gösterirse yanlış olur. Sadece kontrol etmeli ve geri dönmelidir.
 
 Bu örnekler genel olarak öneklerin nasıl tahmin edilmesi gerektiğini gösterir. Bunların ne anlama geleceği siz ve takımınıza kalmıştır. Belki sizin kodunuz için farklı bir şekilde davranması gayet doğal olabilir. Fakat yine de öneklere ait bir anlamlandırmanız olmalıdır. Ön ek ne yapabilir ne yapamaz vs. Tüm aynı önekli fonksiyonlar sizin koyduğunuz kurala uymalı ve tüm takım bu kuralları biliyor olmalıdır.
@@ -382,7 +382,7 @@ Bunlar istisnadır. Genel olarak fonksiyon isimleri kısa ve açıklayıcı olma
 
 ## Fonksiyonlar == Yorumlar
 
-Fonksiyonlar kısa olmalı ve sadece birşeyi yapmalıdırlar. Eğer uzun ise bu durumda ayırıp yeni bir fonksiyon yapmanız daha iyi olabilir. Bazen bu kuralı takip etmek zor olabilir. Fakat kesinlikle iyi birşeydir.
+Fonksiyonlar kısa olmalı ve sadece bir şeyi yapmalıdırlar. Eğer uzun ise bu durumda ayırıp yeni bir fonksiyon yapmanız daha iyi olabilir. Bazen bu kuralı takip etmek zor olabilir. Fakat kesinlikle iyi bir şeydir.
 
 Farklı fonksiyon daha kolay bir şekilde çalışması kontrol edilebilir. Varlığı harika bir yorumdur.
 
@@ -440,13 +440,13 @@ function fonksiyon ismi(parametreler, virgül , ile, ayrilirlar) {
 
 Kodun daha anlaşılır ve okunabilir olması için, fonksiyonlar içerisinde yerel değişken kullanılması önerilir. Dış değişkenler kullanılması önerilmez.
 
-Eğer fonksiyon parametre ile değer alır ve bu değer üzerinde çalışıp değer geri dönderirse anlaşılırlığı artar. Fakat eğer fonksiyon hiç bir parametre almadan sadece dışarıdaki değişkenleri değiştiriyor ise kodun anlaşılırlığı büyük ölçüde azalır.
+Eğer fonksiyon parametre ile değer alır ve bu değer üzerinde çalışıp değer geri dönderirse anlaşılırlığı artar. Fakat eğer fonksiyon hiçbir parametre almadan sadece dışarıdaki değişkenleri değiştiriyor ise kodun anlaşılırlığı büyük ölçüde azalır.
 
 Fonksiyon isimlendirme:
 
 - Bir isim fonksiyonun ne işe yaradığını açıklayabiliyor olmalıdır. İyi bir isim fonksiyonun okunmadan ne iş yaptığına dair fikir verir.
 - Fonksiyon bir fiili yerine getirdiğinden, fonksiyon isimleri yüklem olmalıdır.
-- Bunlar için ön ek kullanabilirsiniz. Türkçe sondan eklemeli bir dil olduğundan dolayı fonksiyon ekleri sona gelmektedir. Örneğin `asalGoster`, bu tip kullanım aslında okunurluk açısından pekte iyi değil benim kanaatimce. Çünkü okurken önce ne yaptığını anlaşılmıyor. Fakat İngilizce örneğine bakarsanız `showPrime`, burada önce ne yaptığını söylüyor. Farzedin ki bir çok fonksiyonunuz var ve okuduğunuzda önce ne iş yaptığını bilmek bunları filtrelemenizde size yardımcı olacaktır.
+- Bunlar için ön ek kullanabilirsiniz. Türkçe sondan eklemeli bir dil olduğundan dolayı fonksiyon ekleri sona gelmektedir. Örneğin `asalGoster`, bu tip kullanım aslında okunurluk açısından pekte iyi değil benim kanaatimce. Çünkü okurken önce ne yaptığını anlaşılmıyor. Fakat İngilizce örneğine bakarsanız `showPrime`, burada önce ne yaptığını söylüyor. Farzedin ki birçok fonksiyonunuz var ve okuduğunuzda önce ne iş yaptığını bilmek bunları filtrelemenizde size yardımcı olacaktır.
 - Örnek kaç tane ek , `create...` , `show...`, `get...`, `check...` vs.
 
 Fonksiyonlar kod yazarken kullanılan ana yapılardır. Artık temellerini anlaşıldığına göre kullanılmaya başlanabilir. Fakat sadece temellerinin gösterildiğini bilmekte fayda var. ileride defalaraca fonksiyonlar konusuna geri dönülecektir.
diff --git a/1-js/02-first-steps/15-function-expressions/article.md b/1-js/02-first-steps/15-function-expressions/article.md
index 67f18ee43..70287d151 100644
--- a/1-js/02-first-steps/15-function-expressions/article.md
+++ b/1-js/02-first-steps/15-function-expressions/article.md
@@ -79,7 +79,7 @@ let func = selamVer;
 // ...
 ```
 
-Herşey aynı olduğu gibi çalışırdı. Hatta neyin ne olduğu daha açık değil mi?
+Her şey aynı olduğu gibi çalışırdı. Hatta neyin ne olduğu daha açık değil mi?
 
 
 ````smart header="Neden sonunda noktalı virgül var"
@@ -161,7 +161,7 @@ sor(
 );
 */!*
 ```
-Gördüğünüz gibi yukarıda fonksiyonlar doğrudan `sor(...)` içerisinde tanımlandı. Hiç bir isim kullanılmadığından dolayı. Böyle fonksiyonlara *anonim* veya *anonymous* fonksiyonlar denir. Bu fonksiyonlar `sor` fonksiyonu dışında ulaşılabilir değillerdir(çünkü hiç bir değişkene atanmazlar).
+Gördüğünüz gibi yukarıda fonksiyonlar doğrudan `sor(...)` içerisinde tanımlandı. hiçbir isim kullanılmadığından dolayı. Böyle fonksiyonlara *anonim* veya *anonymous* fonksiyonlar denir. Bu fonksiyonlar `sor` fonksiyonu dışında ulaşılabilir değillerdir(çünkü hiçbir değişkene atanmazlar).
 
 Bu şekilde isimsiz kullanım JavaScript içerisinde çok doğaldır. Bu JavaScript'in ruhunda var diyebiliriz.
 
@@ -298,7 +298,7 @@ if (yas < 18) {
 
 } else {
 
-  function merhaba() {     //  Yaş 16 olduğundan burası hiç bir zaman çalışmaz.
+  function merhaba() {     //  Yaş 16 olduğundan burası hiçbir zaman çalışmaz.
     alert("Merhabalar!");
   }
 }
diff --git a/1-js/02-first-steps/16-arrow-functions-basics/article.md b/1-js/02-first-steps/16-arrow-functions-basics/article.md
index 1cb60801e..f0cb84ca8 100644
--- a/1-js/02-first-steps/16-arrow-functions-basics/article.md
+++ b/1-js/02-first-steps/16-arrow-functions-basics/article.md
@@ -44,7 +44,7 @@ let ikiKati = n => n * 2;
 alert( ikiKati(3) ); // 6
 ```
 
-Eğer hiç bir değer yoksa parantez eklenmelidir. ( Bir değer olduğunda yukarıdaki gibi kullanılabilir.)
+Eğer hiçbir değer yoksa parantez eklenmelidir. (Bir değer olduğunda yukarıdaki gibi kullanılabilir.)
 
 
 ```js run
diff --git a/1-js/02-first-steps/17-javascript-specials/article.md b/1-js/02-first-steps/17-javascript-specials/article.md
index 000ef4abf..16cbebdc2 100644
--- a/1-js/02-first-steps/17-javascript-specials/article.md
+++ b/1-js/02-first-steps/17-javascript-specials/article.md
@@ -52,7 +52,7 @@ JavaScript'in tüm modern özelliklerini kullanabilmek için, `"use strict"` kul
 ```
 Bu talimatı dosyanın başında veya fonksiyonun başında belirtmeniz gerekmektedir.
 
-`"use strict"` kullanmadan da herşey çalışır. Fakat eski tipte ve uyumluluk modunda çalışır. Modern davranışı seçerseniz böylece son yenilikleri uyumluluk modu olmadan da çalıştırabilirsiniz.
+`"use strict"` kullanmadan da her şey çalışır. Fakat eski tipte ve uyumluluk modunda çalışır. Modern davranışı seçerseniz böylece son yenilikleri uyumluluk modu olmadan da çalıştırabilirsiniz.
 
 Bazı modern özellikler ise uyumluluk modunda da çalışmaz sadece sıkı modda çalışır. Bunlara ilerleyen zamanlarda değinilecektir.
 Dahası için: <info:strict-mode>.
@@ -70,7 +70,7 @@ Değişkenler isimlendirilirken aşağıdakileri içerebilir:
 - `$` ve `_` gibi karakterler diğer karakterle aynı niteliktedir ve her yerde kullanılabilir.
 - Latin olmayan yani Arapça, Japonca, Çince gibi diller de kullanılabilir fakat genelde kullanılmaz. 
 
-Değişkenler dinamik yazıma sahiptir ve herşeyi tutabilirler:
+Değişkenler dinamik yazıma sahiptir ve her şeyi tutabilirler:
 
 ```js
 let x = 5;
@@ -157,7 +157,7 @@ Karşılaştırma
     ```
     `sıkı eşitlik` operatörü `===` bu çeviriyi yapmamaktadır: farklı tipler her zaman farklı değerler ifade eder, öyleyse:
 
-    `null` ve `undefined` değerleri özeldir: `==` şeklinde birbirlerine eşittirler. Fakat başka hiç bir değere eşit değildirler.
+    `null` ve `undefined` değerleri özeldir: `==` şeklinde birbirlerine eşittirler. Fakat başka hiçbir değere eşit değildirler.
     Büyüktür/Küçüktür karşılaştırmasında karakter dizileri karakter karakter karşılaştırılır. Diğer tipler sayıya çevrilir.
 
 
@@ -261,7 +261,7 @@ Detaylı bilgi için: <info:switch>.
 
 - Fonksiyonlar yerel değişkenlere sahip olabilirler: Bu değişkenler fonksiyon gövdesinde yazılır ve sadece fonksiyon içerisinde kullanılabilir.
 - Parametreler varsayılan değerlere sahip olabilirler: `function sum(a = 1, b = 2){...}`
-- Fonksiyonlar her zaman birşey döndürürler. Eğer `return` kelimesi yoksa sonuçta yine de `undefined` döner.
+- Fonksiyonlar her zaman bir şey döndürürler. Eğer `return` kelimesi yoksa sonuçta yine de `undefined` döner.
 
 
 | Fonksiyon Tanımlama | Fonksiyon ifadesi |
diff --git a/1-js/03-code-quality/01-debugging-chrome/article.md b/1-js/03-code-quality/01-debugging-chrome/article.md
index 0776827cd..cb1252ed6 100644
--- a/1-js/03-code-quality/01-debugging-chrome/article.md
+++ b/1-js/03-code-quality/01-debugging-chrome/article.md
@@ -37,7 +37,7 @@ Eğer `Esc` tuşuna basarsanız altta `konsol` açılır. Buraya komutları yaz
 
 Komut çalıştıktan sonra sonucunu hemen altında gösterir.
 
-Örneğin burada `1+2` `3`  çıktısını verir. `hello("debugger")` dediğinizde hiç birşey bulamadığından `undefined` döndürür.
+Örneğin burada `1+2` `3`  çıktısını verir. `hello("debugger")` dediğinizde hiçbir şey bulamadığından `undefined` döndürür.
 
 ![](chrome-sources-console.svg)
 
@@ -55,7 +55,7 @@ Aşağıdaki gibi görünmeli. (tıkladığınız yerler mavi olmalı)
 
 Kod durdurulduğunda, o anki değişken değerlerini inceleyebilir veya konsoldan kod çalıştırabilirsiniz. Diğer bir deyişle *hata ayıklayabilirsiniz*
 
-Oluşturulan bu kesme noktalarını sağ taraftaki panelde list halinde görmek mümkündür. Bu farklı dosyalarda eğer kesme noktaları varsa bunları görme açısından yararlı bir özelliktir. Eğer bir çok dosyada kesme noktası varsa bu panel vasıtasıyla:
+Oluşturulan bu kesme noktalarını sağ taraftaki panelde list halinde görmek mümkündür. Bu farklı dosyalarda eğer kesme noktaları varsa bunları görme açısından yararlı bir özelliktir. Eğer birçok dosyada kesme noktası varsa bu panel vasıtasıyla:
 
 - İstenilen herhangi bir kesme noktasına doğrudan üstüne tıklayarak gidilebilir.
 - Geçici olarak kesme noklarını devre dışı bırakılabilir.
@@ -147,7 +147,7 @@ Satır numaralarına sağ tıklayıp "Buradan devam et" özelliği ile kodu bir
 
 ## Loglama
 
-Konsola basit birşey yazdıracağınız zaman `console.log` fonksiyonunu kullanabilirsiniz. Aşağıdaki örnekte ekrana 0 ile 4 arasındaki değerler yazılır.
+Konsola basit bir şey yazdıracağınız zaman `console.log` fonksiyonunu kullanabilirsiniz. Aşağıdaki örnekte ekrana 0 ile 4 arasındaki değerler yazılır.
 
 ```js run
 // çalışmasını görmek için lütfen geliştirici konsolunu açınız.
diff --git a/1-js/03-code-quality/02-coding-style/article.md b/1-js/03-code-quality/02-coding-style/article.md
index 225b96c3e..2e88bf57f 100644
--- a/1-js/03-code-quality/02-coding-style/article.md
+++ b/1-js/03-code-quality/02-coding-style/article.md
@@ -38,7 +38,7 @@ if (n < 0) {
 -->
 Şimdi bu kurallar ve nedenleri hakkında konuşabiliriz.
 
-Buradaki hiç bir şey kanun değildir. Hepsi sizin zevgine kalmıştır ve değişebilir. Buradaki kodlama kuralları dogmalara dayanmaz.
+Buradaki hiçbir şey kanun değildir. Hepsi sizin zevgine kalmıştır ve değişebilir. Buradaki kodlama kuralları dogmalara dayanmaz.
 
 ### Süslü Parantez
 
@@ -92,7 +92,7 @@ Satır uzunluğu limitine takım seviyesinde karar verilir. Genelde 80-120 karak
 
 - **Yatay boşluklar:2(4) boşluk.**
     
-    Yatay boşluklar genelde 2 veya 4 veya "Tab" sembolünden oluşur. Bunlardan hangisinin seçilmesi gerektiği bir çeşit savaştır. Bu günlerde boşluk tuşu ile boşluk bırakmak daha fazla kullanılan yöntemdir.
+    Yatay boşluklar genelde 2 veya 4 veya "Tab" sembolünden oluşur. Bunlardan hangisinin seçilmesi gerektiği bir çeşit savaştır. Bugünlerde boşluk tuşu ile boşluk bırakmak daha fazla kullanılan yöntemdir.
 
     Boşluk tuşu ile satıra başlamanın "Tab" a göre üstünlü daha esnek ayarlanabilir olmasından dolayıdır.
 
diff --git a/1-js/03-code-quality/03-comments/article.md b/1-js/03-code-quality/03-comments/article.md
index f80fde37b..af7548157 100644
--- a/1-js/03-code-quality/03-comments/article.md
+++ b/1-js/03-code-quality/03-comments/article.md
@@ -109,7 +109,7 @@ function addJuice(kap) {
 ```
 Tekrardan söylemek gerekirse nelerin olup bittiğini yorum değil, fonksiyonun kendisi söylemeli.Ayrıca kod yapısı fonksiyonlar şeklinde ayrık olduğunda daha düzgün olur. Her fonksiyonun ne argüman aldığı ne geri döndürdüğü bellidir.
 
-Gerçekte neyin olup bittiğini söyleyen yorumu tamamen çıkarmak olanaksızdır. Bazen karmaşık algorimalara olabilir. Bazen akıllıca yapılmış kısa yollar olabilir. Fakat genel olarak kod basit ve kendi kendini açıklayıcı olmalı.
+Gerçekte neyin olup bittiğini söyleyen yorumu tamamen çıkarmak olanaksızdır. Bazen karmaşık algorimalara olabilir. Bazen akıllıca yapılmış kısayollar olabilir. Fakat genel olarak kod basit ve kendi kendini açıklayıcı olmalı.
 
 
 ## İyi yorum
diff --git a/1-js/03-code-quality/04-ninja-code/article.md b/1-js/03-code-quality/04-ninja-code/article.md
index 02543db38..6146b9d5a 100644
--- a/1-js/03-code-quality/04-ninja-code/article.md
+++ b/1-js/03-code-quality/04-ninja-code/article.md
@@ -4,7 +4,7 @@ Ninja programcıların eskiden bu kurnazlıkları yaparak kodu tekrardan düzenl
 
 Dikkatlice oku ve hangisisin bul bakalım - ninja, çaylak, veya kod eleştirmeni.
 
-```warn header="İroni tesbit edildi!"
+```warn header="İroni tespit edildi!"
 Bu kodlar kötü yazıma örnektirler.!!!
 ```
 
@@ -15,7 +15,7 @@ Kodunuzu olabildiğince kısa tutmalısınız. Bu sizin ne kadar zeki olduğunuz
 Örneğin aşağıdaki `'?'` kullanımına bakın:
 
 ```js
-// meşur bir javascript kütüphanesinden.
+// meşhur bir javascript kütüphanesinden.
 i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
 ```
 Harika değil mi? Eğer böyle yazarsanız, daha sonra gelen programcı bu satıra bakar ve `i` nin ne olduğunu ve ne yapmaya çalıştığınızı anlamak için uğraşır. Sonra size cevap almaya gelir.
@@ -31,7 +31,7 @@ Diğer bir şekilde daha hızlı ( ve daha beter!) kod yazma yöntemi de tek-har
 
 Kısa değişken isimleri kodun içerisinde aynen bir ninjanın ormanda kaybolduğu gibi kaybolurlar. Kimse onları "arayarak" bulamaz. Hatta birisi bulsa bile ne olduğunu çözemez
 
-.... Fakat bir istisna var. Gerçek ninja hiç bir zaman `for` döngüsünde sayaç için `i` kullanmaz. Her yerde kullanır ama orada kullanmaz. Biraz kurcalayın daha çok garip harf var. Örneğin `x` veya `y` gibi.
+.... Fakat bir istisna var. Gerçek ninja hiçbir zaman `for` döngüsünde sayaç için `i` kullanmaz. Her yerde kullanır ama orada kullanmaz. Biraz kurcalayın daha çok garip harf var. Örneğin `x` veya `y` gibi.
 
 Garip değişkenler eğer döngü gövdesi 1-2 sayfaysa daha harika olurlar. ( olabildiğince uzun olsun). Eğer birisi daha derinlemesine bakarsa, kolayca `x` in döngü sayacı olduğunu anlayamasın.
 
@@ -71,7 +71,7 @@ While choosing a name try to use the most abstract word. Like `obj`, `data`, `va
 - **Değişkeni tipi ile tanımlayın: `str`, `num`...**
     Bir defa deneyin. Genç ninjanın ağzı açık kalsın -- böyle isimler gerçekten de kodu kötü mü yapar? Evet!
 
-    Bir taraftan değişken isimleri hala birşey ifade ediyor. Değişkenin içinde ne var bunu söylüyor: karakter, sayı veya başka birşey. Fakat dışından başkası kodu anlamaya çalıştığında, şaşıracak ve aslında hiç bir bilgi olmadığını anlayacak
+    Bir taraftan değişken isimleri hala bir şey ifade ediyor. Değişkenin içinde ne var bunu söylüyor: karakter, sayı veya başka bir şey. Fakat dışından başkası kodu anlamaya çalıştığında, şaşıracak ve aslında hiçbir bilgi olmadığını anlayacak
 
     Gerçektende değerin tipi hata ayıklarken kolayca bulunabilir. Fakat ya anlamı? Hangi karakter veya sayıyı tutuyor? Bu sorunun cevabı anca iyi bir meditasyon ile bulunabilir!
 
@@ -97,9 +97,9 @@ Hepsinden zoru karanlık odada kara kediyi bulmak, hele bir de odada kedi yoksa.
 
 *Aynı şeyler* için *birbirine yakın* şeyler kullanmak hayatı daha ilginç kılar ve sizin yaratıcılığınız topluma gösterme açısından iyi bir fırsattır.
 
-Örneğin, fonksiyon öneklerini kullanın. Eğer bir fonksiyon ekrana çıktı veriyorsa `display_` ön eki ile başlayın. Örneğin `displayMessage`. Sonrasında başka bir fonksiyonda ekrana yine birşey yazdırmak isterseniz bu defa `show_` kullanın. Örneğin `showName`
+Örneğin, fonksiyon öneklerini kullanın. Eğer bir fonksiyon ekrana çıktı veriyorsa `display_` ön eki ile başlayın. Örneğin `displayMessage`. Sonrasında başka bir fonksiyonda ekrana yine bir şey yazdırmak isterseniz bu defa `show_` kullanın. Örneğin `showName`
 
-Bu fonksiyonlar için hiç bir farklılık olmasada sanki farklılık varmış hissi yaratın.
+Bu fonksiyonlar için hiçbir farklılık olmasada sanki farklılık varmış hissi yaratın.
 
 Diğer ninjalarla birleşip: Eğer Ahmet ekranda yazı gösteren fonksiyona `display..` ile başlıyorsa, Mehmet `render..` ile başlasın, Mehtapta `paint..` kullansın gibi kararlar verebilirsiniz. Düşünün kod ne kadar da ilginç ve çeşitli olur.
 
@@ -146,7 +146,7 @@ function ninjaFonksiyonu(elem) {
 
 ## Eğlence için alttan çizgi kullanmak.
 
-Değişken isimlerinden önce alttan çizgi kullanın `_`, `__` gibi. Örneğin `_isim` veya `__deger` gibi. Bunun anlamını sadece siz biliyorsanız harika olur. Veya, daha iyisi, bunları eğlencesine ekleyin. Hiç bir anlamı olmasın. Farklı yerlerde farklı anlamlara gelsin.
+Değişken isimlerinden önce alttan çizgi kullanın `_`, `__` gibi. Örneğin `_isim` veya `__deger` gibi. Bunun anlamını sadece siz biliyorsanız harika olur. Veya, daha iyisi, bunları eğlencesine ekleyin. hiçbir anlamı olmasın. Farklı yerlerde farklı anlamlara gelsin.
 
 Bir taşla iki kuş vurdunuz. Önce kodu daha uzun ve daha az okunabilir yaptınız, ikinci olarak, yazılımcı dostunuzu tongaya düşürerek alttan çizginin ne anlama geldiğini bulması için uzunca bir süre uğraşmasını sağladınız.
 
@@ -156,14 +156,14 @@ Zeki bir ninja bir yerde alttan çizgi kullanır, başka bir yerde kullanmaz. B
 
 Herkese varlık(entity)larınızın ne kadar mükemel olduğunu gösterin. Örneğin `harikaElement`, `guzelAlert`, `cokAkilliNinja` gibi isimlendirmeler kodunuzu okuyanları aydınlatacaktır.
 
-Gerçekten de bir yandan `super...`, `harika...`, `mega...` gibi kullanmış fakat diğer yandan hiç bir detay vermemiş olursunuz. Okuyucunun bunun altında yatan anlamı bulması için bir kaç saat meditasyon yapıp hayatını sorgulaması gerekmektedir.
+Gerçekten de bir yandan `super...`, `harika...`, `mega...` gibi kullanmış fakat diğer yandan hiçbir detay vermemiş olursunuz. Okuyucunun bunun altında yatan anlamı bulması için bir kaç saat meditasyon yapıp hayatını sorgulaması gerekmektedir.
 
 
 ## Global değişkenlerin veya dıştaki değişkenlerin üzerine başka değer yazın
 
 ```quote author="Guan Yin Zi"
-Işıktayken karanlıktaki hiç bir şey görünmez<br>
-Karanlıktayken, aydınlıktaki herşey görünür.
+Işıktayken karanlıktaki hiçbir şey görünmez<br>
+Karanlıktayken, aydınlıktaki her şey görünür.
 ```
 
 Fonksiyonun içinde ve dışında aynı değişken isimleri kullanın. Basit, fazladan efora hiç gerek yok!
@@ -190,11 +190,11 @@ Sonrasında dışta bulunan `kullanici` değişkenine bakacak ve `kullaniciBilgi
 
 ## Her yerde yan etki!
 
-Bazı fonksiyonlar hiç birşey değiştirmiyormuş gibi görünür. Örneğin `hazirMi()`, `izinKontrol()`, `tagbul()` gibi. Hesaplamaları yapıp veriyi geri döndürdüğü ve bunun dışında bir değişiklik yapılmadığı tahmin edilsin. Diğer bir deyişle "yan etkisi" olmadığı.
+Bazı fonksiyonlar hiçbir şey değiştirmiyormuş gibi görünür. Örneğin `hazirMi()`, `izinKontrol()`, `tagbul()` gibi. Hesaplamaları yapıp veriyi geri döndürdüğü ve bunun dışında bir değişiklik yapılmadığı tahmin edilsin. Diğer bir deyişle "yan etkisi" olmadığı.
 
 **En güzel kurnazlık bunlara kendi görevleri dışında "işe yarar" bir eylem yaptırın** 
 
-İş arkadaşınızın yüzündeki şaşkınlığı düşünebiliyor musunuz? `hazirMi`,`kontrolEt`, `bul...` gibi fonksiyonlar birşeyleri değiştiriyor. Gerçekten de sınırları zorlayan bir yöntem.
+İş arkadaşınızın yüzündeki şaşkınlığı düşünebiliyor musunuz? `hazirMi`,`kontrolEt`, `bul...` gibi fonksiyonlar bir şeyleri değiştiriyor. Gerçekten de sınırları zorlayan bir yöntem.
 
 **Yine bir başka şaşkınlık yaratacak yöntem ise standart olmayan bir sonuç döndürmek**
 
@@ -218,7 +218,7 @@ Ek eylemler fonksiyonun isminde kesinlikle belirtilmesin. Gerçek bir ninja prog
 
 **Birçok eylemi bir fonksiyona yazın ki kodun tekrardan kullanılmasını engelleyin**
 
-Düşünün ki, diğer yazılımcı sadece email'i kontrol etmek istiyor ve ekrana çıktı vermek istemiyor. Sizin fonksiyonunuz `emailDogrula(email)` ve hem doğruluk kontrolü yapıyor hemde ekrana hata çıktısı veriyor. Bundan dolayı size bu yazılımcının soracağı birşey olamaz. Siz zaten ikisini de yapmışsınız.
+Düşünün ki, diğer yazılımcı sadece email'i kontrol etmek istiyor ve ekrana çıktı vermek istemiyor. Sizin fonksiyonunuz `emailDogrula(email)` ve hem doğruluk kontrolü yapıyor hemde ekrana hata çıktısı veriyor. Bundan dolayı size bu yazılımcının soracağı bir şey olamaz. Siz zaten ikisini de yapmışsınız.
 
 ## Özet
 
diff --git a/1-js/03-code-quality/05-testing-mocha/article.md b/1-js/03-code-quality/05-testing-mocha/article.md
index fbda1ea47..690b7340f 100644
--- a/1-js/03-code-quality/05-testing-mocha/article.md
+++ b/1-js/03-code-quality/05-testing-mocha/article.md
@@ -10,7 +10,7 @@ Fonksiyon yazıldığında, genelde ne olması gerektiğini düşünürüz: hang
 
 Geliştirme yaparken, bu fonksiyonun çıktısı ile bekleneni birbiri ile karşılaştırılabilir. Örneğin bu konsolda yapılabilir.
 
-Eğer birşey yanlışsa kod değiştirilir ve tekrar çalıştırılır, ta ki doğru çalışana dek.
+Eğer bir şey yanlışsa kod değiştirilir ve tekrar çalıştırılır, ta ki doğru çalışana dek.
 
 Fakat bunları tekrar tekrar çalıştırmak iyi bir yöntem değildir.
 
@@ -18,7 +18,7 @@ Fakat bunları tekrar tekrar çalıştırmak iyi bir yöntem değildir.
 
 Örneğin, `f` diye bir fonksiyon yazılırken. Test: `f(1)` çalışır fakat `f(2)` çalışmaz. Kod düzeltildi, şimdi  `f(2)`çalışmakta. Tamamlandı mı? Fakat `f(1)` tekrar test edilmedi. Bu bir hataya neden olabilir.
 
-Bu çok tipiktir. Birşey geliştirirken çoğu zaman muhtemel olan durumları aklımızda tutarız. Fakat programcıların bu durumların tamamını aklında tutması beklenemez. Bundan dolayı bir tanesini düzeltirken diğerini kırmak çokça yaşanılan bir durumdur.
+Bu çok tipiktir. Bir şey geliştirirken çoğu zaman muhtemel olan durumları aklımızda tutarız. Fakat programcıların bu durumların tamamını aklında tutması beklenemez. Bundan dolayı bir tanesini düzeltirken diğerini kırmak çokça yaşanılan bir durumdur.
 
 
 **Otomatik testlerin koddan ayrı yazılması demektir. Kolayca çalıştırılır ve tüm durumları kontrol edebilir**
@@ -74,7 +74,7 @@ Genelde akış şu şekildedir:
 
 1. Başlangıçta en basit fonksiyonalite test edilir.
 2. Bunun uygulaması yapılmıştır.
-3. Çalışıp çalışmadığını  [Mocha](http://mochajs.org/) kullanarak yapabilirsiniz. Hata alındığında kod tekrar düzeltilmeli, taki herşey düzgün şekilde çalışana kadar.
+3. Çalışıp çalışmadığını  [Mocha](http://mochajs.org/) kullanarak yapabilirsiniz. Hata alındığında kod tekrar düzeltilmeli, taki her şey düzgün şekilde çalışana kadar.
 4. Şu anda çalışan ve uygulaması yapılmmış bir testiniz var.
 5. Daha fazla koşul ekleyerek bunların uygulamasını yazdığınızda testlerde hata almaya başlarsınız.
 6. Üçüncü adıma dönüp bu testlerin hatalarını düzeltene kadar hata almaya devam edersiniz.
@@ -170,7 +170,7 @@ Birbiri arasındaki fark eğer birinci `it` içindeki `assert` de hata varsa do
 
 Testleri ayrı ayrı yazmak ne olup bittiğini anlamak için daha iyidir, yani ikinci yöntem.
 
-Bunun haricinde bir takip edebileceğiniz ayrı bir kural da, **bir test birşeyi kontrol eder** mantığıdır. Eğer teste baktığınızda aslında kontrol edilmesi gereken iki şey vardır. Bundan dolayı ikiye ayırırsanız daha iyi olur.
+Bunun haricinde bir takip edebileceğiniz ayrı bir kural da, **bir test bir şeyi kontrol eder** mantığıdır. Eğer teste baktığınızda aslında kontrol edilmesi gereken iki şey vardır. Bundan dolayı ikiye ayırırsanız daha iyi olur.
 
 İkinci yöntem ile devam edecek olursak:
 
@@ -293,7 +293,7 @@ Testler bitti – tüm testlerden sonra (after)
 
 [edit src="beforeafter" title="Örneği sandbox'ta çalıştır"]
 
-Genelde `beforeEach/afterEach` (`before/each`) başlangıçta ösellikleri ayarlama, sayacı sıfırlama veya testler arasında birşey yapma gibi aksiyonları gerçekleştirir.
+Genelde `beforeEach/afterEach` (`before/each`) başlangıçta ösellikleri ayarlama, sayacı sıfırlama veya testler arasında bir şey yapma gibi aksiyonları gerçekleştirir.
 ````
 
 ## Özellikleri geliştirme
@@ -383,12 +383,12 @@ BDD'de önce özellikler yazılır sonra bunların uygulamaları yapılır. Sonu
 
 Özelliklere bakarak, güvenli bir şekilde kod geliştirilebilir, değiştirilebilir hatta fonksiyonlar yeniden yazılabilir.
 
-Bu aslında büyük projeler için daha önemlidir. Örneğin fonksiyonda bir yeri değiştirdiniz ve bir çok yerde aynı fonksiyon kullanılmış olsun. Bunu kullanan her yeri teker teker kontrol etmek oldukça zahmetli bir iştir. Fakat eğer test başarılı ise istediğinizi elde etmişsiniz demektir.
+Bu aslında büyük projeler için daha önemlidir. Örneğin fonksiyonda bir yeri değiştirdiniz ve birçok yerde aynı fonksiyon kullanılmış olsun. Bunu kullanan her yeri teker teker kontrol etmek oldukça zahmetli bir iştir. Fakat eğer test başarılı ise istediğinizi elde etmişsiniz demektir.
 
 Testler olmazsa geliştiriciler iki şekilde devam edebilir:
 
-1. Değişiklik ne olursa olsun yapılır. Sonrasında kullanıcılar bug bulur ve bunları bize bildirir. Tabi bu sizin için normal birşeyse eğer. 
-2. Veya geliştiriciler bu fonksiyona dokunmaya çekinir, eğer gerçekten önemli bir fonksiyonsa bunun altından kalkılamayabilir. Bundan dolayı fonksiyonlara dokunmaya dokunmaya bir çok fonksiyon yazılır ve herkes kendine ait kodu kullanır.
+1. Değişiklik ne olursa olsun yapılır. Sonrasında kullanıcılar bug bulur ve bunları bize bildirir. Tabi bu sizin için normal bir şeyse eğer. 
+2. Veya geliştiriciler bu fonksiyona dokunmaya çekinir, eğer gerçekten önemli bir fonksiyonsa bunun altından kalkılamayabilir. Bundan dolayı fonksiyonlara dokunmaya dokunmaya birçok fonksiyon yazılır ve herkes kendine ait kodu kullanır.
 
 **Otomatik test edilmiş kod ise bunun tam anlamıyla zıttıdır**
 
@@ -404,6 +404,6 @@ Gerçek hayatta bu bazen kolay olmayabilir. Bazen gerçekten özellikleri yazmak
 
 ## Sırada ne var?
 
-Bu ders sonunda bir çok test ile iç içi görev bulacaksınız. Böylece daha pratiğe dayalı örnekler yapabileceksiniz.
+Bu ders sonunda birçok test ile iç içi görev bulacaksınız. Böylece daha pratiğe dayalı örnekler yapabileceksiniz.
 
 Test yazmak iyi JavaScript bilgisi gerektirir. Fakat siz daha yeni öğrenmeye başladınız. Bundan dolayı şimdilik bu kadar yeterli, bundan sonra test yazmanıza gerek yok. Eğer daha karmaşık olsalar bile bu derste gördüğünüz örneklerden yola çıkarak bunları okuyabilirsiniz.
diff --git a/1-js/04-object-basics/01-object/3-is-empty/task.md b/1-js/04-object-basics/01-object/3-is-empty/task.md
index 07b46fb48..1e2af465f 100644
--- a/1-js/04-object-basics/01-object/3-is-empty/task.md
+++ b/1-js/04-object-basics/01-object/3-is-empty/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Boş olup olmadığını kontrol et
 
-`bosMu(obj)` adında bir fonksiyon tanımla ve eğer objenin hiç bir özelliği yok ise `true`, var ise `false` döndersin.
+`bosMu(obj)` adında bir fonksiyon tanımla ve eğer objenin hiçbir özelliği yok ise `true`, var ise `false` döndersin.
 
 Should work like that:
 
diff --git a/1-js/04-object-basics/01-object/4-const-object/solution.md b/1-js/04-object-basics/01-object/4-const-object/solution.md
index 5bee72091..668a7f0fc 100644
--- a/1-js/04-object-basics/01-object/4-const-object/solution.md
+++ b/1-js/04-object-basics/01-object/4-const-object/solution.md
@@ -1,4 +1,4 @@
-Tabi ki çalışır, hiç bir problem yok.
+Tabi ki çalışır, hiçbir problem yok.
 
 `const` sadece değişkenin kendisinin değişmesine engel olur.
 
diff --git a/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/test.js b/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/test.js
index 5873106fd..d797bf995 100644
--- a/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/test.js
+++ b/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/test.js
@@ -11,7 +11,7 @@ describe("ikiIleCarp", function () {
     assert.equal(menu.baslik, "Menü");
   });
 
-  it("birşey döndürmez", function () {
+  it("bir şey döndürmez", function () {
     assert.isUndefined(ikiIleCarp({}));
   });
 
diff --git a/1-js/04-object-basics/01-object/8-multiply-numeric/task.md b/1-js/04-object-basics/01-object/8-multiply-numeric/task.md
index b59abd03b..217726f74 100644
--- a/1-js/04-object-basics/01-object/8-multiply-numeric/task.md
+++ b/1-js/04-object-basics/01-object/8-multiply-numeric/task.md
@@ -26,7 +26,7 @@ menu = {
 };
 ```
 
-Dikkat ederseniz `multiplyNumeric` birşey döndürmedi, öyleyse değişikliği olduğu yerde yapmak zorunda.
+Dikkat ederseniz `multiplyNumeric` bir şey döndürmedi, öyleyse değişikliği olduğu yerde yapmak zorunda.
 Not: `typeof` ile objenin tipinin `numeric` olup olmadığını kontrol edebilirsiniz.
 
 
diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 34f42fad3..a6d22a86d 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -1,7 +1,7 @@
 
 # Objeler
 
-<info:types> bölümünde hatırlanacağı üzere, JavaScript'te yedi tane farklı tip olduğundan bahsedilmşiti. Altı tanesi "basit" tipler, değerleri sadece tek birşeye eşit olabilir. ( karakter dizisi, sayı vs.)
+<info:types> bölümünde hatırlanacağı üzere, JavaScript'te yedi tane farklı tip olduğundan bahsedilmşiti. Altı tanesi "basit" tipler, değerleri sadece tek bir şeye eşit olabilir. ( karakter dizisi, sayı vs.)
 
 Buna karşın objeler anahtar bilgileri ile değerlerini tutar ve daha karmaşık veri yapıları oluşturabilirler. JavaScript'te bu objeler dilin neredeyse her alanına etki etmiş durumdadır. Bundan dolayı daha derinlere inmeden nasıl çalıştıklarının öğrenilmesi gerekmekte.
 
@@ -707,7 +707,7 @@ Eğer objenin "gerçek kopyası" , veya diğer bir deyişle `klonu` yapılmak is
 
 Bu bölümde "basit obje" veya `Obje` konusunu işlendi.
 
-JavaScript'te bir çok çeşit obje bulunmaktadır:
+JavaScript'te birçok çeşit obje bulunmaktadır:
 
 - `Dizi` sıralı olarak verileri tutar.,
 - `Date` Tarih ve saat bilgilerini tutar.,
diff --git a/1-js/04-object-basics/02-garbage-collection/article.md b/1-js/04-object-basics/02-garbage-collection/article.md
index 05cf04f8d..9fa73c653 100644
--- a/1-js/04-object-basics/02-garbage-collection/article.md
+++ b/1-js/04-object-basics/02-garbage-collection/article.md
@@ -10,7 +10,7 @@ JavaScript'te hafıza yönetimi *erişilebilirlik* konsepti üzerinden olur.
 
 Basit bir şekilde; *erişilebilir* değerler yararlıdır mantığı vardır. Bunlar kesinlikle hafızada yer alır.
 
-1. Başlangıçta varsayılan olarak var olan *erişilebilir* değerler bulunmaktadır bunlar hiç bir zaman silinemez.
+1. Başlangıçta varsayılan olarak var olan *erişilebilir* değerler bulunmaktadır bunlar hiçbir zaman silinemez.
 
     Örneğin:
     - O anda içinde bulunulan fonksiyonların yerel değişkenleri.
@@ -118,7 +118,7 @@ Fakat ikisini birden silerseniz, İhsan'a erişilemez:
 
 ![](family-no-father.svg)
 
-Dışarı giden referanslar önemli değildir. Sadece içeri gelenler o objeyi *ulaşılabilir* yapar. Öyleyse artık İhsan erişilemez ve hafızadan silinecektir. Ayrıca hiç bir verisine de erişilemez.
+Dışarı giden referanslar önemli değildir. Sadece içeri gelenler o objeyi *ulaşılabilir* yapar. Öyleyse artık İhsan erişilemez ve hafızadan silinecektir. Ayrıca hiçbir verisine de erişilemez.
 
 Çöp toplmaa işleminden sonra:
 
@@ -179,7 +179,7 @@ Son adım olarak ziyaret edilmeyen objeler "ulaşılamaz" addedilip silinir:
 
 ![](garbage-collection-5.svg)
 
-JavaScript motoru bunu hızlıca çalıştırmak ve kodun çalışmasını etkilememek için bir çok optimizsyon yapar.
+JavaScript motoru bunu hızlıca çalıştırmak ve kodun çalışmasını etkilememek için birçok optimizsyon yapar.
 
 
 Bazı Optimizasyonlar:
@@ -208,6 +208,6 @@ Genel bir kitap önerisi olarak "The Garbage Collection Handbook: The Art of Aut
 
 Eğer alt seviye diller ile aranız iyi ise, daha derinlemesine bilgiyi aşağıdaki makaleden edinebilirsiniz: [A tour of V8: Garbage Collection](http://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection).
 
-[V8 blog](http://v8project.blogspot.com/) Arada bir hafıza yönetimi hakkında belge yayınlamaktadır. Doğal olarak, çöp toplama hakkında bilgi sahibi olunmak isteniyorsa dahili yapıların bilinmesi gerekmektedir. Bu yapılar [Vyacheslav Egorov](http://mrale.ph) takip edilerek öğrenilebilir. Kendisi "V8" motoru mühendislerindendir. "V8"in önerilmesinin nedeni internette hakkında çokça bilgi bulunabilmesinden dolayıdır. Diğer motorlar için çoğu yaklaşım benzerdir fakat çöp toplama bir çok yönden farklılık gösterir.
+[V8 blog](http://v8project.blogspot.com/) Arada bir hafıza yönetimi hakkında belge yayınlamaktadır. Doğal olarak, çöp toplama hakkında bilgi sahibi olunmak isteniyorsa dahili yapıların bilinmesi gerekmektedir. Bu yapılar [Vyacheslav Egorov](http://mrale.ph) takip edilerek öğrenilebilir. Kendisi "V8" motoru mühendislerindendir. "V8"in önerilmesinin nedeni internette hakkında çokça bilgi bulunabilmesinden dolayıdır. Diğer motorlar için çoğu yaklaşım benzerdir fakat çöp toplama birçok yönden farklılık gösterir.
 
 Alt-seviye optimizasyonu istendiğinde derinlemesine bilgi sahibi olunması gerekmektedir. JavaScript dilini öğrendikten sonra bu yolda ilerlenmesi daha mantıklı olur.
diff --git a/1-js/04-object-basics/03-symbol/article.md b/1-js/04-object-basics/03-symbol/article.md
index 116ca39fc..2ed7c3810 100644
--- a/1-js/04-object-basics/03-symbol/article.md
+++ b/1-js/04-object-basics/03-symbol/article.md
@@ -20,7 +20,7 @@ Ayrıca sembollere tanım açıklama ( sembol ismi ) verilebilir. Bu genelde hat
 // id açıklaması "id" olan bir semboldür.
 let id = Symbol("id");
 ```
-Sembollerin eşsiz oldukları garantidir. Eğer aynı açıklamaya ( sembol ismi ) ait iki sembol olsa bile değerleri farklıdır. Bu açıklama sadece etikettir. Hiç birşeyi etkilemez.
+Sembollerin eşsiz oldukları garantidir. Eğer aynı açıklamaya ( sembol ismi ) ait iki sembol olsa bile değerleri farklıdır. Bu açıklama sadece etikettir. hiçbir şeyi etkilemez.
 
 Örneğin aşağıdaki iki sembol aynı açıklamalara aittir -- eşit değillerdir:
 
@@ -86,7 +86,7 @@ let id = Symbol("id");
 
 kullanici[id] = "Id değeri";
 ```
-Artık birbiri ile hiç bir ayrılık olmayacaktır, hatta aynı isme sahip olsalar bile.
+Artık birbiri ile hiçbir ayrılık olmayacaktır, hatta aynı isme sahip olsalar bile.
 
 Şimdi bu `"id"`'nin karakter dizisi olduğunu varsayın, eğer başkası aynı isim ile `id` objeye veri eklemeye çalışırsa bu durumda *ayrılık* olacaktır.
 
@@ -235,7 +235,7 @@ alert( Symbol.keyFor(Symbol("isim2")) ); // tanımsız, bu argüman sembol kayı
 
 ## System sembolleri
 
-JavaScript içinde tanımlı bir çok "sistem" sembolü bulunmaktadır. Bunları farklı yönlerden objeler içinde kullanmak mümkündür.
+JavaScript içinde tanımlı birçok "sistem" sembolü bulunmaktadır. Bunları farklı yönlerden objeler içinde kullanmak mümkündür.
 
 Bu semboller [Bilinen semboller](https://tc39.github.io/ecma262/#sec-well-known-symbols) tablosundan kontrol edilebilir:
 
diff --git a/1-js/04-object-basics/04-object-methods/2-check-syntax/solution.md b/1-js/04-object-basics/04-object-methods/2-check-syntax/solution.md
index d877f518c..00c5cb0c3 100644
--- a/1-js/04-object-basics/04-object-methods/2-check-syntax/solution.md
+++ b/1-js/04-object-basics/04-object-methods/2-check-syntax/solution.md
@@ -22,7 +22,7 @@ let kullanici = { selamVer:... }(kullanici.selamVer)()
 
 Bu şekilde çağırıldığında, `let kullanici` ile çağrı aynı satırda yapılmış olur. Ayrıca bu tanımlanan fonksiyon `(kullanici.selamVer)` şeklinde aynı satırda argüman olarak kullanılmıştır. Bundan dolayı da hata oluşmaktadır.
 
-Eğer noktalı virgül koyarsanız herşey beklediğiniz gibi çalışır:
+Eğer noktalı virgül koyarsanız her şey beklediğiniz gibi çalışır:
 
 ```js run
 let kullanici = {
diff --git a/1-js/04-object-basics/04-object-methods/article.md b/1-js/04-object-basics/04-object-methods/article.md
index 0a2742a04..54489a1c3 100644
--- a/1-js/04-object-basics/04-object-methods/article.md
+++ b/1-js/04-object-basics/04-object-methods/article.md
@@ -176,7 +176,7 @@ function selamVer() {
 }
 ```
 
-`this`'in değeri çalışma anında değerlendirilir. Herşey olabilir.
+`this`'in değeri çalışma anında değerlendirilir. Her şey olabilir.
 
 Örneğin `this` farklı objelerden çağırıldıklarında değerler alabilirler:
 
diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 23e4e0277..2b5c9408f 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -78,7 +78,7 @@ let kullanici = new function() {
   // mantıklar veya yerel değişkenler
 };
 ```
-Yapıcı fonksiyon tekrar çağırılamaz çünkü hiç bir yere kayıt edilmemiştir, sadece yaratılır ve çağırılır. Böylece yapıcı metod ilerde tekrar kullanılmayacağına garanti verir.
+Yapıcı fonksiyon tekrar çağırılamaz çünkü hiçbir yere kayıt edilmemiştir, sadece yaratılır ve çağırılır. Böylece yapıcı metod ilerde tekrar kullanılmayacağına garanti verir.
 ````
 
 ## Yapıcı modu testi: new.target
@@ -117,7 +117,7 @@ function Kullanici(isim) {
 let ihsan = Kullanici("John"); // çağrıyı new Kullanici(isim) fonksiyonuna yönlendirir.
 alert(ihsan.isim); // İhsan
 ```
-Bu yaklaşım bazı kütüphanelerde yazımı daha esnek yapabilmek amacıyla kullanılır.  Her yerde kullanılması o kadar da iyi değildir. Çünkü `new` ne olup bittiği hakkında bilgi vermektedir. `new` ile yeni bir obje yaratıldığını anlayabiliyorsunuz ki bu da iyi birşeydir.
+Bu yaklaşım bazı kütüphanelerde yazımı daha esnek yapabilmek amacıyla kullanılır.  Her yerde kullanılması o kadar da iyi değildir. Çünkü `new` ne olup bittiği hakkında bilgi vermektedir. `new` ile yeni bir obje yaratıldığını anlayabiliyorsunuz ki bu da iyi bir şeydir.
 
 ## Yapıcı metodun return sözcüğü
 
@@ -142,7 +142,7 @@ function BuyukKullanici() {
 
 alert( new BuyukKullanici().isim );  // Muhsin, objeyi aldık ^^
 ```
-Şimdi ise boş bir `return` cümlesi yazalım( eğer ilkel bir tipte kullanılsa birşey değiştirmez)
+Şimdi ise boş bir `return` cümlesi yazalım( eğer ilkel bir tipte kullanılsa bir şey değiştirmez)
 
 ```js run
 function KucukKullanici() {
diff --git a/1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md b/1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md
index 4ce05b08c..2a2d561ec 100644
--- a/1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md
+++ b/1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md
@@ -18,7 +18,7 @@ Neden? Ne olduğuna `(*)` satırından bakarsanız:
 2. Bundan dolayı obje `test` özelliğini alır.
 3. "obje kabı" kaybolur ve işlem tamamlanır.
 
-Öyleyse `str` nin son satırında özelliğe ait hiç bir iz yoktur. İlkel tipin üzerinde yapılan değişiklik için yeni obje kabı üretilir.
+Öyleyse `str` nin son satırında özelliğe ait hiçbir iz yoktur. İlkel tipin üzerinde yapılan değişiklik için yeni obje kabı üretilir.
 
 Bazı tarayıcılar ilkel tiplere yeni özellik tanımlanmasına izin vermezler. Bundan dolayı `(*)` bölümünde `undefined` değil de hata da görebilirsiniz. Bu aslında özelliklerin dışında bir uygulamadır.
 
diff --git a/1-js/05-data-types/01-primitives-methods/article.md b/1-js/05-data-types/01-primitives-methods/article.md
index 2f3fcf6a6..62e78b687 100644
--- a/1-js/05-data-types/01-primitives-methods/article.md
+++ b/1-js/05-data-types/01-primitives-methods/article.md
@@ -38,7 +38,7 @@ Objeler ilkellere göre daha "ağırdırlar". Daha fazla kaynak gerektirirler. F
 
 Burada JavaScript'i oluşturan kişiler ikilem ile karşılaşmışlardır:
 
-- Karakter dizisi veya sayı gibi ilkel tipler ile bir çok şey yapılmak istenebilir. Bunlara metod eklenmesine izin vermek harika olur.
+- Karakter dizisi veya sayı gibi ilkel tipler ile birçok şey yapılmak istenebilir. Bunlara metod eklenmesine izin vermek harika olur.
 - İlkel tipler olabildiğince hızlı olmalıdır.
 
 Çözüm biraz garip :
diff --git a/1-js/05-data-types/02-number/2-why-rounded-down/solution.md b/1-js/05-data-types/02-number/2-why-rounded-down/solution.md
index 61341fb4e..8a75e3cbb 100644
--- a/1-js/05-data-types/02-number/2-why-rounded-down/solution.md
+++ b/1-js/05-data-types/02-number/2-why-rounded-down/solution.md
@@ -20,7 +20,7 @@ Tam sayı değerini yuvarlama değerine yaklaştırılırsa problem çözülür:
 ```js run
 alert( (6.35 * 10).toFixed(20) ); // 63.50000000000000000000
 ```
-`63.5` hiç bir kayba uğramıyor dikkat ederseniz. Çünkü `0.5` lik fark aslında `1/2`. `2` ve üstü ile yapılan işlemler binary sistemde tam olarak ifade edildiğinden dolayı bu problem çözülmektedir.
+`63.5` hiçbir kayba uğramıyor dikkat ederseniz. Çünkü `0.5` lik fark aslında `1/2`. `2` ve üstü ile yapılan işlemler binary sistemde tam olarak ifade edildiğinden dolayı bu problem çözülmektedir.
 
 
 ```js run
diff --git a/1-js/05-data-types/02-number/4-endless-loop-error/solution.md b/1-js/05-data-types/02-number/4-endless-loop-error/solution.md
index 138e4e655..e28a5297f 100644
--- a/1-js/05-data-types/02-number/4-endless-loop-error/solution.md
+++ b/1-js/05-data-types/02-number/4-endless-loop-error/solution.md
@@ -1,4 +1,4 @@
-Çünkü `i` hiç bir zaman `10` olmaz.
+Çünkü `i` hiçbir zaman `10` olmaz.
 
 Aşağıdaki kodu çalıştırın ve gerçek `i` değerini görün:
 
@@ -9,7 +9,7 @@ while (i < 11) {
   if (i > 9.8 && i < 10.2) alert( i );
 }
 ```
-Hiç birisi tam olarak `10` olmayacaktır.
+hiçbirisi tam olarak `10` olmayacaktır.
 
 Bunun olmasının nedeni `0.2` eklediğimizde kesinlik kaybı olur.
 
diff --git a/1-js/05-data-types/02-number/4-endless-loop-error/task.md b/1-js/05-data-types/02-number/4-endless-loop-error/task.md
index 7b0de1cbf..1d697238f 100644
--- a/1-js/05-data-types/02-number/4-endless-loop-error/task.md
+++ b/1-js/05-data-types/02-number/4-endless-loop-error/task.md
@@ -4,7 +4,7 @@ importance: 4
 
 # Infinite loop
 
-Aşağıdaki döngü neden sonsuzdur ve hiç bir zaman bitmez?
+Aşağıdaki döngü neden sonsuzdur ve hiçbir zaman bitmez?
 s
 ```js
 let i = 0;
diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md
index 0e8c69853..4db5dbb71 100644
--- a/1-js/05-data-types/02-number/article.md
+++ b/1-js/05-data-types/02-number/article.md
@@ -4,7 +4,7 @@ JavaScript'te tüm sayılar 64-bit formatında tutulur [IEEE-754](http://en.wiki
 
 Sayılar ile ilgili bilinenlerin üzerinden tekrar geçecek olunursa.
 
-## Sayıyı yazmanın bir çok yolu
+## Sayıyı yazmanın birçok yolu
 
 Diyelim ki 1 milyar yazmak istiyorsunuz. Şu şekilde:
 
@@ -188,7 +188,7 @@ alert( 0.1 + 0.2 ); // 0.30000000000000004
 ```
 Yok artık! Burada yanlış karşılaştırmanın sonuçlarını gördünüz. Düşünün bir e-ticaret sitesi yapıyorsunuz. Kullanıcı `0.10₺` ve `0.20₺` lik iki tane çiklet ekledi sepetine. Sonuçta toplam `$0.30000000000000004` oldu. Sitenize gelen kişinin kafası karışacaktır.
 
-Peki neden böyle birşey oluyor?
+Peki neden böyle bir şey oluyor?
 
 Sayı hafızada binary formatta tutulur. Fakat ondalık bölümleri `0.1`, `0.2` gibi desimal sistemde çok basit gibi duran sayılar aslında bitmez bir binary forma sahiptir.
 
@@ -232,7 +232,7 @@ Bu problemden nasıl kurtulunur? Tabi bunun için bir kaç yöntem mevcuttur:
     ```js run
     alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3
     ```
-    Aşağıdaki gibi çalışır `0.1 * 10 = 1` ve `0.2 * 10 = 2` sonrasında iki tam sayı hiç bir ondalık bölüm olmadan toplanır böylece küsürat kaybı ortadan kalkar.
+    Aşağıdaki gibi çalışır `0.1 * 10 = 1` ve `0.2 * 10 = 2` sonrasında iki tam sayı hiçbir ondalık bölüm olmadan toplanır böylece küsürat kaybı ortadan kalkar.
 
 3. Eğer e-ticaret sitesi üzerinde çalışıyorsanız. En radikal çözüm tüm küsüratları kuruş olarak kaydedip hiç küsürat kullanmamak olabilir. Fakat ya %30 indirip yapmak isterseniz? Pratikte bu kullanım çok nadirdir. Bundan dolayı yukarıdaki iki şekilde problem çözülebilir.
 
@@ -275,7 +275,7 @@ Her ikisi de `number` tipine aittirler, fakat "normal" sayı değildirler. Bunda
     alert( isNaN("str") ); // true
     ```
     
-    Bu fonksiyona ihtiyacınız var mı? Sadece === NaN kullanılsa ? Malesef ihtiyaç var. `NaN` kendi başına hiç bir şeye eşit değildir, hatta kendisine bile:
+    Bu fonksiyona ihtiyacınız var mı? Sadece === NaN kullanılsa ? Malesef ihtiyaç var. `NaN` kendi başına hiçbir şeye eşit değildir, hatta kendisine bile:
     
     ```js run
     alert( NaN === NaN ); // false
@@ -334,7 +334,7 @@ alert( parseFloat('12.5em') ); // 12.5
 alert( parseInt('12.3') ); // 12, sadece tamsayı bölümü alındı
 alert( parseFloat('12.3.4') ); // 12.3, birinci noktadan sonra yeniden nokta gördüğünde işlemi tamamladı
 ```
-Eğer hiç bir basamak okunamazsa `NaN` dönderirler.
+Eğer hiçbir basamak okunamazsa `NaN` dönderirler.
 
 ```js run
 alert( parseInt('a123') ); // NaN, ilk harf işlemi durdurur.
diff --git a/1-js/05-data-types/03-string/article.md b/1-js/05-data-types/03-string/article.md
index 7703d129e..d78d8754b 100644
--- a/1-js/05-data-types/03-string/article.md
+++ b/1-js/05-data-types/03-string/article.md
@@ -15,7 +15,7 @@ let cift = "çift-tırnak";
 
 let us_isareti = `üs işareti`; // Backticks
 ```
-Tek ve çift tırnak zaten aynıydı. Üs işareti ise JavaScript ifadelerini karakter dizisine yerleştirmenizi sağlar. Bu fonksiyon çağrısı dahil herşey olabilir:
+Tek ve çift tırnak zaten aynıydı. Üs işareti ise JavaScript ifadelerini karakter dizisine yerleştirmenizi sağlar. Bu fonksiyon çağrısı dahil her şey olabilir:
 
 ```js run
 function toplam(a, b) {
@@ -559,7 +559,7 @@ alert( '𝒳'[0] ); // garip semboller...
 alert( '𝒳'[1] ); // ...her biri ikilinin parçaları
 ```
 
-Dikkat ederseniz çifli karakterler tek başlarına birşey ifade etmezler. Yani yukarıdaki örnekler aslında hiç bir işe yaramaz.
+Dikkat ederseniz çifli karakterler tek başlarına bir şey ifade etmezler. Yani yukarıdaki örnekler aslında hiçbir işe yaramaz.
 
 Teknik olarak, bu çiftler kodlarına bakılarak ayırt edilebilir: Eğer bir karakter `0xd800..0xdbff` aralığında ise bu çiftin ilk karakteri demektir. İkinci karakter ise `0xd800..0xdbff` aralığında olmalıdır. Bu aralıklar özel olarak çiftler için ayrılmıştır.
 
@@ -571,7 +571,7 @@ Yukarıdaki duruma göre:
 alert( '𝒳'.charCodeAt(0).toString(16) ); // d835, 0xd800 ile 0xdbff arasında
 alert( '𝒳'.charCodeAt(1).toString(16) ); // dcb3, 0xdc00 ile 0xdfff arasında
 ```
-<info:iterable> bölümünde bu çifler ile ilgili daha fazla bilgi bulabilirsiniz. Muhtemelen bunun ile ilgili kütüphaneler de vardır, fakat burada önerecek kadar meşur olan yok henüz.
+<info:iterable> bölümünde bu çifler ile ilgili daha fazla bilgi bulabilirsiniz. Muhtemelen bunun ile ilgili kütüphaneler de vardır, fakat burada önerecek kadar meşhur olan yok henüz.
 
 ### Aksan işaretleri ve normalleştirme
 
diff --git a/1-js/05-data-types/04-array/article.md b/1-js/05-data-types/04-array/article.md
index 0b384bef9..c02e13b88 100644
--- a/1-js/05-data-types/04-array/article.md
+++ b/1-js/05-data-types/04-array/article.md
@@ -221,7 +221,7 @@ Fakat bu durumda JavaScript motoru bizim diziler ile değil de normal objeler ü
 Diziyi yanlış kullanma biçimleri:
 
 - Sayısal olmayan bir özellik ekle `arr.test = 5`
-- Delikler yap: `arr[0]` ekle sonra `arr[1000]` ekle ( arada hiç bir değer yok)
+- Delikler yap: `arr[0]` ekle sonra `arr[1000]` ekle ( arada hiçbir değer yok)
 - Diziyi ters sıralı şekilde doldur, `arr[1000]`, `arr[999]` vs.
 
 Dizileri sıralı şekilde veri tutan özel bir yapı olarak düşünün. Bunun için özel metodlara sahiptir. JavaScript motoru içerisinde diziler çok etkili ve hızlı bir şekilde çalıştırılmak üzere ayarlanmıştır. Sizde bu şekilde kullanmaya hassasiyet gösterin. Eğer özelliği belirtmek istiyorsanız, belki de normal obje kullanmanız gerekmektedir `{}`
@@ -261,7 +261,7 @@ fruits.pop(); // Sondan bir eleman al
 
 ![](array-pop.svg)
 
-**`pop` hiç birşey taşımaz çünkü diğer elemanların `index`'i değişmez. Bundan dolayı aşırı derecede hızlıdır**
+**`pop` hiçbir şey taşımaz çünkü diğer elemanların `index`'i değişmez. Bundan dolayı aşırı derecede hızlıdır**
 
 `push`'da aynı şekilde sona ekler.
 
@@ -329,7 +329,7 @@ Genelde diziler bu şekilde kullanılmaz.
 
 `length` hakkında diğer bir ilginç bilgi ise bu özelliğin yazılabilir olmasıdır.
 
-Eğer elle bu değeri yükseltirseniz hiç birşey olmaz, fakat düşürürseniz dizideki elemanlar silinir. Bu işlem geri döndürülemez, örneğin:
+Eğer elle bu değeri yükseltirseniz hiçbir şey olmaz, fakat düşürürseniz dizideki elemanlar silinir. Bu işlem geri döndürülemez, örneğin:
 
 ```js run
 let arr = [1, 2, 3, 4, 5];
@@ -353,7 +353,7 @@ let arr = *!*new Array*/!*("Elma", "Armut", "vs");
 
 Bu şekilde yazım daha nadir kullanılır, `[]` kullanımı daha kısadır. Farklı bir özelliği daha vardır:
 
-Eğer `new Array` sayı argümanı ile çağırılırsa, yeni bir boş dizi yaratır. İçerisine birşey koymaz ve dizinin boyutunu belirtilen değer kadar tanımlar.
+Eğer `new Array` sayı argümanı ile çağırılırsa, yeni bir boş dizi yaratır. İçerisine bir şey koymaz ve dizinin boyutunu belirtilen değer kadar tanımlar.
 
 Bu özellik yanlış kullanıma müsaittir:
 
diff --git a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/test.js b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/test.js
index f1af97731..50a6d4ee3 100644
--- a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/test.js
+++ b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/test.js
@@ -9,7 +9,7 @@ describe("filterRangeInPlace", function () {
     assert.deepEqual(arr, [3, 1]);
   });
 
-  it("hiçbirşey döndürmez", function () {
+  it("hiçbir şey döndürmez", function () {
     assert.isUndefined(filterRangeInPlace([1, 2, 3], 1, 4));
   });
 
diff --git a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md
index aa7e71062..1f49c2e18 100644
--- a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md
+++ b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md
@@ -7,7 +7,7 @@ importance: 4
 
 `arr` alan ve `filterRangeInPlace(arr,a,b)` fonksiyonu ile `a` ile `b` arasındaki değerleri alıp ve bunun haricindekileri bu diziden silen fonksiyonu yazınız.
 
-Fonksiyon diziyi modifiye etmeli. Birşey döndürmemeli.
+Fonksiyon diziyi modifiye etmeli. Bir şey döndürmemeli.
 
 
 Örneğin:
diff --git a/1-js/05-data-types/05-array-methods/article.md b/1-js/05-data-types/05-array-methods/article.md
index 032a8a089..ccdc82656 100644
--- a/1-js/05-data-types/05-array-methods/article.md
+++ b/1-js/05-data-types/05-array-methods/article.md
@@ -1,6 +1,6 @@
 # Dizi Metodları
 
-Diziler bir çok metod sunarlar. İşleri daha kolaylaştırmak için bu bölüm ikiye ayrılacaktır.
+Diziler birçok metod sunarlar. İşleri daha kolaylaştırmak için bu bölüm ikiye ayrılacaktır.
 
 ## Elaman silme/ekleme
 
@@ -80,7 +80,7 @@ let removed = arr.splice(0, 2);
 
 alert( removed ); // "Ben", "şu" <-- silinen elemanlar
 ```
-`splice` metodu ayrıca hiç birşey silmeden de ekleme yapabilir. Bunun için `deleteCount`'u `0` yapmanız gerekmektedir:
+`splice` metodu ayrıca hiçbir şey silmeden de ekleme yapabilir. Bunun için `deleteCount`'u `0` yapmanız gerekmektedir:
 
 ```js run
 let arr = ["Ben", "JavaScript", "çalışıyorum"];
@@ -186,14 +186,14 @@ let arr = [1, 2];
 
 let arrayLike = {
   0: "başka",
-  1: "birşey",
+  1: "bir şey",
 *!*
   [Symbol.isConcatSpreadable]: true,
 */!*
   length: 2
 };
 
-alert( arr.concat(arrayLike) ); // 1,2,başka,birşey
+alert( arr.concat(arrayLike) ); // 1,2,başka,bir şey
 ```
 
 ## Dizide arama
@@ -330,7 +330,7 @@ arr.sort();
 
 alert( arr );  // *!*1, 15, 2*/!*
 ```
-Çıktısında birşey fark ettiniz mi?
+Çıktısında bir şey fark ettiniz mi?
 
 Sıralama `1, 15, 2` oldu. Yanlış. Neden peki?
 
@@ -370,7 +370,7 @@ alert(arr);  // *!*1, 2, 15*/!*
 ```
 Şimdi beklendiği gibi çalışmakta.
 
-Ne olduğunu düşünürsek. `arr` herşeyi tutabilir, değil mi? Sayı, karakter veya html elementi vs. tutabilir. İçinde bulunanları sıralamak için karşılaştırmayı yapan *sıralama fonksiyonu*na ihtiyaç vardır. Bunun da varsayılanı karakter sıralamadır.
+Ne olduğunu düşünürsek. `arr` her şeyi tutabilir, değil mi? Sayı, karakter veya html elementi vs. tutabilir. İçinde bulunanları sıralamak için karşılaştırmayı yapan *sıralama fonksiyonu*na ihtiyaç vardır. Bunun da varsayılanı karakter sıralamadır.
 
 `arr.sort(fn)` metodu içinde sıralama algoritmasına sahiptir. Bu sıralamanın nasıl çalıştığına dair bir bilgimiz olmasına gerek yok (Çoğu zaman [quicksort](https://en.wikipedia.org/wiki/Quicksort) kullanılır). Diziyi dolanır ve elemanları verilen algoritmaya göre karşılaştırır ve sıralar. Tek bilmeniz gereken `fn` fonksiyonunun karşılaştırmayı yaptığıdır.
 
@@ -567,7 +567,7 @@ Bundan dolayı her zaman başlangıç değeri kullanılması önerilir.
 Yazımı:
 ```js
 arr.forEach(function(item, index, array) {
-  // ... elemanla birşeyler yap
+  // ... elemanla bir şeyler yap
 });
 ```
 Örneğin aşağıdaki kod dizinin her elemanını göstermeye yarar:
@@ -675,7 +675,7 @@ Dizi metodlarının kısa açıklamaları:
   - `reduce(func, initial)` -- dizide bulunan elemanlar sıra ile `func` fonksiyonu üzerinden hesaplanır ve son değer döndürülür.
   
 - Elemanlar üzerinden dönme:
-  - `forEach(func)` -- dizide bulunan her eleman için `func` çağrılır. Hiç birşey döndürmez.
+  - `forEach(func)` -- dizide bulunan her eleman için `func` çağrılır. hiçbir şey döndürmez.
 
 - Ek olarak:
   - `Array.isArray(arr)`  `arr`'in dizi olup olmadığını kontrol eder.
@@ -699,5 +699,5 @@ Görünürde çok fazla metod varmış gibi ve ezberlemesi zormuş gibi görüns
 
 Sadece tanımların bulunduğu sayfaya bakmanız yeterlid. Ardından bu bölümdeki örnekleri çözerek pratik yaparsanız metodlar ile ilgili yeteri kadar bilgi sahibi olmuş olursunuz.
 
-Daha sonrasında metodlar ile ilgili birşey yapmak istediğinizde, nasıl yapıldığını bilmiyorsanız, buraya tekrar gelip doğru metodu bulabilirsiniz.
-Buradaki örnekler doğru bir şekilde yazmanıza yardımcı olacaktır. Sonrasında metodları hiç bir özel çaba harcamadan hatırlayacak duruma gelebilirsiniz.
+Daha sonrasında metodlar ile ilgili bir şey yapmak istediğinizde, nasıl yapıldığını bilmiyorsanız, buraya tekrar gelip doğru metodu bulabilirsiniz.
+Buradaki örnekler doğru bir şekilde yazmanıza yardımcı olacaktır. Sonrasında metodları hiçbir özel çaba harcamadan hatırlayacak duruma gelebilirsiniz.
diff --git a/1-js/05-data-types/06-iterable/article.md b/1-js/05-data-types/06-iterable/article.md
index d5fa59c24..f8134aa9c 100644
--- a/1-js/05-data-types/06-iterable/article.md
+++ b/1-js/05-data-types/06-iterable/article.md
@@ -154,7 +154,7 @@ while(true) {
   alert(result.value); //karakterlerin bir bir çıktısını verir.
 }
 ```
-Buna çok nadir ihtiyaç olur. Fakat bu bize `for..of`'tan daha fazla kontrol yetkisi verir. Örneğin bu sıralı erişim olayını bazen çalıştırıp bazen çalıştırma veya o ara birşeyler yaptırma mümkün olmaktadır.
+Buna çok nadir ihtiyaç olur. Fakat bu bize `for..of`'tan daha fazla kontrol yetkisi verir. Örneğin bu sıralı erişim olayını bazen çalıştırıp bazen çalıştırma veya o ara bir şeyler yaptırma mümkün olmaktadır.
 
 ## Döngüler ve dizi-benzerleri
 
diff --git a/1-js/05-data-types/07-map-set-weakmap-weakset/article.md b/1-js/05-data-types/07-map-set-weakmap-weakset/article.md
index 8fdf5087c..6f3d7fd93 100644
--- a/1-js/05-data-types/07-map-set-weakmap-weakset/article.md
+++ b/1-js/05-data-types/07-map-set-weakmap-weakset/article.md
@@ -229,7 +229,7 @@ Komiktir ki `Set` içerisindeki forEach` fonksiyonu 3 argümana sahiptir: bir de
 
 Bu, 3 argüman alan `forEach` fonksiyonuna sahip olan `Map` ile uyumlu olması için yapılmıştır.
 
-`Map`in sahip olduğu yineleme yapan fonksiyonlar burda da vardır:
+`Map`in sahip olduğu yineleme yapan fonksiyonlar burada da vardır:
 
 - `set.keys()` -- değerler için bir yinelenebilir nesne döndürür,
 - `set.values()` -- `set.keys` ile aynı, `Map` ile uyumlu olması için yapılmış,
diff --git a/1-js/05-data-types/10-date/4-get-date-ago/task.md b/1-js/05-data-types/10-date/4-get-date-ago/task.md
index 6adbf9f93..e820719d9 100644
--- a/1-js/05-data-types/10-date/4-get-date-ago/task.md
+++ b/1-js/05-data-types/10-date/4-get-date-ago/task.md
@@ -5,7 +5,7 @@ importance: 4
 
 `kacGunOnce(tarih,gün)` adında bir fonksiyon ile verilen `tarih`'ten `gün` kadar öncesini bulunuz.
 
-Örneğin, eğer bu gün 20'si ise, `kacGunOnce(new Date(),1)` size 19 döndürmeli. Yine `kacGunOnce(new Date(),2)` size 18 döndermeli.
+Örneğin, eğer bugün 20'si ise, `kacGunOnce(new Date(),1)` size 19 döndürmeli. Yine `kacGunOnce(new Date(),2)` size 18 döndermeli.
 
 Should also work over months/years reliably:
 
diff --git a/1-js/05-data-types/10-date/6-get-seconds-today/solution.md b/1-js/05-data-types/10-date/6-get-seconds-today/solution.md
index 68852777c..205cac3f7 100644
--- a/1-js/05-data-types/10-date/6-get-seconds-today/solution.md
+++ b/1-js/05-data-types/10-date/6-get-seconds-today/solution.md
@@ -1,4 +1,4 @@
-Bu gün geçen zamanı alabilmek için bu günün 00:00:00'ı için bir `tarih` objesi oluşturup bunu `şimdi`'nin `tarih` objesinden çıkarabilirsiniz. 
+Bugün geçen zamanı alabilmek için bugünün 00:00:00'ı için bir `tarih` objesi oluşturup bunu `şimdi`'nin `tarih` objesinden çıkarabilirsiniz. 
 
 Bunun sonucu milisaniye cinsinden olacaktır, bundan dolayı dönen değeri 1000'e bölerseniz saniye alırsınız:
 
@@ -15,7 +15,7 @@ function bugundenSaniye() {
 
 alert( bugundenSaniye() );
 ```
-Bunun alternativi, saat/dakika/saniye gibi bilgilerin saniyeye çevrilmesidir:
+Bunun alternatifi, saat/dakika/saniye gibi bilgilerin saniyeye çevrilmesidir:
 
 ```js run
 function bugundenSaniye() {
diff --git a/1-js/05-data-types/10-date/6-get-seconds-today/task.md b/1-js/05-data-types/10-date/6-get-seconds-today/task.md
index 578a513c7..2aa73d073 100644
--- a/1-js/05-data-types/10-date/6-get-seconds-today/task.md
+++ b/1-js/05-data-types/10-date/6-get-seconds-today/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# Şu anda bu günün başlangıcından itibaren kaç saniye geçti?
+# Şu anda bugünün başlangıcından itibaren kaç saniye geçti?
 
 `bugundenSaniye()` adında bir fonksiyon yazın ve bu fonksiyon günün başlangıcından itibaren geçen saniyeyi dönsün.
 
@@ -12,4 +12,4 @@ importance: 5
 getSecondsToday() == 36000 // (3600 * 10)
 ```
 
-Fonksiyon her gün çalışabilmelidir. Bu demek oluyor ki elle bu günün değerini almamalısınız.
+Fonksiyon her gün çalışabilmelidir. Bu demek oluyor ki elle bugünün değerini almamalısınız.
diff --git a/1-js/05-data-types/10-date/7-get-seconds-to-tomorrow/task.md b/1-js/05-data-types/10-date/7-get-seconds-to-tomorrow/task.md
index 651ad51ba..37c099bbd 100644
--- a/1-js/05-data-types/10-date/7-get-seconds-to-tomorrow/task.md
+++ b/1-js/05-data-types/10-date/7-get-seconds-to-tomorrow/task.md
@@ -12,4 +12,4 @@ importance: 5
 yarinaKacSn() == 3600
 ```
 
-Not: Fonksiyon her gün çalışabilmelidir. Bu demek oluyor ki elle bu günün değerini almamalısınız.
+Not: Fonksiyon her gün çalışabilmelidir. Bu demek oluyor ki elle bugünün değerini almamalısınız.
diff --git a/1-js/05-data-types/10-date/article.md b/1-js/05-data-types/10-date/article.md
index adcdbc9dd..55667428f 100644
--- a/1-js/05-data-types/10-date/article.md
+++ b/1-js/05-data-types/10-date/article.md
@@ -145,11 +145,11 @@ Gördüğünüz gibi,`setHours` gibi bazı metodlar birden fazla bileşeni aynı
 ```js run
 let today = new Date();
 
-bugun.setHours(0);
-alert(today); // bu gün ve saat 0
+today.setHours(0);
+alert(today); // bugün ve saat 0
 
-bugun.setHours(0, 0, 0, 0);
-alert(today); // bu gün ve saniye 00:00:00.
+today.setHours(0, 0, 0, 0);
+alert(today); // bugün ve saniye 00:00:00.
 ```
 
 ## Otomatik Düzenleme
@@ -299,17 +299,17 @@ alert( 'Time of diffSubtract: ' + bench(diffSubtract) + 'ms' );
 alert( 'Time of diffGetTime: ' + bench(diffGetTime) + 'ms' );
 ```
 
-`getTime()` ile yapılan işlem çok daha hızlı! Bunun nedeni tip dönüşümü olmaması, böylece JavaScript motoru çok daha iyi optimize edebilmektedir.
+Vay be! `getTime()` ile yapılan işlem çok daha hızlı! Bunun nedeni tip dönüşümü olmaması, böylece JavaScript motoru çok daha iyi optimize edebilmektedir.
 
 Bir değer aldık fakat bu henüz iyi bir karşılaştırma olmadı.
 
-Diyelim ki`karsilastirma(cikarma)` çalışırken işlemci paralelde başka birşeyler ile uğraşıyor olsun. Bu uğraştığı işlemler `karsilastirma(tarihFarki)` zamanında bitsin.
+Diyelim ki `karsilastirma(cikarma)` çalışırken işlemci paralelde başka bir şeyler ile uğraşıyor olsun. Bu uğraştığı işlemler `karsilastirma(tarihFarki)` zamanında bitsin.
 
 Bu aslında oldukça gerçekçi bir senaryodur.
 
 A pretty real scenario for a modern multi-process OS.
 
-Sonuç olarak `karsilastirm(cikarma)` için daha az işlemci kaynağı kullanılanılır ve bu da yanlış sonuca neden olur.
+Sonuç olarak `karsilastirma(cikarma)` için daha az işlemci kaynağı kullanılanılır ve bu da yanlış sonuca neden olur.
 
 **Daha güvenilir karşılaştırma yapabilmek için bu karşılaştırma paketi bir kaç defa çalıştırılmalıdır**
 
@@ -400,11 +400,11 @@ alert(date);
 
 ## Özet
 - Tarih ve saat bilgisi JavaScript'te [Date](mdn:js/Date) objesiyle temsil edilir. Sadece tarih veya saadece saat bilgisiyle obje oluşturulamaz: `Date` objesi her zaman iki bilgiyi de taşır.
-- Aylar 0'dan başlar. ( Evet, Ocak ayı 0. aydır)
-- Haftanın günü `getDate()` de 0'dan başlar ( Pazar günü )
-- `Date` objesi eğer belirttiğiniz tarih mevcut değilse bunu hesaplayabilir. Bu gün,saat,ay ekleme/çıkarmak için kullanışlı bir özelliktir.
+- Aylar 0'dan başlar. (Evet, Ocak ayı 0. aydır)
+- Haftanın günü `getDate()` de 0'dan başlar (Pazar günü)
+- `Date` objesi eğer belirttiğiniz tarih mevcut değilse bunu hesaplayabilir. Bu; gün, saat, ay ekleme/çıkarmak için kullanışlı bir özelliktir.
 - Tarihler çıkartılabilir, aradaki fark sarise olarak döndürülür. Bunun nedeni `Date` sayıya çevrildiğinde zaman damgası olur.
-- O anki zaman damgasını( timestamp ) almak için `Date.now()` kullanabilirsiniz.
+- O anki zaman damgasını (timestamp) almak için `Date.now()` kullanabilirsiniz.
 
 Diğer sistemlerin aksine, zaman damgası javascripte saniye değil sarise cinsindendir.
 
diff --git a/1-js/05-data-types/11-json/2-serialize-event-circular/task.md b/1-js/05-data-types/11-json/2-serialize-event-circular/task.md
index e226255af..59946e50e 100644
--- a/1-js/05-data-types/11-json/2-serialize-event-circular/task.md
+++ b/1-js/05-data-types/11-json/2-serialize-event-circular/task.md
@@ -8,7 +8,7 @@ Basit dairesel referanslarda özelliğin ismi verilip seri hale getirilirken gö
 
 Fakat bazen çok fazla dairesel referans olabilir. Ayrıca isimleri hem dairesel referanslarda hem de normal özelliklerde kullanılabilir.
 
-`degistirici` fonksiyonu ile herşeyi karaktere çevirin, fakat `tanisma`'ya referans veren özellikleri silin:
+`degistirici` fonksiyonu ile her şeyi karaktere çevirin, fakat `tanisma`'ya referans veren özellikleri silin:
 
 ```js run
 let oda = {
diff --git a/1-js/05-data-types/11-json/article.md b/1-js/05-data-types/11-json/article.md
index f959d4f99..44630942d 100644
--- a/1-js/05-data-types/11-json/article.md
+++ b/1-js/05-data-types/11-json/article.md
@@ -23,7 +23,7 @@ alert(kullanici); // {adi: "Ahmet", yasi: 30}
 
 ... Fakat geliştirme esnasında yeni özellikler eklendi ve öncekiler ya silindi ya da isim değiştirdi. Böyle bir durumda `toString` metoduyla her zaman değişiklik yapmak oldukça zordur. Özellikleri döngüye sokup buradan değerler alınabilir. Bu durumda da iç içe objelere ne olacak? Bunlarında çevirimlerini yapmak gerekir. Ayrıca ağ üzerinden objeyi göndermeye çalıştığınızda ayrıca bu objenin alan yer tarafından nasıl okunacağına dair bilgi göndermek zorundasınız.
 
-Neyseki bunların hiç biri için kod yazmaya gerek yok. Bu problem bizim için çözülmüş durumda.
+Neyseki bunların hiçbiri için kod yazmaya gerek yok. Bu problem bizim için çözülmüş durumda.
 
 [cut]
 
@@ -273,7 +273,7 @@ sayi:       23
 */
 ```
 
-`degistirici` fonksiyonu içiçe objeler ve diziler dahil herşeyi alır. Tüm objelere yinelemeli olarak uygulanır. `this`'in değeri `degistirici` içerisinde o anki özellikleri tutar.
+`degistirici` fonksiyonu içiçe objeler ve diziler dahil her şeyi alır. Tüm objelere yinelemeli olarak uygulanır. `this`'in değeri `degistirici` içerisinde o anki özellikleri tutar.
 
 İlk çağrı özeldir. "Sarıcı obje" vasıtasıyla: `{"": tanisma}`. Diğer bir deyişle ilk `(anahtar, deger)` çifti boş anahtar ile gelir ve değeri hedef objenin tamamıdır. Bundan dolayı yukarıdaki örnekte ilk satır: `":[object Object]"`'dir.
 
diff --git a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md
index a35a3c82d..6558f8bba 100644
--- a/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md
+++ b/1-js/06-advanced-functions/01-recursion/04-output-single-linked-list/solution.md
@@ -41,7 +41,7 @@ function listeYaz(list) {
 
 }
 ```
-... Fakat çok akıllıca bir yöntem değil. İleride fonksiyonu genişletmek gerekebilir. Liste ile birşeyler yapmak gerekebilir. Eğer `list` değişirse bu gerekliliklerin hiç biri yerine getirilemez.
+... Fakat çok akıllıca bir yöntem değil. İleride fonksiyonu genişletmek gerekebilir. Liste ile bir şeyler yapmak gerekebilir. Eğer `list` değişirse bu gerekliliklerin hiçbiri yerine getirilemez.
 
 Değişken isimlerinden konuşmak gerekirse `list` burada liste'nin kendisidir, `ilk` elemanıdır ve öyle kalmalıdır. Temiz ve güvenilir.
 
diff --git a/1-js/06-advanced-functions/01-recursion/article.md b/1-js/06-advanced-functions/01-recursion/article.md
index 114d573a6..e46fff04a 100644
--- a/1-js/06-advanced-functions/01-recursion/article.md
+++ b/1-js/06-advanced-functions/01-recursion/article.md
@@ -160,7 +160,7 @@ Değişkenler aynı fakat satır değiştir, şimdiki kaynak şu şekilde:
 
 Dallanma işleminin yapılabilmesi için JavaScript'in öncelikle o anki çalışma durumunu *çalışma kaynağı yığını*na atması gerekmektedir.
 
-Burada `us` fonksiyonu çağrılmıştır. Bu herhangi bir fonksiyon da olabilirdi, aralarında bu yönden hiç bir farklılık bulunmamaktadır:
+Burada `us` fonksiyonu çağrılmıştır. Bu herhangi bir fonksiyon da olabilirdi, aralarında bu yönden hiçbir farklılık bulunmamaktadır:
 
 1. O anki kaynak yığının en üstüne "hatırlatılır"
 2. Alt çağrı için yeni bir kaynak yaratılır.
@@ -181,7 +181,7 @@ Aşağıda `pow(2,2)` altçağrısına girildiğinde kaynak yığınının durum
 
 Üst tarafta o anda çalışan kaynak ( kalın harflerle ), alt tarafta ise "hatırlatılan" kaynak bulunmaktadır.
 
-Altçağrı bittiğinde, daha önceki kalınan kaynaktan devam etmek kolaydır. Çünkü bu her iki değişkeni ve kaldığı satırı tutmaktadır. Burada "satır" denmesine rağmen aslında bunun daha net birşey olduğu bilinmelidir.
+Altçağrı bittiğinde, daha önceki kalınan kaynaktan devam etmek kolaydır. Çünkü bu her iki değişkeni ve kaldığı satırı tutmaktadır. Burada "satır" denmesine rağmen aslında bunun daha net bir şey olduğu bilinmelidir.
 
 ### us(2, 1)
 
diff --git a/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md b/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md
index e15404741..093c5667b 100644
--- a/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md
+++ b/1-js/06-advanced-functions/02-rest-parameters-spread-operator/article.md
@@ -217,7 +217,7 @@ Sonuç `[...str]` ile aynıdır. Fakat `Array.from(obj)` and `[...obj]` ince bir
 - `Array.from` hem dizi-benzerlerinde hem de döngüye alınabilirlerde ( array-likes, iterables ) kullanılabilirler.
 - Yayma operatörü ise sadece döngüye alınabilirlerde uygulanır.
 
-Bundan dolayı, birşeyi diziye çevirmek için `Array.from` kullanmak daha mantıklı olacaktır.
+Bundan dolayı, bir şeyi diziye çevirmek için `Array.from` kullanmak daha mantıklı olacaktır.
 
 
 ## Özet
diff --git a/1-js/06-advanced-functions/03-closure/1-counter-independent/task.md b/1-js/06-advanced-functions/03-closure/1-counter-independent/task.md
index 6a762c9a4..dd2f0e738 100644
--- a/1-js/06-advanced-functions/03-closure/1-counter-independent/task.md
+++ b/1-js/06-advanced-functions/03-closure/1-counter-independent/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 `sayac` ve `sayac2` aynı `sayacUret` fonksiyonu kullanmaktadır.
 
-Bu sayaçlar birbirlerinden bağımsız mıdır? İkinci sayaç ne gösterecek ? `0,1` veya `2,3` veya tamamen başka birşey mi?
+Bu sayaçlar birbirlerinden bağımsız mıdır? İkinci sayaç ne gösterecek ? `0,1` veya `2,3` veya tamamen başka bir şey mi?
 
 ```js
 function sayacUret() {
diff --git a/1-js/06-advanced-functions/03-closure/article.md b/1-js/06-advanced-functions/03-closure/article.md
index d54200bc8..4a748c5cc 100644
--- a/1-js/06-advanced-functions/03-closure/article.md
+++ b/1-js/06-advanced-functions/03-closure/article.md
@@ -93,7 +93,7 @@ Sağ tarafta bulunan dikdörtgenler evrensel Sözcük Ortamının çalışırken
 3. `ifade`'ye değer atanır.
 4. `ifade` yeni bir defere referans olur.
 
-Herşey çok basit görünüyor değil mi?
+Her şey çok basit görünüyor değil mi?
 
 Özetlemek gerekirse:
 
@@ -140,7 +140,7 @@ Fonksiyon çağrıldığında ise iki tane sözcüksel ortam bulunmaktadır: iç
 
 **Kod değişkene ulaşmak istediğinde -- önce İç Sözcük ortamında arara, daha sonra dış sözcüm ortamına bakar ve daha sonra daha dıştakine bakar bu şekilde zincirin en sonuna kadar devam eder**
 
-Eğer değişken hiç bir yerde bulunamazsa, sıkı modda hata verir. `use strict` kullanılmazsa tanımsız değişken yeni bir global değişken yaratır.
+Eğer değişken hiçbir yerde bulunamazsa, sıkı modda hata verir. `use strict` kullanılmazsa tanımsız değişken yeni bir global değişken yaratır.
 
 Arama olayı bizim yazdığımız kodlarda nasıl işliyor buna bakalım:
 
@@ -307,7 +307,7 @@ Muhetemelen, aklınızda dış değişkenlerin nasıl çalıştığı açıklı
 
 Şu anda clouse'ların genel olarak nasıl çalıştığını biliyorsunuz, artık daha derinine inme vakti geldi.
 
-Aşağıda `sayacUret` fonksiyonunun adımları gösterilmektedir, herşeyi anladığınıza emin olun. Basamaklarda göreceğiniz `[[Environment]]` henüz işlenmedi.
+Aşağıda `sayacUret` fonksiyonunun adımları gösterilmektedir, her şeyi anladığınıza emin olun. Basamaklarda göreceğiniz `[[Environment]]` henüz işlenmedi.
 
 1. Kod çalışmaya başkadığında sadece bir tane Sözcüksel Ortam bulunmaktadır:
 
@@ -351,7 +351,7 @@ Aşağıda `sayacUret` fonksiyonunun adımları gösterilmektedir, herşeyi anla
 
     Bu fonksiyonun sadece bir satır kodu var: `return sayac++`, sadece bu çalışacaktır.
     
-5. `sayac()` çağrıldığında, "boş" bir Sözcüksel Ortam yaratılır. Hiç bir yerel değişkeni yoktur. Fakat `sayac`'ın `[[Environment]]`'i dış referans olarak kullanılır. Bundan dolayı, daha önceden yapılan `sayacUret()`'in değişkenlerine erişebilir. Oluşturulduğu yerder:
+5. `sayac()` çağrıldığında, "boş" bir Sözcüksel Ortam yaratılır. hiçbir yerel değişkeni yoktur. Fakat `sayac`'ın `[[Environment]]`'i dış referans olarak kullanılır. Bundan dolayı, daha önceden yapılan `sayacUret()`'in değişkenlerine erişebilir. Oluşturulduğu yerder:
 
     ![](lexenv-nested-makecounter-5.svg)
 
@@ -513,7 +513,7 @@ JavaScript'e başka yollarla da Fonksiyon İfadesini belirtmek mümkündür.
 }*!*)*/!*();
 
 (function() {
-  alert("Herşeyin etrafında parantez");
+  alert("Her şeyin etrafında parantez");
 }()*!*)*/!*;
 
 *!*!*/!*function() {
diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md
index 6f08c2648..cacee5240 100644
--- a/1-js/06-advanced-functions/04-var/article.md
+++ b/1-js/06-advanced-functions/04-var/article.md
@@ -123,7 +123,7 @@ function selamVer() {
 ```
 Bu davranışa "yükseltilme" davranışı da denir, çünkü tüm `var` ile tanımlamalar fonksiyonun başına "yükseltilme"
 
-Bundan dolayı yukarıdaki örnekte `if(false)` hiç bir zaman çalışmayacaktır, zaten önemli de değildir. İçinde bulunan `var` fonksiyonun başında işlenir. Yani `(*)` anında zaten `terim` değişkeni vardır.
+Bundan dolayı yukarıdaki örnekte `if(false)` hiçbir zaman çalışmayacaktır, zaten önemli de değildir. İçinde bulunan `var` fonksiyonun başında işlenir. Yani `(*)` anında zaten `terim` değişkeni vardır.
 
 **Tanımlar yükseltilir fakat atamalar yükseltilmez**
 
diff --git a/1-js/06-advanced-functions/05-global-object/article.md b/1-js/06-advanced-functions/05-global-object/article.md
index 323f2137b..34f6ebb2d 100644
--- a/1-js/06-advanced-functions/05-global-object/article.md
+++ b/1-js/06-advanced-functions/05-global-object/article.md
@@ -59,7 +59,7 @@ Fakat ES-2015 sonrası, bu varlıklar ayrıldı. Artık evrensel sözcük ortam
 
 Uygulamada evrensel `let/cons` değişkenleri global Evrensel Kayıtta tanımlanmış özelliklerdir fakat evrensel obje'de bulunmamaktadırlar.
 
-Doğal olarak, evrensel objenin "evrensel olan herşeye erişebilir" fikri eski zamanlarda kalmıştır. Artık bu iyi birşey olarak görülmemektedir. `let/const` gibi dil özellikleri bunu desteklememektedir, fakat eski olanlara hala destek verir.
+Doğal olarak, evrensel objenin "evrensel olan her şeye erişebilir" fikri eski zamanlarda kalmıştır. Artık bu iyi bir şey olarak görülmemektedir. `let/const` gibi dil özellikleri bunu desteklememektedir, fakat eski olanlara hala destek verir.
 ```
 ## "window"'un kullanım alanları
 
diff --git a/1-js/06-advanced-functions/06-function-object/article.md b/1-js/06-advanced-functions/06-function-object/article.md
index 29d6a9e05..069fa9910 100644
--- a/1-js/06-advanced-functions/06-function-object/article.md
+++ b/1-js/06-advanced-functions/06-function-object/article.md
@@ -40,7 +40,7 @@ function f(selamVer = function() {}) {
 
 f();
 ```
-Tanımda bu özelliğe "bağlamsal isim" denir. Eğer fonksiyonda böyle birşey yoksa, tanımlama bunu içerikten alır.
+Tanımda bu özelliğe "bağlamsal isim" denir. Eğer fonksiyonda böyle bir şey yoksa, tanımlama bunu içerikten alır.
 
 Object metodlarının da isimleri vardır:
 ```js run
@@ -217,7 +217,7 @@ Peki buradaki mantık ne? Ayrıca bir `"func"` eklemenin ne anlamı var?
 
 Tekrar etmek gerekirse, hala bir Fonksiyon İfadeniz var. Fonksiyon ifadesine `"function"` 'dan sonra `"func"` eklemek bu fonksiyonu Fonksiyon Tanımı haline getirmez çünkü hala bir atama operasyonu ile tanımlanmıştır.
 
-Böyle bir isim eklemek hiç bir soruna neden olmaz. 
+Böyle bir isim eklemek hiçbir soruna neden olmaz. 
 
 Fonksiyon hala `selamVer()` şeklinde kullanılabilir:
 
@@ -309,9 +309,9 @@ hosGeldin(); // Selam, Misafir (iç çağrı çalışır)
 
 Şimdi çalışır, bunun nedeni `"func"`'in lokal fonksiyon olmasındandır. Dışarıdan alınmaz ( dışarıdan görünmez de ). Bu şekilde yazıldığında var olan fonksiyonu referans vereceği garantidir.
 
-Dışta bulunan kod hala `selamVer` veya `hosGeldin` değişkenlerine sahiptir. Dıştaki değişkenlere birşey olsa bile `func`"iç fonksiyon ismi"'dir. Kendisini gizli biçimde çağırabilir.
+Dışta bulunan kod hala `selamVer` veya `hosGeldin` değişkenlerine sahiptir. Dıştaki değişkenlere bir şey olsa bile `func`"iç fonksiyon ismi"'dir. Kendisini gizli biçimde çağırabilir.
 
-```smart header="Fonksiyon Tanımı diye birşey yoktur."
+```smart header="Fonksiyon Tanımı diye bir şey yoktur."
 "içsel isim" olarak tanımlanan özellik sadece Fonksiyon İfadeleri için geçerlidir. Fonksiyon Tanımlarında çalışmaz. Fonksiyon tanımları için "içsel" bir isim ekleme yöntemi yoktur.
 
 Bazen güvenli bir isme ihtiyaç duyulduğunda Fonksiyon Tanımı tekrardan İsimlendirilmiş Fonksiyon İfadesi şekline getirilir.
diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md
index 66a558a9c..6a06b01d2 100644
--- a/1-js/06-advanced-functions/07-new-function/article.md
+++ b/1-js/06-advanced-functions/07-new-function/article.md
@@ -134,4 +134,4 @@ new Function('a,b', ' return a + b; '); // virgül ile ayrılmış yazım
 new Function('a , b', ' return a + b; '); //virgül ve boşluk ile ayrılmış yazım.
 ```
 
-`new Function` kullanılarak yaratılan fonksiyonlar, `[[Ortam]]` olarak Evrensel Sözcük Ortamını referans verir, dış değil. Bundan dolayı dıştaki değişkeni kullanamazlar. Fakat bu aslında iyi birşeydir, bizi hatalardan korur. Bire bir parametre gönderme de mimari olarak çok başarılır. Ayrıca *sıkıştırıcı* ile de probleme neden olmamaktadır.
+`new Function` kullanılarak yaratılan fonksiyonlar, `[[Ortam]]` olarak Evrensel Sözcük Ortamını referans verir, dış değil. Bundan dolayı dıştaki değişkeni kullanamazlar. Fakat bu aslında iyi bir şeydir, bizi hatalardan korur. Bire bir parametre gönderme de mimari olarak çok başarılır. Ayrıca *sıkıştırıcı* ile de probleme neden olmamaktadır.
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
index 2bb1cb9cd..8d891001e 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
@@ -75,7 +75,7 @@ Yeni başlayan arkadaşlar bazen yanlışlıkla fonksiyonun sonuna `()` ekleyebi
 setTimeout(selamVer(), 1000);
 ```
 
-Bu çalışmaz, çünkü `setTimeout` referans bir fonksiyon beklemektedir. Burada `selamVer()` derseniz fonksiyonu çalıştırırsınız ve *bunun sonucu* `setTimeout` fonksiyonu tarafından kullanılır. Bizim durumumuzda `selamVer()` `undefined` döndürür. ( fonksiyon ile alakalı bir sorun yok ) bundan dolayı hiç birşey zamanlanmaz.
+Bu çalışmaz, çünkü `setTimeout` referans bir fonksiyon beklemektedir. Burada `selamVer()` derseniz fonksiyonu çalıştırırsınız ve *bunun sonucu* `setTimeout` fonksiyonu tarafından kullanılır. Bizim durumumuzda `selamVer()` `undefined` döndürür. ( fonksiyon ile alakalı bir sorun yok ) bundan dolayı hiçbir şey zamanlanmaz.
 ````
 
 ### clearTimeout fonksiyonu ile iptal etme
@@ -93,14 +93,14 @@ Aşağıdaki kodda önce bir zamanlayıcı test eder sonrasında ise bunu iptal
 
 
 ```js run no-beautify
-let timerId = setTimeout(() => alert("Birşey olmayacak"), 1000);
+let timerId = setTimeout(() => alert("Bir şey olmayacak"), 1000);
 alert(timerId); // timer identifier
 
 clearTimeout(timerId);
 alert(timerId); // same identifier (iptal ettikten sonra null olmaz)
 ```
 
-`alert` çıktısından da göreceğiniz gibi timer bir id numarası ile tanımlanır. Diğer ortamlarda bu başka birşey olabilir. Örneğin Node.Js bir sayı yerine farklı metodları olan timer objesi döner.
+`alert` çıktısından da göreceğiniz gibi timer bir id numarası ile tanımlanır. Diğer ortamlarda bu başka bir şey olabilir. Örneğin Node.Js bir sayı yerine farklı metodları olan timer objesi döner.
 
 Tekrar söylemek gerekirse üzerinde anlaşılmış bir şartname bulunmamaktadır.
 
@@ -228,7 +228,7 @@ Bunun nedeni yeni çağrının önceki çağrının bitiminde hesaplanmasından
 
 ````smart header="Garbage collection" ( Çöp Toplama)
 
-Bir fonksiyon `setInterval/setTimeout`'a gönderildiğinde içeride bir referansını oluşturup zamanlayıcıya kaydeder. Bundan dolayı bu fonksiyon Çöp toplama işlemine girmez. Dışarıda hiç bir referans olmasa bile bu fonksiyon yok olmaz.
+Bir fonksiyon `setInterval/setTimeout`'a gönderildiğinde içeride bir referansını oluşturup zamanlayıcıya kaydeder. Bundan dolayı bu fonksiyon Çöp toplama işlemine girmez. Dışarıda hiçbir referans olmasa bile bu fonksiyon yok olmaz.
 
 ```js
 // zamanlayıcı çağırana kadar fonksiyon hafızada kalır.
@@ -262,13 +262,13 @@ alert("Merhaba");
 
 `setTimeout` ile CPU-aç görevlerin kullanılabilmesi şöyle bir yöntem kullanılabilir.
 
-Örneğin, yazıların renklerini değiştiren ( şu anki sayfa gibi ) bir uygulama tam olarak CPU-aç bir uygulamadır. Analiz eder, bir çok renkli eleman yaratır, bunları dökümana ekler dosya büyüdükçe bu da gittikçe daha fazla işlemci gerektirir. Hatta tarayıcının "hang " durumuna yani tepki vermemesine kadar gidebilir, bu da kabul edilemez.
+Örneğin, yazıların renklerini değiştiren ( şu anki sayfa gibi ) bir uygulama tam olarak CPU-aç bir uygulamadır. Analiz eder, birçok renkli eleman yaratır, bunları dökümana ekler dosya büyüdükçe bu da gittikçe daha fazla işlemci gerektirir. Hatta tarayıcının "hang " durumuna yani tepki vermemesine kadar gidebilir, bu da kabul edilemez.
 
 Bundan dolayı uzun metinleri ayırabiliriz. Önce 100 satır, sonra diğer bir 100 satır vs.
 
 Daha basit bir örnekten anlatmaya çalışırsak. Bir fonksiyonunuz olsun ve `1`'den `100000000000`'a kadar saysın
 
-Eğer kodu çalıştırırsanız işlemci tepki vermemeye başlar. Sunucu tabanlı JS kodlarında bu kolay bir şekilde fark edilebilir fakat eğer bu kodu tarayıcı üzerinde çalıştırıyorsanız diğer butonlara tıkladığınızda JavaScript'in durduğunu ve bunun bitene kadar da başka birşeyin çalışmadığını görürsünüz.
+Eğer kodu çalıştırırsanız işlemci tepki vermemeye başlar. Sunucu tabanlı JS kodlarında bu kolay bir şekilde fark edilebilir fakat eğer bu kodu tarayıcı üzerinde çalıştırıyorsanız diğer butonlara tıkladığınızda JavaScript'in durduğunu ve bunun bitene kadar da başka bir şeyin çalışmadığını görürsünüz.
 
 ```js run
 let i = 0;
@@ -460,7 +460,7 @@ Artık `<div>` `i` nin yükselen değerini gösterecektir.
 - CPU-aç görevleri parçalara ayırmak için, böylece kod sürekli tepki verebilir.
 - Böylece görev devam ederken tarayıcının başka işlere ( ilerleme çubuğu ) zaman ayırır.
 
-Tüm zamanlama metodları tam olarak gecikmeyi *garantilemez*. Zamanlayıcıda bu varsayımın üzerine birşey inşa etmeyin.
+Tüm zamanlama metodları tam olarak gecikmeyi *garantilemez*. Zamanlayıcıda bu varsayımın üzerine bir şey inşa etmeyin.
 
 Örneğin, tarayıcı zamanı birçok nedenden ötürü yavaşlayabilir:
 - İşlemcinin yükü artarsa.
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
index 314a4ab30..8bc702998 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/04-throttle/task.md
@@ -23,7 +23,7 @@ Bundan dolayı `update()` yerine, her bir fare hareketinde çalışacak `throttl
 Şu şekilde görünecektir:
 
 1. İlk fare hareketinde dekoratör çağrıyı doğrudan `update`'e yönlendirecektir. Bu önemlidir, kullanıcı böylece hareketinin sonucunu doğrudan görür.
-2. Sonrasında fare hareket etse de `100ms` geçene kadar hiç birşey olmaz. Dekoratör çağrıları görmezden gelir.
+2. Sonrasında fare hareket etse de `100ms` geçene kadar hiçbir şey olmaz. Dekoratör çağrıları görmezden gelir.
 3. `100ms` sonunda son koordinatlar ile tekrardan bir `update` çalışır.
 4. En sonunda fare bir yerlerde durur. Dekoratör `100ms` bekler ve bu bekleme bittikten sonra `update` fonksiyonu son koordinatlar ile çalışır. Belki de en önemlisi son fare koordinatlarının da işlenmiş olmasıdır.
 
diff --git a/1-js/06-advanced-functions/09-call-apply-decorators/article.md b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
index dfa83b4b0..06a638d06 100644
--- a/1-js/06-advanced-functions/09-call-apply-decorators/article.md
+++ b/1-js/06-advanced-functions/09-call-apply-decorators/article.md
@@ -45,7 +45,7 @@ alert( "Tekrar: " + slow(2) ); // bir önceki ile aynısı döndü.
 
 Yuarkıdaki kodda `cachingDecorator` bir *dekoratör*'dür: Diğer bir fonksiyonu alan ve bunun davranışını değiştiren özel bir fonksiyon fonksiyon.
 
-Aslında her bir fonksiyon için `cachingDecorator` çağrılabilir ve o da saklama mekanizmasını kullanır. Harika, bu şekilde ihtiyacı olacak bir çok fonksiyonumuz olabilir. Tek yapmamız gereken bu fonksiyonlara `cachingDecorator` uygulamak.
+Aslında her bir fonksiyon için `cachingDecorator` çağrılabilir ve o da saklama mekanizmasını kullanır. Harika, bu şekilde ihtiyacı olacak birçok fonksiyonumuz olabilir. Tek yapmamız gereken bu fonksiyonlara `cachingDecorator` uygulamak.
 
 Saklama olayını ana fonksiyonldan ayırarak aslında daha temiz bir yapıya da geçmiş olduk.
 
@@ -306,7 +306,7 @@ let wrapper = function() {
   return anotherFunction.apply(this, arguments);
 };
 ```
-Buna *çağrı iletme* denir. Saklayıcı sahip olduğu herşeyi iletir: `this` ile argümanları `anotherFunction`'a iletir ve sonucunu döner.
+Buna *çağrı iletme* denir. Saklayıcı sahip olduğu her şeyi iletir: `this` ile argümanları `anotherFunction`'a iletir ve sonucunu döner.
 
 Böyle bir saklayıcı kod çağırıldığında içerideki orjinal fonksiyon çağıran tarafından ayrıştırılamaz.
 
diff --git a/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md b/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md
index 8e7658bd7..4ee23b2fd 100644
--- a/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md
+++ b/1-js/06-advanced-functions/10-bind/5-question-use-bind/task.md
@@ -8,7 +8,7 @@ importance: 5
 
 Fakat bu bir hataya neden oluyor. Neden?
 
-Sadece üstü çizili satırda değişiklik yaparak herşeyin doğru çalışmasını sağlayınız. ( diğer satırlarda değişiklik yapılmamalıdır)
+Sadece üstü çizili satırda değişiklik yaparak her şeyin doğru çalışmasını sağlayınız. ( diğer satırlarda değişiklik yapılmamalıdır)
 
 ```js run
 function askPassword(ok, fail) {
diff --git a/1-js/06-advanced-functions/10-bind/article.md b/1-js/06-advanced-functions/10-bind/article.md
index 07d1599fb..d814051af 100644
--- a/1-js/06-advanced-functions/10-bind/article.md
+++ b/1-js/06-advanced-functions/10-bind/article.md
@@ -37,7 +37,7 @@ let f = user.sayHi;
 setTimeout(f, 1000); // lost kullanıcı kaynağı kayboldu
 ```
 
-Tarayıcıda `setTimeout` kullanımı biraz özeldir: `this=window` olarak ayarlanır. ( Node.JS için `this` timer objesi olur, fakat burada pek de önemli değil.) Öyleyse `this.firstName` bu değeri `window.firstName`'den almaya çalışır, fakat böyle birşey yok. Buna benzer durumlarda siz de göreceksiniz `this` genelde `undefined` olur.
+Tarayıcıda `setTimeout` kullanımı biraz özeldir: `this=window` olarak ayarlanır. ( Node.JS için `this` timer objesi olur, fakat burada pek de önemli değil.) Öyleyse `this.firstName` bu değeri `window.firstName`'den almaya çalışır, fakat böyle bir şey yok. Buna benzer durumlarda siz de göreceksiniz `this` genelde `undefined` olur.
 
 Aslında yapmak istediğimiz çok basit obje metodunu çağrılan yere ( -- ) iletmek istiyoruz ( burada -- zamanlayıcıdır.) Bunun doğru kaynakta çağırıldığına nasıl emin olunabilir?
 
@@ -88,7 +88,7 @@ user = { sayHi() { alert("Another user in setTimeout!"); } };
 // Another user in setTimeout?!?
 ```
 
-Bir sonraki çözüm içe böyle birşeyin olmasını engeller.
+Bir sonraki çözüm içe böyle bir şeyin olmasını engeller.
 
 ## Çözüm 2: bağlama
 
@@ -198,5 +198,5 @@ Bu şekilde büyük bağlama olayları için bazı JavaScript kütüphanelerinde
 
 `func.bind(kaynak, ...args)` `func` fonksiyonunun "bağlanmış hali"'ni döndürür. Bu bağlanmış halde `this` ve argümanlar sabitlenir.
 
-Bind genelde obje metodlarındaki `this`'in sabitlenmesi amacıyla kullanılır, sonrasında istenilen yere iletilebilir. `setTimeout` örneği gibi. `bind`'in modern geliştirmede kullanılmasının bir çok nedeni vardır bunlara ilerleyen konularda değineceğiz.
+Bind genelde obje metodlarındaki `this`'in sabitlenmesi amacıyla kullanılır, sonrasında istenilen yere iletilebilir. `setTimeout` örneği gibi. `bind`'in modern geliştirmede kullanılmasının birçok nedeni vardır bunlara ilerleyen konularda değineceğiz.
 
diff --git a/1-js/06-advanced-functions/11-currying-partials/article.md b/1-js/06-advanced-functions/11-currying-partials/article.md
index b7b5bc57a..9fe53d232 100644
--- a/1-js/06-advanced-functions/11-currying-partials/article.md
+++ b/1-js/06-advanced-functions/11-currying-partials/article.md
@@ -161,7 +161,7 @@ function curry(f) {
 
 Tımarlayarak hem fonksiyon normal olarak çağırılabilir  hem de kısmi olarak alınabilir. Yararını anlayabilmek için gerçekten de iyi bir örneğe gerek var.
 
-Örneğin, bir loglama fonksiyonu olsun `log(data, importance, message)` gelen veriye göre çıktıyı formatlayabilsin. Projelerde böyle fonksiyonlar bunun yanında bir çok özelliğe sahip olabilir. Örneğin bunları ağ üzerinden iletmek veya filtrelemek gibi.
+Örneğin, bir loglama fonksiyonu olsun `log(data, importance, message)` gelen veriye göre çıktıyı formatlayabilsin. Projelerde böyle fonksiyonlar bunun yanında birçok özelliğe sahip olabilir. Örneğin bunları ağ üzerinden iletmek veya filtrelemek gibi.
 
 ```js
 function log(date, importance, message) {
@@ -184,16 +184,16 @@ log(new Date(), "DEBUG", "some debug");
 ```js
 log(new Date())("DEBUG")("some debug"); // log(a)(b)(c)
 ```
-Bu günün loglarını daha kolay bir şekilde alabileceğimiz bir fonksiyon yazalım:
+Bugünün loglarını daha kolay bir şekilde alabileceğimiz bir fonksiyon yazalım:
 
 ```js
-// todayLog bu günün değeri sabit olacak şekilde oluşturulmuş bir kısmi fonksiyondur
+// todayLog bugünün değeri sabit olacak şekilde oluşturulmuş bir kısmi fonksiyondur
 let todayLog = log(new Date());
 
 // kullanımı
 todayLog("INFO", "message"); // [HH:mm] INFO message
 ```
-Şimdi ise bu günün Debug değerlerini alabileceğimiz diğer bir fonksiyon yapalım:
+Şimdi ise bugünün Debug değerlerini alabileceğimiz diğer bir fonksiyon yapalım:
 
 ```js
 let todayDebug = todayLog("DEBUG");
@@ -202,7 +202,7 @@ todayDebug("message"); // [HH:mm] DEBUG message
 ```
 
 Sonuç olarak:
-1. Tımarladıktan sonra `log` fonksiyonundan birşey kaybetmedik. Hala aynı şekilde çağırabiliriz.
+1. Tımarladıktan sonra `log` fonksiyonundan bir şey kaybetmedik. Hala aynı şekilde çağırabiliriz.
 2. Kısmi fonksiyonlar ile işimize yarar birçok yeni fonksiyon geliştirebiliriz.
 
 
diff --git a/1-js/06-advanced-functions/12-arrow-functions/article.md b/1-js/06-advanced-functions/12-arrow-functions/article.md
index 5b3e2fec8..fd76919da 100644
--- a/1-js/06-advanced-functions/12-arrow-functions/article.md
+++ b/1-js/06-advanced-functions/12-arrow-functions/article.md
@@ -71,7 +71,7 @@ Bu ok fonksiyonlarında işlemez çünkü ok fonksiyonlarında `this` bulunmamak
 `=>` fonksiyonları ile `.bind(this)` ile çağırılan normal fonksiyonlar arasında ince bir fark vardır.
 
 - `.bind(this)` fonksiyonun "bağlı versiyonu"'nu oluştururken.
-- `=>` fonksiyonu hiç bir bağlılık oluşturmaz. Fonksiyon basit bir şekilde `this`'e sahip değildir. `this`'in aranması aynı normal fonksiyonlardaki gibi dışarıdaki sözcüksel ortamda aranması ile son bulur.
+- `=>` fonksiyonu hiçbir bağlılık oluşturmaz. Fonksiyon basit bir şekilde `this`'e sahip değildir. `this`'in aranması aynı normal fonksiyonlardaki gibi dışarıdaki sözcüksel ortamda aranması ile son bulur.
 ```
 
 ## Ok fonksiyonlarının "argümanları" olmaz.
diff --git a/1-js/07-object-properties/02-property-accessors/article.md b/1-js/07-object-properties/02-property-accessors/article.md
index f5853e509..5b0537c0d 100644
--- a/1-js/07-object-properties/02-property-accessors/article.md
+++ b/1-js/07-object-properties/02-property-accessors/article.md
@@ -173,7 +173,7 @@ alert(user.name); // Pete
 
 user.name = ""; // İsim çok kısa...
 ```
-Teknik olarak, dışarıdan hala `user._name` ile erişilebilir. Fakat genel bir kural olarak `"_"` ile başlayan özellikler içte kullanılan değişkenlerdir ve dışarıdan hiç bir zaman erişilmemelidir.
+Teknik olarak, dışarıdan hala `user._name` ile erişilebilir. Fakat genel bir kural olarak `"_"` ile başlayan özellikler içte kullanılan değişkenlerdir ve dışarıdan hiçbir zaman erişilmemelidir.
 
 
 ## Uyumluluk için kullanma
diff --git a/1-js/08-prototypes/01-prototype-inheritance/article.md b/1-js/08-prototypes/01-prototype-inheritance/article.md
index bda161efc..c9b0ab7a0 100644
--- a/1-js/08-prototypes/01-prototype-inheritance/article.md
+++ b/1-js/08-prototypes/01-prototype-inheritance/article.md
@@ -14,7 +14,7 @@ Javascript objeleri gizli bir özellik olan `[[Prototype]]` özelliğine sahipti
 
 `[[Prototip]]`'in "büyülü" bir anlamı bulunmaktadır. Objeden bir özellik okunmak istendiğinde, ve bu obje bulunamadığında JavaScript bunu otomatik olarak prototip'ten alır. Programlamada buna `prototip kalıtımı` denir. Birçok dil özelliği ve programlama tekniği bunun üzerine kuruludur.
 
-`[[Prototpe]]` gizli bir özelliktir, fakat bunu ayarlamanın bir çok yolu vardır.
+`[[Prototpe]]` gizli bir özelliktir, fakat bunu ayarlamanın birçok yolu vardır.
 
 Bunlardan biri `__proto__` kullanmaktır:
 
@@ -197,7 +197,7 @@ admin.fullName = "Alice Cooper"; // (**)
 
 Yukarıdaki örnekte aklınıza şöyle bir soru gelebilir. `set fullName(value)` içerisinde `this`'in değeri nedir? `this.name` ve `this.surname` yazılan yerlerde `admin` mi yoksa `user` mı kullanılır?
 
-Cevap basittir: `this` prototip tarafından hiç bir şekilde etkilenmez.
+Cevap basittir: `this` prototip tarafından hiçbir şekilde etkilenmez.
 
 **Metodun bulunduğu yerin önemi olmaksızın, metod çağrısında `this` her zaman noktadan önceki bölümdür.**
 
diff --git a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
index c47256bdc..6c2d1f1a9 100644
--- a/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
+++ b/1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md
@@ -14,7 +14,7 @@ Cevaplar:
     
 3. `true`.
 
-    Tüm  `delete` operasyonları objeye doğrudan etki eder. Mesela `delete rabbit.eats` `rabbit`'ten `eats` özelliğini silmeye çalışır fakat yapaz. Bundan dolayı bu operasyonun hiç bir etkisi olayacaktır.
+    Tüm  `delete` operasyonları objeye doğrudan etki eder. Mesela `delete rabbit.eats` `rabbit`'ten `eats` özelliğini silmeye çalışır fakat yapaz. Bundan dolayı bu operasyonun hiçbir etkisi olayacaktır.
     
 4. `undefined`.
 
diff --git a/1-js/08-prototypes/02-function-prototype/article.md b/1-js/08-prototypes/02-function-prototype/article.md
index 6f00e28b6..458b4f0ed 100644
--- a/1-js/08-prototypes/02-function-prototype/article.md
+++ b/1-js/08-prototypes/02-function-prototype/article.md
@@ -46,7 +46,7 @@ Sonuç şu şekildedir:
 
 Görselde  `"prototip"` yataydaki oktur, sıranda bir özelliktir. `[[Prototype]]` ise dikeydir ve `rabbit`'in `animal`'dan miras aldığını ifade eder.
 
-## Sıradan F.prototype, yapıcı( contructor) özelliği
+## Sıradan F.prototype, yapıcı (contructor) özelliği
 
 Her fonksiyonun `"prototype"` özelliği bulunmaktadır. Siz belirtmeseniz bile bu geçerlidir.
 
@@ -74,7 +74,7 @@ function Rabbit() {}
 alert( Rabbit.prototype.constructor == Rabbit ); // true
 ```
 
-Eğer hiç birşey yapmazsak doğal olarak `contructor` özelliği tüm rabbit objelerine `[[Prototype]]` vasıtasıyla iletilir.
+Eğer hiçbir şey yapmazsak doğal olarak `contructor` özelliği tüm rabbit objelerine `[[Prototype]]` vasıtasıyla iletilir.
 
 ```js run
 function Rabbit() {}
@@ -111,7 +111,7 @@ Muhtemelen `"contructor"` hakkındaki en önemli şey...
 
 **... JavaScript `"contructor"` değerinin doğru olduğuna garanti vermez.**
 
-Evet, varsayılan `"prototype"` da bulunur fakat hepsi budur, sonrasındaki herşey bize aittir.
+Evet, varsayılan `"prototype"` da bulunur fakat hepsi budur, sonrasındaki her şey bize aittir.
 
 Daha özelde, eğer prototip'i tamamen değiştirirsek, bu durumda içinde `"contructor"` olmayacaktır.
 
@@ -158,7 +158,7 @@ Rabbit.prototype = {
 
 Bu bölümde kısaca yapıcı fonksiyonlar ile oluşturulan objelerin `[[Prototip]]`'lerinin nasıl ayarlanabileceğinden bahsettik. İlerde bunların daha gelişmişini programlama kalıpları üzerinde öğreneceksiniz.
 
-Herşey aslında çok basit, birkaç cümle ile daha net anlatmak gerekirse:
+Her şey aslında çok basit, birkaç cümle ile daha net anlatmak gerekirse:
 
 - `F.prototype` özelliği `[[Prototype]]` ile aynı değildir. `F.prototype` aslında `new F()` çağırıldığında  `[[Prototype]]`'ı  ayarlar.
 - `F.prototype` değeri ya obje ya da null olmalıdır: diğer değerler çalışmaz.
@@ -168,7 +168,7 @@ Normal objeler `prototype`'ın ayrı bir önemi yoktur:
 ```js
 let user = {
   name: "John",
-  prototype: "Bla-bla" // hiç bir büyüsü yok
+  prototype: "Bla-bla" // hiçbir büyüsü yok
 };
 ```
 Varsayılan durumda tüm  fonksiyonlar `F.prototype = { constructor: F}` şeklinde tanımlıdır, bundan dolayı, bir objenin yapıcısına `"constructor"` özelliği ile erişilebilir.
\ No newline at end of file
diff --git a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md
index ce6f7f04e..b78189bd2 100644
--- a/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md
+++ b/1-js/08-prototypes/03-native-prototypes/2-defer-to-prototype-extended/task.md
@@ -2,7 +2,7 @@ importance: 4
 
 ---
 
-# Fonksiyonlara Düzenleyici ( Decorator ) ekleyiniz.
+# Fonksiyonlara Düzenleyici (Decorator) ekleyiniz.
 
 Tüm fonksiyonların prototiplerini `defer(ms)` metodunu ekleyiniz. Bu metod çağrılan fonksiyonu `ms` kadar geciktiren bir kapsayıcıdır.
 
diff --git a/1-js/08-prototypes/03-native-prototypes/article.md b/1-js/08-prototypes/03-native-prototypes/article.md
index bf6fa44ed..c51b442e9 100644
--- a/1-js/08-prototypes/03-native-prototypes/article.md
+++ b/1-js/08-prototypes/03-native-prototypes/article.md
@@ -48,7 +48,7 @@ alert(Object.prototype.__proto__); // null
 
 Örneğin, `[1,2,3]` bir array yarattığınızda içte varsayılan `new Array()` yapıcısı kullanılır. Bundan dolayı dizi dizi objesi yeni bir objeye yazılır ve `Array.prototype` bunun prototipi olur ve metodlar sağlar. Bu hafızayı oldukça etkin kullanmaya yarar.
 
-Tanım gereği, tüm gömülü prototipler üstünde `Object.prototype`'a sahip olmalıdır. Bazen "herşey objelerden kalıtım alır" sözünü duyarsınız.
+Tanım gereği, tüm gömülü prototipler üstünde `Object.prototype`'a sahip olmalıdır. Bazen "her şey objelerden kalıtım alır" sözünü duyarsınız.
 
 Aşağıda bunun etraflı bir görselini görebilirsiniz. 
 
diff --git a/1-js/08-prototypes/04-prototype-methods/article.md b/1-js/08-prototypes/04-prototype-methods/article.md
index 8834487b0..2d93181f1 100644
--- a/1-js/08-prototypes/04-prototype-methods/article.md
+++ b/1-js/08-prototypes/04-prototype-methods/article.md
@@ -54,7 +54,7 @@ Tanımlayıcıların <info:property-descriptors> bölümünde üstünden geçilm
 // Objenin yüzeysel klonu
 let clone = Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
 ```
-Bu tam olarak `obj`'nin aynısını verir. Tüm özellikler: dönülebilir veya dönülemez, veri özellikleri, alıcı ve ayarlayıcılar --  herşey, ayrıca doğru `[[Prototype]]` ile
+Bu tam olarak `obj`'nin aynısını verir. Tüm özellikler: dönülebilir veya dönülemez, veri özellikleri, alıcı ve ayarlayıcılar --  her şey, ayrıca doğru `[[Prototype]]` ile
 
 ## Tarihçe
 
@@ -100,11 +100,11 @@ Böyle bir olay sadece `__proto__`'da meydana gelir diğer tüm özellikler norm
 
 Bu problemden nasıl kaçınılabilir?
 
-Öncelikle `Map` kullanılabilir, herşey doğru çalışır.
+Öncelikle `Map` kullanılabilir, her şey doğru çalışır.
 
 Fakat burada bize `Obje` yardımcı olabilir, çünkü dili yaratıcılar bu konuları uzun zaman önce düşünmüşler.
 
-`__proto__` objenin bir özelliği değildir. Fakat `Object.prototype`'a erişimsağlar( accessor ):
+`__proto__` objenin bir özelliği değildir. Fakat `Object.prototype`'a erişim sağlar (accessor):
 
 ![](object-prototype-2.svg)
 
@@ -133,7 +133,7 @@ Bundan dolayı `__proto__`  için atadan kalan alıcı/ayarlayıcı bulunmamakta
 
 Böyle objelere "en basit" veya "saf sözlük objeleri" denir, Çünkü bunlar sıradan objelerden `{...}` bile daha basittirler.
 
-Bu objelerin kötü tarafı ise, içinde hiç bir varsayılan metod bulunmaz, Örneğin: `toString`:
+Bu objelerin kötü tarafı ise, içinde hiçbir varsayılan metod bulunmaz, Örneğin: `toString`:
 
 ```js run
 *!*
@@ -202,7 +202,7 @@ for(let prop in rabbit) alert(prop); // jumps, sonra  eats
 ```
 Eğer kalıtılmış özellikler ayrıştırılmak istenirse bunun için varolan [obj.hasOwnProperty(key)](mdn:js/Object/hasOwnProperty) kullanılabilir: Eğer `obj` `key` adında kalıtımsal olmayan bir özelliğe sahipse `true` dönderir.
 
-Kalıtımsal özellikleri bu şekilde filtreleyebilir veya başka birşey yapabiliriz:
+Kalıtımsal özellikleri bu şekilde filtreleyebilir veya başka bir şey yapabiliriz:
 
 ```js run
 let animal = {
@@ -232,8 +232,8 @@ Zincire bakarsanız `rabbit.hasOwnProperty` nereden geliyor görebilirsiniz. `Ob
 Bu bölümde anlatılanların üzerinden kısaca geçecek olursak:
 
 - [Object.create(proto[, descriptors])](mdn:js/Object/create) -- verilen `proto` ile yeni bir obje yaratır, ayrıca opsiyonel olarak özellik tanımlıyıcılar verilebilir.
-- [Object.getPrototypeOf(obj)](mdn:js/Object.getPrototypeOf) -- `obj`'nin `[[Prototype]]`ını döner ( `__proto__` alıcısı ( getter ) ile aynı işi yapar)).
-- [Object.setPrototypeOf(obj, proto)](mdn:js/Object.setPrototypeOf) -- `obj`'nin `[[Prototype]]`'ını verilen `proto`'ya ayarlar. ( `__proto__` ayarlayıcısı ( setter) ile aynı işi yapar)
+- [Object.getPrototypeOf(obj)](mdn:js/Object.getPrototypeOf) -- `obj`'nin `[[Prototype]]`ını döner ( `__proto__` alıcısı (getter) ile aynı işi yapar)).
+- [Object.setPrototypeOf(obj, proto)](mdn:js/Object.setPrototypeOf) -- `obj`'nin `[[Prototype]]`'ını verilen `proto`'ya ayarlar. ( `__proto__` ayarlayıcısı (setter) ile aynı işi yapar)
 - [Object.keys(obj)](mdn:js/Object/keys) / [Object.values(obj)](mdn:js/Object/values) / [Object.entries(obj)](mdn:js/Object/entries) -- döngülenebilir karakter dizisi/ değerler/ anahtar-değer ikilisi dizisi döner.
 - [Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols) -- tüm sembolik özelliklerin dizisini döner.
 - [Object.getOwnPropertyNames(obj)](mdn:js/Object/getOwnPropertyNames) -- özelliklerin tüm karakter dizisi isimlerini dizi olarak döner.
diff --git a/1-js/09-classes/02-class-inheritance/article.md b/1-js/09-classes/02-class-inheritance/article.md
index 61a2df24a..b6f9a7045 100644
--- a/1-js/09-classes/02-class-inheritance/article.md
+++ b/1-js/09-classes/02-class-inheritance/article.md
@@ -94,7 +94,7 @@ Sınıflar bunun için `"super"` anahtar kelimesini sağlarlar.
 
 - `super.method(...)` üst class'ın metodunu çağırmak için.
 
-- `super(...)` üst metodun yapıcısını ( constructor) çağırmak için kullanılır.
+- `super(...)` üst metodun yapıcısını (constructor) çağırmak için kullanılır.
 
 Örneğin, Rabbit otomatik olarak durduğunda gizlensin.
 
@@ -263,7 +263,7 @@ Artık `super`'in derinliklerine dalma vakti geldi. Altında yatan ilginç şeyl
 
 Öncelikle, şimdiye kadar öğrendiklerimizle `super` ile çalışmak mümkün değil.
 
-Ever gerçekten, kendimize soralım, nasıl teknik olarak böyle birşey çalışabilir? Bir obje metodu çalıştığında var olan objeyi `this` olarak alır. Eğer biz `super.method()`'u çağırırsak `metod`'u nasıl alabilir? Doğal olarak `method`'u var olan objenin prototipinden almak gerekmektedir. Peki teknik olarak bunu JavaScript motoru nasıl halledebilir?
+Ever gerçekten, kendimize soralım, nasıl teknik olarak böyle bir şey çalışabilir? Bir obje metodu çalıştığında var olan objeyi `this` olarak alır. Eğer biz `super.method()`'u çağırırsak `metod`'u nasıl alabilir? Doğal olarak `method`'u var olan objenin prototipinden almak gerekmektedir. Peki teknik olarak bunu JavaScript motoru nasıl halledebilir?
 
 Belki `this`in `[[Prototype]]`'ını `this.__proto__.method` olarak alıyordur? Malesef böyle çalışmıyor.
 
@@ -317,7 +317,7 @@ let rabbit = {
 let longEar = {
   __proto__: rabbit,
   eat() {
-    // ...uzun kulaklar ile birşeyler yap ve üst sınıfı çağır.
+    // ...uzun kulaklar ile bir şeyler yap ve üst sınıfı çağır.
     this.__proto__.eat.call(this); // (**)
   }
 };
diff --git a/1-js/09-classes/06-instanceof/article.md b/1-js/09-classes/06-instanceof/article.md
index 2f1e63879..891edcce0 100644
--- a/1-js/09-classes/06-instanceof/article.md
+++ b/1-js/09-classes/06-instanceof/article.md
@@ -2,7 +2,7 @@
 
 `instanceof` operatörü bir objenin belirli bir sınıfa ait olup olmadığını kontrol eder. Kalıtımı da hesaba kadar.
 
-Böyle bir kontrole bir çok durumda ihtiyacımız olabilir. Aşağıda *polymorphic* fonksiyon inşa etmek için, argümanların tipine göre farklı davranış sergileyen bir yapı yer almaktadır.
+Böyle bir kontrole birçok durumda ihtiyacımız olabilir. Aşağıda *polymorphic* fonksiyon inşa etmek için, argümanların tipine göre farklı davranış sergileyen bir yapı yer almaktadır.
 
 [cut]
 
@@ -56,7 +56,7 @@ Dikkat edin `arr` ayrıca `Object` sınıfına da aittir. Çünkü `Array` proto
 1. Eğer `Symbol.hasInstance` statik metodu var ise onu kullan. Şu şekilde:
 
     ```js run
-    // canEat yapabilen herşeyi animal varsayalım.
+    // canEat yapabilen her şeyi animal varsayalım.
     class Animal {
       static [Symbol.hasInstance](obj) {
         if (obj.canEat) return true;
diff --git a/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md b/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md
index d02bc99e1..4f084232b 100644
--- a/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md
+++ b/1-js/10-error-handling/1-try-catch/1-finally-or-code-after/task.md
@@ -10,7 +10,7 @@ Aşağıdaki iki kod parçacığını karşılaştırınız.
 
     ```js
     try {
-      birşeyler çalıştır
+      bir şeyler çalıştır
     } catch (e) {
       hatalarla uğraş
     } finally {
@@ -23,7 +23,7 @@ Aşağıdaki iki kod parçacığını karşılaştırınız.
 
     ```js
     try {
-      birşeyler çalıştır
+      bir şeyler çalıştır
     } catch (e) {
       hatalarla uğraş
     }
diff --git a/1-js/10-error-handling/1-try-catch/article.md b/1-js/10-error-handling/1-try-catch/article.md
index fd97c8dfb..e576bab1a 100644
--- a/1-js/10-error-handling/1-try-catch/article.md
+++ b/1-js/10-error-handling/1-try-catch/article.md
@@ -10,7 +10,7 @@ Hataları "yakalamak" için "try..catch" kullanarak doğrudan kodun ölmesine am
 
 ## "try..catch" yazımı
 
-`try..catch` yapısı iki ana bloktan oluşur: `try` ( dene ) ve sonrasında `catch` ( yakala ):
+`try..catch` yapısı iki ana bloktan oluşur: `try` (dene) ve sonrasında `catch` (yakala):
 
 ```js
 try {
@@ -254,9 +254,9 @@ Yazımı şu şekildedir:
 ```js
 throw <error object>
 ```
-Teknik olarak herşeyi hata objesi olarak kullanmak mümküdür. Hatta bu ilkel tipler olan sayı, karakter dizisi gibi yapılar da olabilir. Fakat obje kullanmak, daha sı `name` ve `message` özelliklerine sahip obje kullanmak daha iyidir. ( Böylece gömülü gelen hatalar ile uyumlu olacaktır.)
+Teknik olarak her şeyi hata objesi olarak kullanmak mümküdür. Hatta bu ilkel tipler olan sayı, karakter dizisi gibi yapılar da olabilir. Fakat obje kullanmak, daha sı `name` ve `message` özelliklerine sahip obje kullanmak daha iyidir. ( Böylece gömülü gelen hatalar ile uyumlu olacaktır.)
 
-JavaScript bir çok standart hataya sahitir:`Error`, `SyntaxError`, `ReferenceError`, `TypeError` vs. Bunları kullanarak da hata objesiyaratmak mümkündür.
+JavaScript birçok standart hataya sahitir:`Error`, `SyntaxError`, `ReferenceError`, `TypeError` vs. Bunları kullanarak da hata objesiyaratmak mümkündür.
 
 Yazımı:
 
@@ -273,10 +273,10 @@ Gömülü hatalar ( objeler değil sadece hatalar ) `name` özelliği yapıcın
 Örneğin:
 
 ```js run
-let error = new Error("Birşeyler oldu o_O");
+let error = new Error("Bir şeyler oldu o_O");
 
 alert(error.name); // Error
-alert(error.message); // Birşeyler oldu o_O
+alert(error.message); // Bir şeyler oldu o_O
 ```
 `JSON.parse` ne tarz hatalar üretti bakalım:
 
@@ -322,7 +322,7 @@ try {
 
 Artık `catch` tüm hata idaresinin yapılacağı yerdir: Buna `JSON.parse` ve diğer durumlar dahildir.
 
-## Tekrar atma ( Rethrowing )
+## Tekrar atma (Rethrowing)
 
 Yukarıdaki örnekte yanlış veri ile başa çıkmak için `try..catch` kullandık. Peki başka beklenmeyen hata varsa ne yapacağız? Mesela değişken tanımsız olabilir veya bilmediğimiz bir hata ile de karşılaşabiliriz.
 
@@ -332,7 +332,7 @@ Yukarıdaki örnekte yanlış veri ile başa çıkmak için `try..catch` kulland
 let json = '{ "age": 30 }'; // tamamlanmamış veri
 
 try {
-  user = JSON.parse(json); // <-- user'dan önce  "let" kullanmayı unuttuysak
+  user = JSON.parse(json); // <-- user'dan önce "let" kullanmayı unuttuysak
 
   // ...
 } catch(err) {
@@ -340,9 +340,9 @@ try {
   // (hata aslında JSON ile alakalı değil)
 }
 ```
-Tabiki herşey mümkün! Programcılar da hata yapar. Yıllardır milyonlarca kişinin kullandığı open-source projelerde bile hata vardır. Hatta öyle hatalar vardır ki bulunduğunda çok büyük belaya neden olabilir ( `ssh`'ta bulunan hata)
+Tabii ki her şey mümkün! Programcılar da hata yapar. Yıllardır milyonlarca kişinin kullandığı open-source projelerde bile hata vardır. Hatta öyle hatalar vardır ki bulunduğunda çok büyük belaya neden olabilir (`ssh`'ta bulunan hata)
 
-Biz denemelerimizde `try..catch`i "doğru olmayan veri"'yi yakalamak için kullandık. Fakat aslında `catch` `try`'da olabilecek *tüm* hataları alır.Yukarıdaki örnekte beklenmeyecen bir hata almasına rağmen bundan dolayı `"JSON Error" mesajı verir. Bu aslında kod ayıklamayı zorlaştıran birşeydir ve yanlış kullanımdır.
+Biz denemelerimizde `try..catch`i "doğru olmayan veri"yi yakalamak için kullandık. Fakat aslında `catch` `try`'da olabilecek *tüm* hataları alır.Yukarıdaki örnekte beklenmeyecen bir hata almasına rağmen bundan dolayı `"JSON Error" mesajı verir. Bu aslında kod ayıklamayı zorlaştıran bir şeydir ve yanlış kullanımdır.
 
 Yine de ne hatası olduğunu `name`'den çıkarmak mümkündür.
 
@@ -396,7 +396,7 @@ try {
 
 }
 ```
-`try..catch` içerisinde eğer `(*)` hata tekrar atılırsa bu `try..catch` in dışına taşar. Bu daha üstte bulunan başka bir `try..catch` tarafından yakalanması gerekmektedir. Böyle bir ihtimal yoksa kod burada sona ermelidir.
+`try..catch` içerisinde eğer `(*)` hata tekrar atılırsa bu, `try..catch` in dışına taşar. Bunun daha üstte bulunan başka bir `try..catch` tarafından yakalanması gerekmektedir. Böyle bir ihtimal yoksa kod burada sona ermelidir.
 
 Böylece `catch` bloğu aslında sadece bildiği hataları idare eder ve diğerlerini hiç kontrol etmeden paslar diyebiliriz.
 
@@ -429,7 +429,7 @@ try {
 */!*
 }
 ```
-Burada `readData` sadece `SyntaxError` ile nasıl başa çıkacağını biliyor. Bunun yanında dıştaki `try..catch` ise geri kalan herşeyi idare ediyor.
+Burada `readData` sadece `SyntaxError` ile nasıl başa çıkacağını biliyor. Bunun yanında dıştaki `try..catch` ise geri kalan her şeyi idare ediyor.
 
 ## try..catch..finally
 
@@ -472,7 +472,7 @@ Kod iki türlü çalışabilir:
 1. Eğer "Make an error?"'a "Yes" cevabını verirseniz, `try -> catch -> finally` şeklinde sona erer.
 2. Eğer "No" derseniz `try-> finally` şeklinde sona erer.
 
-`finally` genelde `try..catch`'den önce birşey yapıp bunu sona erdirmek ( finally ) istediğiniz durumlarda kullanılır.
+`finally` genelde `try..catch`'den önce bir şey yapıp bunu sona erdirmek (finally) istediğiniz durumlarda kullanılır.
 
 Örneğin Fibonacci sayılarını hesaplayan bir fonksiyonun ne kadar sürdüğünü ölçmek istediğinizde, doğal olarak işlem başlamadan süre başlar ve işlem bittikten sonra süre biter. Fakat diyelimki fonksiyonda bir hata var. Aşağıda uygulaması görünen `fib(n)`'e negatif bir sayı gönderdiğinizde veya integer olmayan bir sayı gönderdiğinizde hata döner.
 
@@ -651,7 +651,7 @@ Hata objeleri şu özellikleri taşır:
 - `stack` ( standart değil ) - hatanın oluştuğu andaki yığın. Hatanın nedenini bulmak için yararlı bir özellik.
 
 
-`throw` kullanarak biz de kendi hatalarımızı oluşturabiliriz. Teknik olarak, `throw`'un argümanları herşey olabilir. Fakat genelde `Error` sınıfından türemesi ve özelliklerini alması iyi bir yoldur. Bunları nasıl genişleteceğinizi bir sonraki bölümde görebilirsiniz.
+`throw` kullanarak biz de kendi hatalarımızı oluşturabiliriz. Teknik olarak, `throw`'un argümanları her şey olabilir. Fakat genelde `Error` sınıfından türemesi ve özelliklerini alması iyi bir yoldur. Bunları nasıl genişleteceğinizi bir sonraki bölümde görebilirsiniz.
 
 Tekrar atma hata idaresi için temel bir desendir: bir `catch` bloğu her zaman hangi hataların geleceğini ve buna göre ne yapması gerektiğini bilmeli, eğer bilmiyorsa bu hatayı tekrar atmalıdır.
 
diff --git a/1-js/10-error-handling/2-custom-errors/article.md b/1-js/10-error-handling/2-custom-errors/article.md
index fb36e229c..bfbc203ee 100644
--- a/1-js/10-error-handling/2-custom-errors/article.md
+++ b/1-js/10-error-handling/2-custom-errors/article.md
@@ -1,6 +1,6 @@
 # Düzenlenmiş hatalar, hataların geliştirilmesi
 
-Birşey geliştirirken, genelde kendi hata sınıflarımıza sahip olmak isteriz, böylece bize has yerlerde oluşabilecek hataları idare edebiliriz. Örneğin network hataları için `HttpError`, veri tabanı hataları için `DbError`, arama hataları için `NotFoundError` gibi.
+Bir şey geliştirirken, genelde kendi hata sınıflarımıza sahip olmak isteriz, böylece bize has yerlerde oluşabilecek hataları idare edebiliriz. Örneğin network hataları için `HttpError`, veri tabanı hataları için `DbError`, arama hataları için `NotFoundError` gibi.
 
 Hatalarımız basit hata özelliklerini `message`, `name` ve `stack`'i desteklemelidir. Bunun ile birlikte kendine has özellikleri de olabilir. Örneğin `HttpError` objesi `statusCode` özelliğine sahip olabilir. Bu özelliğin değeri de `404`, `403`, `500` gibi hata kodları olacaktır.
 
@@ -214,11 +214,11 @@ Böylece hata sınıfları kısalmış oldu, özellikle `"this.name=..."`'i att
 
 Hatırlarsanız yukarıdaki `readUser` "kullanıcıların verilerini okumak" amacıyla yazılmıştı, değil mi? Farklı hatalar olabileceğinden dolayı şimdilik `SyntaxError`, `ValidationError` gibi hata sınıflarına sahibiz. Fakat `readUser` ileride daha da büyüyebilir: yeni kod yeni hatalara neden olacaktır.
 
-Bundan dolayı `readUser`'ı çağıran fonksiyon hataları ile başa çıkmalıdır. Şu anda bir çok `if`, `catch` ile kontrol edilip eğer bunlar dahilinde değil ise tekrar hata atma işlemini yapmaktayız. Fakat `readUser` fonksiyonu daha fazla hataya neden olursa, kendimize: gerçekten de tüm hataları birer birer kontrol etmemiz gerekli mi sorusunu sormalıyız.
+Bundan dolayı `readUser`'ı çağıran fonksiyon hataları ile başa çıkmalıdır. Şu anda birçok `if`, `catch` ile kontrol edilip eğer bunlar dahilinde değil ise tekrar hata atma işlemini yapmaktayız. Fakat `readUser` fonksiyonu daha fazla hataya neden olursa, kendimize: gerçekten de tüm hataları birer birer kontrol etmemiz gerekli mi sorusunu sormalıyız.
 
 Tabiki cevap "Hayır": Dıştaki kod her zaman "diğerlerinden bir üst seviyede" olmak ister. "veri okuma hatası" gibi bir hata olmak ister. Neden olduğu çok da önemli değildir. Tabi hataların detayları olsa iyi olur fakat sadece ihtiyaç olursa.
 
-Bunlar ışığında `ReadError` sınıfını yeniden yazacak olursak. Eğer `readUser` içerisinde bir hata olursa bunu yakalayacak ve `ReadError` üreteceğiz. Ayrıca orjinal hatanın `cause` ( neden ) özelliğine referans vereceğiz. Bundan dolayı dıştaki kod sadece `ReadError`'u kontrol etmeli.
+Bunlar ışığında `ReadError` sınıfını yeniden yazacak olursak. Eğer `readUser` içerisinde bir hata olursa bunu yakalayacak ve `ReadError` üreteceğiz. Ayrıca orjinal hatanın `cause` (neden) özelliğine referans vereceğiz. Bundan dolayı dıştaki kod sadece `ReadError`'u kontrol etmeli.
 
 Aşağıdaki kod `ReadError`'u tanımlamakta ve `readUser` ve `try..catch`'in nasıl kullanılacağını göstermektedir:
 
diff --git a/1-js/11-async/01-callbacks/01-animate-circle-callback/task.md b/1-js/11-async/01-callbacks/01-animate-circle-callback/task.md
index 8d09b1725..0e1030a8b 100644
--- a/1-js/11-async/01-callbacks/01-animate-circle-callback/task.md
+++ b/1-js/11-async/01-callbacks/01-animate-circle-callback/task.md
@@ -7,7 +7,7 @@
 Diyelim ki sadece çember değil, bunun içinde mesaj da olsun. Mesaj animasyon *tamamlandıktan* sonra ( çemberin en büyük halinde ) görünmelidir. Aksi halde çirkin görünecektir.
 
 
-Görevin çözümünde, `showCircle(cx, cy, radius)` çemberi çizmektedir, fakat hazır olup olmadığına dair hiç bir bilgi vermemektedir.
+Görevin çözümünde, `showCircle(cx, cy, radius)` çemberi çizmektedir, fakat hazır olup olmadığına dair hiçbir bilgi vermemektedir.
 
 Yeni bir callback argümanı ekle: `showCircle(cx, cy, radius, callback)` animasyon tamamlandığında çağırılmalıdır. `callback` çemberin `<div>`'ini argüman olarak almalı.
 
diff --git a/1-js/11-async/01-callbacks/article.md b/1-js/11-async/01-callbacks/article.md
index 473fb5bfe..a4f34feee 100644
--- a/1-js/11-async/01-callbacks/article.md
+++ b/1-js/11-async/01-callbacks/article.md
@@ -210,7 +210,7 @@ Yukarıdaki kodda:
 2. Hata yoksa `2.js`'yi yükle.
 3. Hata yoksa `3.js`'yi ve en sonda da `(*)` çalıştırılır.
 
-Çağrılar çoğaldıkça kod daha derinlere inmekte ve bunun yönetimi de zorlaşmaktadır, özellikle içerisinde `...` yerine gerçek kod varsa bu bir çok döngüye, koşula sahip olacaktır.
+Çağrılar çoğaldıkça kod daha derinlere inmekte ve bunun yönetimi de zorlaşmaktadır, özellikle içerisinde `...` yerine gerçek kod varsa bu birçok döngüye, koşula sahip olacaktır.
 
 Bunun için "callback cehennemi" veya "Kıyamet piramidi" denilebilir.
 
diff --git a/1-js/11-async/02-promise-basics/article.md b/1-js/11-async/02-promise-basics/article.md
index 0997cb2fa..631c2db02 100644
--- a/1-js/11-async/02-promise-basics/article.md
+++ b/1-js/11-async/02-promise-basics/article.md
@@ -2,14 +2,14 @@
 
 Diyelim ki çok iyi bir sanatçısınız ve fanlarınız size sabah akşam ne zaman yeni şarkılarınızın geleceğini soruyor.
 
-Siz de biraz rahatlamak için yeni şarkı yayınladığınızda onlara göndereceğinize söz verdiniz. Onlara bir liste verdiniz ve güncellemeleri buradan yayınlayacağınızı söylediniz. Böylece onlar da kendi email adreslerini yazar ve yeni şarkılar geldiğinde hemen bunları görebilir. Diyelimki birşey yanış gitti ve yeni şarkıyı yayınlayamadınız bu şekliyle bile onlara bildirim gider.
+Siz de biraz rahatlamak için yeni şarkı yayınladığınızda onlara göndereceğinize söz verdiniz. Onlara bir liste verdiniz ve güncellemeleri buradan yayınlayacağınızı söylediniz. Böylece onlar da kendi email adreslerini yazar ve yeni şarkılar geldiğinde hemen bunları görebilir. Diyelimki bir şey yanış gitti ve yeni şarkıyı yayınlayamadınız bu şekliyle bile onlara bildirim gider.
 
-Böylece herkes mutlu, sizi artık kimse darlamayacak, ve hiç bir yeni şarkınızı kaçırmayacaklar.
+Böylece herkes mutlu, sizi artık kimse darlamayacak, ve hiçbir yeni şarkınızı kaçırmayacaklar.
 
 Bu programlamada karşılaştığımız olayların gerçek-hayattaki analojisi:
 
 1. Zaman alan "Kod üretme". Örneğin ağ üzerinden veri yükleyen bir uygulama, yani "Şarkıcı"
-2. Üretilen kodu hazır olduğunda "tüketmek isteyen" kod. Bir çok fonksiyon bu sonuca ihtiyaç duyabilir. Bu da "fanlar"'dır.
+2. Üretilen kodu hazır olduğunda "tüketmek isteyen" kod. Birçok fonksiyon bu sonuca ihtiyaç duyabilir. Bu da "fanlar"'dır.
 3. *promise*(söz) bir çeşif özel JavaScript objesidir. Bu obje "üreten kod" ile "tüketen kod'u" birleştirir. Bizim kurduğumuz analoji'de bu "üyelik listesi"'ne denk gelir. "Kod üreten"'in ne kadar sürede üreteceği belli değildir.  Bu söz hazır olduğunda tüm üyelere bunu bildirir.
 
 Bu analoji tam olarak doğru değildir, aslında JavaScript promise'leri üyelik listesinden çok daha karmaşıktır: Bazı ek özellikleri ve sınırlılıkları mevcuttur. Fakat başlangıç olarak iyi diyebiliriz.
@@ -25,7 +25,7 @@ let promise = new Promise(function(resolve, reject) {
 
 Sonuçlanan `promise` objesinin dahili özellikleri şu şekildedir:
 
-- `durum` - ilk önce "bekleniyor ( pending )" sonrasında "yerine getirildi" veya "red edildi" durumuna getirilir.
+- `durum` - ilk önce "bekleniyor (pending)" sonrasında "yerine getirildi" veya "red edildi" durumuna getirilir.
 - `sonuç` - ilk başlangıçta `undefined`'dır.
 
 Çalıştırıcı işini bitirdiğinde, aşağıdaki fonksiyonları belirtilen argümanlar ile çağırmalıdır:
@@ -108,7 +108,7 @@ let promise = new Promise(function(resolve, reject) {
 });
 ```
 
-Bu durum işe başladığınızda fakat sonrasında değişen birşey olmadığının görünüp hiç çalışmadan gönderilmek istendiğinde gerçekleştirilebilir.
+Bu durum işe başladığınızda fakat sonrasında değişen bir şey olmadığının görünüp hiç çalışmadan gönderilmek istendiğinde gerçekleştirilebilir.
 
 Bu aslında iyi bir çözüm. Böylece söz hemen çözülmüş olur.
 ````
diff --git a/1-js/13-modules/02-import-export/article.md b/1-js/13-modules/02-import-export/article.md
index 5581bb55d..bebb4ee4f 100644
--- a/1-js/13-modules/02-import-export/article.md
+++ b/1-js/13-modules/02-import-export/article.md
@@ -159,7 +159,7 @@ Pratikte, modüller şunlardan birini içerir:
 - Bir kütüphane, fonksiyonlar paketi, `lib.js` gibi.
 - Veya bir varlık,`user.js` de `class User` tanımlanmıştır. Bütün modül bu sınıfa sahiptir.
 
-Çoğunlukla ikinci yaklaşım tercih edilir. Böylece her "şey" kendi modulünde bulunur.
+Çoğunlukla ikinci yaklaşım tercih edilir. Böylece her " şey" kendi modulünde bulunur.
 
 Doğal olarak bu çok fazla dosya gerektirir, her şeyin kendi modülünü istediği gibi, ama bu hiç sorun değil. Aslında, dosyalar iyi adlandırılmışsa ve klasörler halinde yapılandırılmışsa kod gezinme işlemi kolaylaşır.
 
diff --git a/1-js/index.md b/1-js/index.md
index 242dcd8da..3208f4d67 100644
--- a/1-js/index.md
+++ b/1-js/index.md
@@ -1,5 +1,5 @@
 # JavaScript Dili
 
-Bu bölümde başlangıçtan daha Nesne Yönelimli Programlama gibi daha derin konulara gireceğiz.
+Bu bölümde sıfırdan başlayarak, Nesne Yönelimli Programlama gibi daha derin konulara doğru ilerleyeceğiz.
 
-Dilin kendisi üzerinde duracağız, bu bölümde çevre-bazlı özelliklere çok az değineceğiz.
+Çevre bazlı özelliklere çok az değinerek burada dilin kendisi üzerinde duracağız.
diff --git a/2-ui/1-document/01-browser-environment/article.md b/2-ui/1-document/01-browser-environment/article.md
index 57f4657f9..c52cfc1ff 100644
--- a/2-ui/1-document/01-browser-environment/article.md
+++ b/2-ui/1-document/01-browser-environment/article.md
@@ -1,6 +1,6 @@
 # Tarayıcı Ortamı, Özellikleri
 
-Javascript dili başlangıçta internet tarayıcıları için oluşturuldu. O zamandan beri geliştirildi ve bir çok kullanımı ve platformu ile bir dil haline geldi.
+Javascript dili başlangıçta internet tarayıcıları için oluşturuldu. O zamandan beri geliştirildi ve birçok kullanımı ve platformu ile bir dil haline geldi.
 
 
 Bir platform tarayıcı, bir web sunucusu, bir çamaşır makinesi veya başka bir sunucu olabilir. Bunların her biri platforma özgü fonksiyonlar sağlar. JavaScript özelliklerinde bunu bir sunucu ortamı olarak adlandırılır.
@@ -53,7 +53,7 @@ Burada `document.body.style` kullandık fakat daha fazla parametreler var. Özel
 
 DOM standartları : <https://dom.spec.whatwg.org>
 
-Eskiden hiç bir standart yoktu. -- her tarayıcı her ne istiyorsa onu uyguladı. Bu yüzden farklı tarayıcıların aynı şeyler için farklı metotları ve özellikleri vardı. Geliştiriciler her bir tarayıcı için farklı kodlar yazmak zorunda kalıyordu. Karanlık dağınık zamanlar.
+Eskiden hiçbir standart yoktu. -- her tarayıcı her ne istiyorsa onu uyguladı. Bu yüzden farklı tarayıcıların aynı şeyler için farklı metotları ve özellikleri vardı. Geliştiriciler her bir tarayıcı için farklı kodlar yazmak zorunda kalıyordu. Karanlık dağınık zamanlar.
 
 Şimdi bile bazen tarayıcılara özgü özellikleri kullanan ve uyumsuzluklar etrafında çalışan eski kodlarla çalışabiliriz ama bu derste modern şeyler kullanacağız: Onlara ihtiyacın olana kadar eski şeyler öğrenmeye gerek yok (şansın yüksek değil). 
 
@@ -77,7 +77,7 @@ HTML'in bir parçası (BOM), belge dışında her şey ile çalışmak için tar
 
 Örneğin:
 
-- [navigator](mdn:api/Window/navigator) nesnesi tarayıcı ve işletim sistemi hakkında arkaplan bilgisi sağlar. Bir çok özelliği var, fakat en çok bilinen ikisi şunlardır: `navigator.userAgent` -- mevcut tarayıcı hakkında, ve `navigator.platform` -- platform hakkında (Windows/Linux/Mac arasında farklılık olacağından yardım gerekebilir). 
+- [navigator](mdn:api/Window/navigator) nesnesi tarayıcı ve işletim sistemi hakkında arkaplan bilgisi sağlar. Birçok özelliği var, fakat en çok bilinen ikisi şunlardır: `navigator.userAgent` -- mevcut tarayıcı hakkında, ve `navigator.platform` -- platform hakkında (Windows/Linux/Mac arasında farklılık olacağından yardım gerekebilir). 
 - [location](mdn:api/Window/location) nesnesi geçerli adresi okumayı ve tarayıcıyı yenisine yönlendirmeyi sağlar
 
 `location` nesnesini bu şekilde kullanabiliriz: 
@@ -108,9 +108,9 @@ CSSOM tanımlaması
 : stil sayfaları ve stil kurallarını açıklar, bunlarla yapılan manipülasyonları ve belge bağlanmalarını sağlar, Bkz <https://www.w3.org/TR/cssom-1/>.
 
 HTML tanımlaması
-: HTML dilini (etiketler vs.) ve ayrıca BOM (tarayıcı nesne modeli) -- çeşitli tarayıcı fonksiyonlar: `setTimeout`, `alert`, `location` vb açıklar, Bkz <https://html.spec.whatwg.org>. DOM özelliğini alır ve bir çok ek özellik ve yöntemle geliştirir.
+: HTML dilini (etiketler vs.) ve ayrıca BOM (tarayıcı nesne modeli) -- çeşitli tarayıcı fonksiyonlar: `setTimeout`, `alert`, `location` vb açıklar, Bkz <https://html.spec.whatwg.org>. DOM özelliğini alır ve birçok ek özellik ve yöntemle geliştirir.
 
-Lütfen yukarıdaki bağlantıları kontrol edin. Çünkü öğrenecek bir çok şey var. Her şeyi hatırlamak imkansızdır.
+Lütfen yukarıdaki bağlantıları kontrol edin. Çünkü öğrenecek birçok şey var. Her şeyi hatırlamak imkansızdır.
 
 Bir özellik ve yöntem hakkında okumak istediğinizde -- Mozilla kılavuzu <https://developer.mozilla.org/en-US/search> güzel kılavuzlardan bir tanesidir, ancak ilgili özelliklerin okunması daha iyi olabilir: daha karmaşık ve okunması uzun fakat temel bilginiz eksiksiz ve sağlam hale gelecektir.
 
diff --git a/2-ui/1-document/02-dom-nodes/article.md b/2-ui/1-document/02-dom-nodes/article.md
index 88cef36a6..40c12bf7d 100644
--- a/2-ui/1-document/02-dom-nodes/article.md
+++ b/2-ui/1-document/02-dom-nodes/article.md
@@ -94,7 +94,7 @@ Tarayıcı hatalı biçimlendirilmiş HTML ile karşılaşırsa, DOM oluştururk
 
 Örneğin, en üstteki etiket her zaman <html> olur. Belgede olmasa bile - DOM'da bulunacak, tarayıcı onu oluşturacaktır. Aynısı <body> için de geçerlidir .
 
-Örnek olarak, HTML dosyası tek bir kelimeyse yani "Hello" gibi birşey ise , tarayıcı onu <html> içine saracak, gerekli olan <body> ve <head> kısmını ekleyecek ve DOM şu şekilde olacaktır:
+Örnek olarak, HTML dosyası tek bir kelimeyse yani "Hello" gibi bir şey ise , tarayıcı onu <html> içine saracak, gerekli olan <body> ve <head> kısmını ekleyecek ve DOM şu şekilde olacaktır:
 
 
 <div class="domtree"></div>
diff --git a/2-ui/1-document/07-modifying-document/4-clear-elem/task.md b/2-ui/1-document/07-modifying-document/4-clear-elem/task.md
index fa0219ac8..1d2b076b7 100644
--- a/2-ui/1-document/07-modifying-document/4-clear-elem/task.md
+++ b/2-ui/1-document/07-modifying-document/4-clear-elem/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Clear the element
 
-`clear(elem)` adında, elementten herşeyi kaldıran bir fonksiyon yarat.
+`clear(elem)` adında, elementten her şeyi kaldıran bir fonksiyon yarat.
 
 ```html run height=60
 <ol id="elem">
diff --git a/2-ui/3-event-details/1-mouse-events-basics/article.md b/2-ui/3-event-details/1-mouse-events-basics/article.md
index 6066c79ae..9306c7918 100644
--- a/2-ui/3-event-details/1-mouse-events-basics/article.md
+++ b/2-ui/3-event-details/1-mouse-events-basics/article.md
@@ -113,7 +113,7 @@ Tüm fare olayları, basılan değiştirici tuşlarla ilgili bilgileri içerir.
 ```warn header="Dikkat: Mac için genellikle `Ctrl` yerine `Cmd` kullanılır."
 Windows ve Linux işletim sistemlerinde `key:Alt`, `key:Shift` and `key:Ctrl` değiştiricileri bulunur. Mac için bir değiştirici daha var: `key:Cmd`, bu `metaKey` özelliğine karşılık gelir.
 
-Çoğu zaman Windows/Linux üzerinde bir durum için `key:Ctrl` kullanılırken, Mac üzerinde `key:Cmd` kullanılır. Bu yüzden Windows kullanıcısı `key:Ctrl+Enter` ya da `key:Ctrl+A` kullandığı zaman, Mac kullanıcısı `key:Cmd+Enter` ya da `key:Cmd+A` kullanır. Bir çok uygulama da `key:Ctrl` yerine `key:Cmd` kullanır.
+Çoğu zaman Windows/Linux üzerinde bir durum için `key:Ctrl` kullanılırken, Mac üzerinde `key:Cmd` kullanılır. Bu yüzden Windows kullanıcısı `key:Ctrl+Enter` ya da `key:Ctrl+A` kullandığı zaman, Mac kullanıcısı `key:Cmd+Enter` ya da `key:Cmd+A` kullanır. Birçok uygulama da `key:Ctrl` yerine `key:Cmd` kullanır.
 
 Dolayısıyla, Ctrl + tıklama gibi kombinasyonları kullanacagımız zaman, Mac için Cmd + tıklamayı kullanmak mantıklıdır. Bu, Mac kullanıcıları için fiziksel açıdan da daha rahat bir çözümdür.
 
diff --git a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md
index 86d4c65eb..f5b8bbf46 100644
--- a/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md
+++ b/2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/article.md
@@ -50,7 +50,7 @@ Bu, eğer kullanıcı fareyi çok hızlı hareket ettiriyorsa, bazı DOM ögeler
 
 Eğer fare `#FROM` ögesinden`#TO` ögesine çok hızlı bir şekilde hareket ederse, ortadaki `<div>` ögeleri (ya da bazıları) atlanabilir. `mouseout` olayı `#FROM` ogesinde ve ardından aniden `#TO` ögesi üzerinde tetiklenir.
 
-Bu, performans için iyidir, çünkü arada bir çok öge bulunabilir. Her birinde olay tetiklemeyi her zaman istemeyiz.
+Bu, performans için iyidir, çünkü arada birçok öge bulunabilir. Her birinde olay tetiklemeyi her zaman istemeyiz.
 
 Öte yandan, fare ımlecinin yol boyunca tüm öğeleri "ziyaret etmediğini" unutmamalıyız. Bu ögelerin üzerinden "zıplayabilir".
 
@@ -65,7 +65,7 @@ Hızlı fare hareketi durumunda, ortadaki elementler olay tetiklemeyebilirler. A
 ```online
 Aşağıdaki test standında "canlı" olarak kontrol edebilirsiniz.
 
-HTML iç içe geçmiş `<div>` ögelerinden oluşuyor. Eğer farenizi onların üzerinden hızlıca hareket ettirirseniz, hiç bir olay tetiklenmeyebilir, belki sadece kırmızı div olay tetikleyebilir ya da sadece yeşil div tetikleyebilir.
+HTML iç içe geçmiş `<div>` ögelerinden oluşuyor. Eğer farenizi onların üzerinden hızlıca hareket ettirirseniz, hiçbir olay tetiklenmeyebilir, belki sadece kırmızı div olay tetikleyebilir ya da sadece yeşil div tetikleyebilir.
 
 Ayrıca, fareyi kırmızı "div" nin üzerine getirmeyi deneyin ve ardından hızlıca yeşil olandan aşağı doğru hareket ettirin. Hareket yeterince hızlıysa, ana öğe göz ardı edilir.
 
diff --git a/2-ui/4-forms-controls/3-events-change-input/article.md b/2-ui/4-forms-controls/3-events-change-input/article.md
index 8470eb2c5..aa637f8e7 100644
--- a/2-ui/4-forms-controls/3-events-change-input/article.md
+++ b/2-ui/4-forms-controls/3-events-change-input/article.md
@@ -8,7 +8,7 @@ Hadi veri güncellemelerine eşlik eden çeşitli olayları tartışalım.
 
 Bu olay metin girişleri için odak kaybedildiği zaman meydana gelir.
 
-Örneğin, aşağıdaki metin alanına birşey yazarken olay yok. Ama odağı başka bir yere taşıdığımızda, örneğin, butona tıkladığımızda bir `change` olayı olacak:
+Örneğin, aşağıdaki metin alanına bir şey yazarken olay yok. Ama odağı başka bir yere taşıdığımızda, örneğin, butona tıkladığımızda bir `change` olayı olacak:
 
 ```html autorun height=40 run
 <input type="text" onchange="alert(this.value)">
diff --git a/2-ui/4-forms-controls/4-forms-submit/article.md b/2-ui/4-forms-controls/4-forms-submit/article.md
index 416a7db00..fd71288bd 100644
--- a/2-ui/4-forms-controls/4-forms-submit/article.md
+++ b/2-ui/4-forms-controls/4-forms-submit/article.md
@@ -38,7 +38,7 @@ Bu oldukça komik çünkü hiç tıklama yoktu.
 Örnek:
 ```html autorun height=60
 <form onsubmit="return false">
- <input type="text" size="30" value="Buraya tıkla ve birşeyler yaz sonra enter'e bas">
+ <input type="text" size="30" value="Buraya tıkla ve bir şeyler yaz sonra enter'e bas">
  <input type="submit" value="Submit" *!*onclick="alert('click')"*/!*>
 </form>
 ```
diff --git a/8-web-components/1-webcomponents-intro/article.md b/8-web-components/1-webcomponents-intro/article.md
index f9427462b..2715f0099 100644
--- a/8-web-components/1-webcomponents-intro/article.md
+++ b/8-web-components/1-webcomponents-intro/article.md
@@ -1,76 +1,76 @@
-# From the orbital height
+# Yörünge yüksekliğinden
 
-This section describes a set of modern standards for "web components".
+Bu bölüm, "web bileşenleri" için bir dizi modern standardı tanımlayacaktır.
 
-As of now, these standards are under development. Some features are well-supported and integrated into the modern HTML/DOM standard, while others are yet in draft stage. You can try examples in any browser, Google Chrome is probably the most up to date with these features. Guess, that's because Google fellows are behind many of the related specifications.
+Şu anda bu standartlar geliştirme aşamasındadır. Bazı standartlar iyi bir desteğe sahip ve modern HTML/DOM standardına entegre edilmişken, diğerleri henüz taslak aşamasındadır. Örnekleri herhangi bir tarayıcıda deneyebilirsiniz, Google Chrome muhtemelen bu özellikler konusundaki en güncel tarayıcı seçeneği olacaktır. Bunun nedeni belki de Google takımının ilgili birçok özelliğin arkasında olmasıdır.
 
-## What's common between...
+## ... arasında ortak olan nedir?
 
-The whole component idea is nothing new. It's used in many frameworks and elsewhere.
+Bu bileşen fikri tamamen yeni bir şey değil. Birçok framework ve dahası tarafından daha önceden kullanılmaktaydı.
 
-Before we move to implementation details, take a look at this great achievement of humanity:
+Detayları tanımlamaya başlamadan önce insanlığın bu büyük başarısına bir göz atalım:
 
 ![](satellite.jpg)
 
-That's the International Space Station (ISS).
+Bu, Uluslararası Uzay İstasyonu (ISS).
 
-And this is how it's made inside (approximately):
+Bu ise içerisinde ne olduğu (hemen hemen):
 
 ![](satellite-expanded.jpg)
 
-The International Space Station:
-- Consists of many components.
-- Each component, in its turn, has many smaller details inside.
-- The components are very complex, much more complicated than most websites.
-- Components are developed internationally, by teams from different countries, speaking different languages.
+Uluslararası Uzay İstasyonu:
+- Birçok bileşenden meydana gelir.
+- Her bileşen kendi tarafında, içerisinde çok sayıda küçük detaylara sahiptir.
+- Bileşenler oldukça karmaşık, birçok websitesinden çok daha karmaşık bir yapıdadır.
+- Bileşenler; farklı dilleri konuşan, farklı ülkelerden takımlar tarafından, uluslararası olarak geliştirilir.
 
-...And this thing flies, keeps humans alive in space!
+... Ayrıca bu şey, içerisinde insanları canlı tutarak uzayda uçar!
 
-How such complex devices are created?
+Bu kadar karmaşık cihazlar nasıl oluşturulur?
 
-Which principles we could borrow to make our development same-level reliable and scalable? Or, at least, close to it.
+Geliştirmemizi aynı düzeyde güvenilir ve ölçeklenebilir hale getirmek için hangi prensipleri ödünç alabiliriz? En azından, yaklaşabilmek için.
 
-## Component architecture
+## Bileşen mimarisi
 
-The well known rule for developing complex software is: don't make complex software.
+Karmaşık yazılım geliştirmenin en meşhur kuralı şudur: karmaşık yazılım yapma.
 
-If something becomes complex -- split it into simpler parts and connect in the most obvious way.
+Bir şey eğer karmaşıklaşacaksa -- onu parçalara ayır ve birbiriyle en açık şekilde bir araya getir.
 
-**A good architect is the one who can make the complex simple.**
+**İyi bir mimar, karmaşığı basit bir şekilde oluşturabilendir.**
 
-We can split user interface into visual components: each of them has own place on the page, can "do" a well-described task, and is separate from the others.
+Kullanıcı arayüzünü görsel bileşenlere ayırabiliriz: herbiri sayfada kendi yerine sahip olur, iyi tanımlanmış bir görev "yapar" ve diğerlerinden ayrıdır.
 
-Let's take a look at a website, for example Twitter.
+Şimdi bir web sitesine, örneğin Twitter'a bir göz atalım.
 
-It naturally splits into components:
+Doğal olarak bileşenlere ayrılıyor:
 
 ![](web-components-twitter.svg)
 
-1. Top navigation.
-2. User info.
-3. Follow suggestions.
-4. Submit form.
-5. (and also 6, 7) -- messages.
+1. Üst menü.
+2. Üye bilgisi.
+3. Takip önerileri.
+4. Gönderi formu.
+5. (ve aynı zamanda 6, 7) -- mesajlar.
 
-Components may have subcomponents, e.g. messages may be parts of a higher-level "message list" component. A clickable user picture itself may be a component, and so on.
+Bileşenler alt bileşenlere sahip olabilir; örneğin mesajlar, bir üst seviyedeki "mesaj listesi" bileşeninin birer parçası olabilir. Tıklanabilir bir kullanıcı resmi kendi başına bir bileşen olabilir ve bu şekilde gider.
 
-How do we decide, what is a component? That comes from intuition, experience and common sense. Usually it's a separate visual entity that we can describe in terms of what it does and how it interacts with the page. In the case above, the page has blocks, each of them plays its own role, it's logical to make these components.
+Bir bileşenin ne olduğuna nasıl karar vereceğiz? Bu biraz da sezgiden, deneyimden ve sağduyudan gelir. Genellikle ne yaptığını ve sayfa ile nasıl etkileşimde bulunduğunu tanımlayabildiğimiz, ayrılmış bir görsel varlıktır. Yukarıdaki durumda sayfa bloklara sahiptir, bunların herbiri kendi rolünü oynar. Bu durumda bunları bileşen yapmak mantıklıdır.
 
-A component has:
-- its own JavaScript class.
-- DOM structure, managed solely by its class, outside code doesn't access it ("encapsulation" principle).
-- CSS styles, applied to the component.
-- API: events, class methods etc, to interact with other components.
+Bir bileşen şunlara sahiptir:
+- kendi JavaScript sınıfı.
+- yalnızca kendi sınıfı tarafından yönetilen DOM mimarisi, dış kod buna erişemez ("kapsülleme" prensibi).
+- Bileşen tarafından uygulanan CSS stilleri
+- API: diğer bileşenlerle etkileşime geçmek için olaylar, sınıf metotları vs.
 
-Once again, the whole "component" thing is nothing special.
+Bir kez daha değinelim, tüm bu "bileşen" yapısı özel bir şey değildir.
 
-There exist many frameworks and development methodologies to build them, each one with its own bells and whistles. Usually, special CSS classes and conventions are used to provide "component feel" -- CSS scoping and DOM encapsulation.
+Bunları oluşturmak için çok fazla framework ve geliştirme metodolojisi vardır, herbirinin kendi gösterişi vardır. Genellikle "bileşen hissi" sağlamak adına, CSS kapsamı ve DOM kapsülleme için özel CSS sınıfları ve kuralları kullanır.
 
-"Web components" provide built-in browser capabilities for that, so we don't have to emulate them any more.
+"Web bileşenleri" bunun için yerleşik tarayıcı özellikleri sağlar, bu yüzden bunları artık taklit etmemize gerek yok.
 
-- [Custom elements](https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements) -- to define custom HTML elements.
-- [Shadow DOM](https://dom.spec.whatwg.org/#shadow-trees) -- to create an internal DOM for the component, hidden from the others.
-- [CSS Scoping](https://drafts.csswg.org/css-scoping/) -- to declare styles that only apply inside the Shadow DOM of the component.
-- [Event retargeting](https://dom.spec.whatwg.org/#retarget) and other minor stuff to make custom components better fit the development.
+- [Özel elementler](https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements) -- özel HTML elementleri tanımlamak için.
+- [Gölge DOM](https://dom.spec.whatwg.org/#shadow-trees) -- bileşen için iç DOM oluşturarak onu diğerlerinden gizlemek için.
+- [CSS Kapsamı](https://drafts.csswg.org/css-scoping/) -- yalnızca bileşen içindeki Gölge DOM'a etki edecek stiller tanımlamak için.
+- [Olay yeniden hedefleme](https://dom.spec.whatwg.org/#retarget) ve özel bileşenlerin geliştirmeye daha çok uyması için diğer şeyler.
 
-In the next chapter we'll go into details of "Custom Elements" -- the fundamental and well-supported feature of web components, good on its own.
+Bir sonraki bölümde, web bileşenleri için temel, iyi desteğe sahip ve kendi başına iyi bir yapıya sahip olan "Özel Elementler"in detaylarına ineceğiz.
diff --git a/8-web-components/index.md b/8-web-components/index.md
index f572ed3d4..962ee8b7a 100644
--- a/8-web-components/index.md
+++ b/8-web-components/index.md
@@ -1,3 +1,3 @@
-# Web components
+# Web bileşenleri
 
-Web components is a set of standards to make self-contained components: custom HTML-elements with their own properties and methods, encapsulated DOM and styles.
+Web bileşenleri, kendi içinde bir bütün oluşturan bileşenler oluşturmak için var olan bir dizi standarttır. Bunlar; kendi özelliklerine ve metotlarına sahip, DOM ve stilleri sarmalayan özel HTML elementleridir.
diff --git a/README.md b/README.md
index e3b07ed86..f75245343 100755
--- a/README.md
+++ b/README.md
@@ -103,7 +103,7 @@ Eğer dış kaynak linkleri Wikipedia ise ve iyi bir kaynak olarak görüyorsan
 
 MDN'de eğer bir bölümü tercüme edilmiş ise buraya link verebilirsiniz.
 
-Eğer hiç bir çevirisi yoksa linki olduğu gibi bırakın.
+Eğer hiçbir çevirisi yoksa linki olduğu gibi bırakın.
 
 ### Metadata