Merge branch 'master' of https://github.com/torgeek/learnxinyminutes-docs

17 files changed, 6368 insertions, 997 deletions

diff --git a/tr-tr/c++-tr.html.markdown b/tr-tr/c++-tr.html.markdown
new file mode 100644
index 00000000..9d65cf9c
--- /dev/null
+++ b/tr-tr/c++-tr.html.markdown
@@ -0,0 +1,1076 @@
+---
+language: c++
+lang: tr-tr
+filename: learncpp-tr.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
+    - ["Ankush Goyal", "http://github.com/ankushg07"]
+    - ["Jatin Dhankhar", "https://github.com/jatindhankhar"]
+    - ["Adem Budak", "https://github.com/p1v0t"]
+---
+
+C++ 
+[yaratıcısı Bjarne Stroustrup'a göre](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+
+- "daha iyi bir C" yapmak
+- veri soyutlamayı desteklemek 
+- nesneye yönelik programlamayı deskteklemek
+- tipten bağımsız programlamayı desteklemek 
+
+için tasarlanmış bir sistem programlama dilir.
+
+Sözdizimi daha yeni dillerden daha zor veya karmaşık olsa da işlemcinin doğrudan çalıştırabileceği
+native komutlara derlenerek, donanım üzerinde (C gibi) sıkı bir kontrol sağlar, bunu yaparken
+tipten bağımsızlık, exception'lar ve sınıflar gibi yüksek-seviyeli özellikleri destekler.
+Bu hız ve kullanışlılık C++'ı en çok kullanılan dillerden biri yapar.
+
+```c++
+//////////////////////
+// C ile karşılaştırma
+//////////////////////
+
+// C++ _neredeyse_ C'nin bir üstkümesidir, değişken tanımı, basit tipleri
+// ve fonksiyonları için temelde aynı sözdizimini paylaşır.
+
+// Aynı C gibi, programın başlangıç noktası bir integer döndüren 
+// main fonksiyonudur.
+// Bu değer programın bitiş statüsünü belli eder.
+// Daha fazla bilgi için bknz http://en.wikipedia.org/wiki/Exit_status .
+
+int main(int argc, char** argv)
+{
+    // Komut satırı argümanları C'de olduğu gibi argv ve argc ile geçilir
+    // argc, argüman sayısını belli eder,
+    // argv, argümanları belli eden, C-stili string'lerin (char*) dizisidir.
+    // İlk argüman çağrılan programın adıdır.
+    // Eğer argümanları umursamıyorsan, argv ve argc kullanılmayabilir 
+    // int main() gibi
+
+    // 0 çıkış durumu başarıyı belirtir.
+    return 0;
+}
+
+// Bunlara rağmen C++ aşağıdaki noktalarda farklılaşır:
+
+// C++'ta, karakterler char türündendir
+sizeof('c') == sizeof(char) == 1
+
+// C'de, karakterler int türündendir
+sizeof('c') == sizeof(int)
+
+
+// C++ katı bir prototip kuralına sahiptir
+void func(); // fonksiyon argüman kabul etmez
+
+// C'de
+void func(); // fonksiyon herhangi bir sayıda argüman kabul edebilir
+
+// C++'da NULL yerine nullptr kullanılır
+int* ip = nullptr;
+
+// C standard başlıkları başına "c" eklenip, sondaki .h
+// kullanılmadan C++'ta kullanılabilir
+#include <cstdio>
+
+int main()
+{
+    printf("Hello, world!\n");
+    return 0;
+}
+
+//////////////////////////////////
+// Fonksiyonun fazladan yüklenmesi
+//////////////////////////////////
+
+// C++ herbir fonksiyonun farklı parametereler
+// aldığı fonksiyon fazladan yüklenmesini desktekler 
+
+void print(char const* myString)
+{
+    printf("String %s\n", myString);
+}
+
+void print(int myInt)
+{
+    printf("My int is %d", myInt);
+}
+
+int main()
+{
+    print("Hello"); // void print(const char*) fonksiyonunu çağırır.
+    print(15); // void print(int) fonksiyonunu çağırır.
+}
+
+////////////////////////////////
+// Default fonksiyon argümanları
+////////////////////////////////
+
+// Eğer çağırıcı tarafından fonksiyona argüman sağlanmamışsa,
+// fonksiyona default argüman verebilirsin
+
+void doSomethingWithInts(int a = 1, int b = 4)
+{
+    // Burada int'lerle birşeyler yap
+}
+
+int main()
+{
+    doSomethingWithInts();      // a = 1,  b = 4
+    doSomethingWithInts(20);    // a = 20, b = 4
+    doSomethingWithInts(20, 5); // a = 20, b = 5
+}
+
+// Default argümanlar, argüman listesinin sonunda yer almalı.
+
+void invalidDeclaration(int a = 1, int b) // Hata!
+{
+}
+
+
+/////////////////////////
+// Namespace(İsim uzayı)
+/////////////////////////
+
+// Namespace'ler değişken, fonksiyon ve diğer bildirimlerin 
+// kapsama alanını ayırır. 
+// Namespace'ler içiçe geçebilir.
+
+namespace First {
+    namespace Nested {
+        void foo()
+        {
+            printf("This is First::Nested::foo\n");
+        }
+    } // Nested namespace'inin sonu
+} // First namespace'inin sonu
+
+namespace Second {
+    void foo()
+    {
+        printf("This is Second::foo\n");
+    }
+}
+
+void foo()
+{
+    printf("This is global foo\n");
+}
+
+int main()
+{
+    // Second namespace'i içinideki tüm sembolleri mevcut kapsama alanına dahil eder.
+    // Dikkat edersen artık yalnızca foo() çağrısı çalışmayacaktır çünkü hangi
+    // namespace'ten çağrıldığı açık değildir.
+    using namespace Second;
+
+    Second::foo(); // "This is Second::foo" yazdırıır
+    First::Nested::foo(); // "This is First::Nested::foo" yazdırır
+    ::foo(); // "This is global foo" yazdırır.
+}
+
+///////////////
+// Input/Output
+///////////////
+
+// C++'ta input ve output stream'leri kullanır.
+// cin, cout ve cerr,sırasıyla, stdin, stdout, ve stderr'i temsil eder.
+// << araya ekleme ve >> aradan çıkarma operatörüdür.
+
+#include <iostream> // I/O stream'lerini dahil etmek için
+
+using namespace std; // Streamler std namespace'i içindedir(standard kütüphane)
+
+int main()
+{
+   int myInt;
+
+   // stdout (veya terminal/screen)'ta çıktı verir
+   cout << "Enter your favorite number:\n";
+   // Girdiyi alır 
+   cin >> myInt;
+
+   // cout ayrıca formatlanabilir
+   cout << "Your favorite number is " << myInt << "\n";
+   // prints "Your favorite number is <myInt>"
+
+    cerr << "Used for error messages";
+}
+
+//////////////
+// String'ler
+/////////////
+
+// String'ler C++'ta nesnedir ve pek çok üye fonksiyonu vardır
+#include <string>
+
+using namespace std; // String'ler de std namespace'i içindedir. (standard kütüphane)
+
+string myString = "Hello";
+string myOtherString = " World";
+
+// + eklemek için kullanıldır 
+cout << myString + myOtherString; // "Hello World"
+
+cout << myString + " You"; // "Hello You"
+
+// C++'ta  stringler are mutable'dır (değişebilir).
+myString.append(" Dog");
+cout << myString; // "Hello Dog"
+
+
+///////////////////////
+// Reference (Referans)
+///////////////////////
+
+// C'deki pointer'lara ek olarak 
+// C++ _reference_'lara sahiptir.
+// Bunlar bir kere atandınğında tekrardan atanamayan pointer'dır
+// ve null olamaz.
+// Değişkenin kendisiyle aynı sözdizimine sahiptir:
+// Değerine ulaşmak için * ihtiyaç yoktur ve
+// atama için & (address of) kullanılmaz.
+
+using namespace std;
+
+string foo = "I am foo";
+string bar = "I am bar";
+
+
+string& fooRef = foo; // Bu foo'nun reference'ını oluşturur.
+fooRef += ". Hi!"; // foo'yu reference'ı üzerinden değiştirir.
+cout << fooRef; // "I am foo. Hi!" yazdırır.
+
+// "fooRef"e yeniden atama yapmaz. Bu "foo = bar" denktir ve bu satırdan sonra
+//  foo == "I am bar" olur
+cout << &fooRef << endl; // foo'un adresini yazdırır
+fooRef = bar;
+cout << &fooRef << endl; //Hala foo'nun adresini yazdırır
+cout << fooRef;  //"I am bar" yazdırır
+
+// fooRef'in adresi aynı kalır yani hala foo'nun adresidir.
+
+const string& barRef = bar; // bar'a const reference oluşturur
+// C'de olduğu gibi, const değerler (pointer'lar ve reference'ler) değiştirilemez.
+barRef += ". Hi!"; // Hata, const reference'ler değiştirilemez.
+
+// Kısa bir ekleme: reference'lere devam etmeden önce, geçici nesne konseptinden
+// bahsetmeliyiz. Mesela aşadaki gibi bir kod var:
+string tempObjectFun() { ... }
+string retVal = tempObjectFun();
+
+// Bu iki satırda aslında ne oluyor:
+//   - tempObjectFun fonksiyonundan bir string nesnesi dönüyor
+//   - dönmüş olan nesneyle yeni bir string oluşturuyor
+//   - dönmüş olan nesne yok ediliyor
+// İşte bu dönen nesneye geçici nesne denir. Geçici nesneler fonksiyon nesne
+// döndürdüğünde oluşturulur ve ifade işini bitirdiğinde yok edilir (Aslında,
+// standard'ın söylediği şey bu ama derleyiciler bu davranışı değiştirmemize 
+// izin veriyor. Daha fazla detay için "return value optimization" diye
+// aratabilirsin. Sonuç olarak aşağıdaki kodda:
+foo(bar(tempObjectFun()))
+
+// foo ve bar'ın varolduğunu kabul ediyoruz, tempObjectFun'dan dönen nesne
+// bar'a geçti ve foo çağrılmadan önce yokedildir.
+
+// Şimdi reference'lara dönelim. "ifadenin sonunda" kuralının bir istisnası
+// eğer geçici nesne const reference'a geçildiyse oratya çıkar, bu durumda
+// nesnenin ömrü mevcut kapsama alanına kadar uzar:
+
+void constReferenceTempObjectFun() {
+  // constRef geçici nesneyi alır ve bu durum fonksiyonun sonuna kadar geçerlidir.
+  const string& constRef = tempObjectFun();
+  ...
+}
+
+// C++11 ile gelen diğer bir reference geçici nesnelere özeldir. Bu türden birden 
+// bir tip tanımlayamazsın ama aşırı yüklenme sırasında bu tipler öncelik alır:
+void someFun(string& s) { ... }  // Regular reference
+void someFun(string&& s) { ... }  // Geçici nesneye reference 
+
+string foo;
+someFun(foo);  // regular reference'ı çağırır
+someFun(tempObjectFun());  // geçici reference'ı çağırır
+
+/////////////////////
+// Enum
+/////////////////////
+
+// Enum'lar sabit değerler yapmak için kullanılır ve çoğunlukla kodun daha okunaklı
+// olması için kullanılır
+
+enum ECarTypes
+{
+  Sedan,
+  Hatchback,
+  SUV,
+  Wagon
+};
+
+ECarTypes GetPreferredCarType()
+{
+	return ECarTypes::Hatchback;
+}
+
+// C++11 ile beraber bir tipi enum'a atamanın kolay bir yolu var, bu enum'un istenen
+// tipe dönüştürmek için kullanışlı bir yöntem
+enum ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Serialize the InputValue to a file
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// enum uint8_t tipine dönüştürüldü
+	WriteByteToFile(InputCarType);
+}
+
+// Diğer yandan enum'ların yanlışlıkla integer tipini veya diğer enumlara dönüşmesini
+// istemiyorsan enum class olarak tanımlayabilirsin
+enum class ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Serialize the InputValue to a file
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// ECarTypes, uint8_t tipinde olmasına rağmen, "enum class" olarak 
+	// tanımlandığından derlenmeyecektir!
+	WriteByteToFile(InputCarType);
+}
+
+///////////////////////////////////////////
+// Sınıflar ve nesneye yönelik proglamalama
+///////////////////////////////////////////
+
+// Sınıflara(class) ilk örnek
+#include <iostream>
+
+// Sınıfı tanımla.
+// Sınıflar genelde header (.h veya .hpp) dosyalarında tanımlanır.
+class Dog {
+    // Üye değişkenler ve fonksiyonlar default olarak private'dir.
+    std::string name;
+    int weight;
+
+// Aşağıda, "private:" veya "protected:" bulunana kadar
+// bütün üyeler public'tir.
+public:
+
+    // Default constructor
+    Dog();
+
+    // Üye fonksiyon bildirimi (gerçeklenimi aşağıda)
+    // Dikkat ederseniz using namespace std; yerine
+    // std::string kullandık.
+    // Hiçbir zaman header dosyasında "using namespace std;" kullanma.
+    void setName(const std::string& dogsName);
+
+    void setWeight(int dogsWeight);
+
+    // Nesnenin durumunu değiştirmeyen fonksiyonlar const ile işaretlenmelidir
+
+    // Türetilen sınıflarda fonksiyonu override edebilmek için başına 
+    // _virtual_ eklenmelidir.
+    // Fonksiyonlar, performanslar ilgili nedenlerden ötürü default olarak virtual değildir
+    virtual void print() const;
+
+    // Fonksiyonlar class içinde de tanımlanabilir.
+    // Bu şekille tanımlanan fonksiyonlar otomatik olarak inline olur.
+    void bark() const { std::cout << name << " barks!\n"; }
+
+    // C++ constructor'ların yanında destructor'da sağlar.
+    // Bunlar nesne silindiğinde veya scope'un dışına çıktığında çağrılır.
+    // Bu RAII gibi güçlü paradigmaları etkin kılar.
+    // (aşağıda açıklandı)
+    // Eğer sınıf kendisinden türetiliyorsa, destructor virtual olmalıdır,
+    // eğer virtual değilse, türetilmiş sınıfın destructor'ı nesne, ana sınıf
+    // referans'ı veya pointer'ı üzerinden yok edildiğinde, çağrılmayacaktır.
+    virtual ~Dog();
+
+}; // class tanımının sonuda noktalı virgül(;) olmalıdır.
+
+// Sınıfın üye fonksiyonları genelde .cpp dosyaları içinde gerçeklenir.
+Dog::Dog()
+{
+    std::cout << "A dog has been constructed\n";
+}
+
+// Objects (such as strings) should be passed by reference
+// Nesneler (string gibi) reference ile fonksiyonlara geçilmelidir
+// Eğer nesneleri değiştirilecekse reference ile fonksiyonlara geçilmelidir,
+// değiştirilmeyecekse const reference ile geçilmelidir.
+void Dog::setName(const std::string& dogsName)
+{
+    name = dogsName;
+}
+
+void Dog::setWeight(int dogsWeight)
+{
+    weight = dogsWeight;
+}
+
+// Dikkat edersen "virtual" yalnızca bildirimde gerekli, tanımlamada değil.
+void Dog::print() const
+{
+    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
+}
+
+Dog::~Dog()
+{
+    std::cout << "Goodbye " << name << "\n";
+}
+
+int main() {
+    Dog myDog; // "A dog has been constructed" yazdırır
+    myDog.setName("Barkley");
+    myDog.setWeight(10);
+    myDog.print(); // "Dog is Barkley and weighs 10 kg" yazdırır.
+    return 0;
+} // "Goodbye Barkley" yazdırır.
+
+// Inheritance(Miras)
+
+// Bu sınıf, Dog sınıfında public ve protected olan herşeyi miras alır, 
+// private olanları da miras alır ama, public ve protected sınıflar aracılıyla
+// yapılmıyorsa, doğrudan erişemez.
+class OwnedDog : public Dog {
+
+public:
+    void setOwner(const std::string& dogsOwner);
+
+    // print fonksiyonunun davranışını bütün OwnedDogs sınıfı için override eder
+    // (üstünden geçer, kendine uyarlar).
+    // bknz http://en.wikipedia.org/wiki/Polymorphism_(computer_science)
+    // override anahtar sözcüpü kullanılma da olur ama kullanılması aslında bir temel
+    // temel sınıf fonksiyonunun üzerinden geçtiğimizi gösterir.
+    void print() const override;
+
+private:
+    std::string owner;
+};
+
+// Bu arada takip eden .cpp dosyasında:
+
+void OwnedDog::setOwner(const std::string& dogsOwner)
+{
+    owner = dogsOwner;
+}
+
+void OwnedDog::print() const
+{
+    Dog::print(); // Ana dog sınıfındaki print fonksiyonunu çağırır 
+    std::cout << "Dog is owned by " << owner << "\n";
+    // 	      "Dog is <name> and weights <weight>"
+    //        "Dog is owned by <owner>"
+    // 	       yazdırır
+}
+
+/////////////////////////////////////////////////////
+// ilk değer atama ve Operatörün fazladan yüklenmesi
+/////////////////////////////////////////////////////
+
+// C++ dilinde +, -, *, /, gibi operatörlerin davranışını fazladan yükleyebilirsiniz.
+// Bu, operator her kullandınıldığında çağrılan bir fonksiyon tanımlamasıyla yapılır.
+
+#include <iostream>
+using namespace std;
+
+class Point {
+public:
+    // Üye değişkenkenlere default değer atanabilir.
+    double x = 0;
+    double y = 0;
+    
+    // Default constructor
+    Point() { };
+
+    Point (double a, double b) :
+        x(a),
+        y(b)
+    { /* İlk değer atama dışında birşey yapma */ }
+
+    // + operatorünün fazladan yükle.
+    Point operator+(const Point& rhs) const;
+
+    // += operatorünü fazladan yükle
+    Point& operator+=(const Point& rhs);
+
+    // - ve -= operatorleri fazladan yüklemek de mantıklı olurdu
+    // ama kısa tutmak için burda değinmedik.
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+    // yeni bir nokta oluştur ve bunu rhs ile topla
+    return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Point up (0,1);
+    Point right (1,0);
+    // Bu Point + operatorünü çağırır
+    Point result = up + right;
+    // "Result is upright (1,1)" yazdırır.
+    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+    return 0;
+}
+
+////////////////////////
+// Şablonlar (Templates)
+////////////////////////
+
+// Şablonlar C++ dilinde tipten bağımsız programlama için kullanılır.
+
+// Zaten aşina olduğun tipten bağımsız programlamayla başladık. Bir tip parametresi
+// alan fonksiyon veya sınıf tanımlamaık için:
+template<class T>
+class Box {
+public:
+    // Bu sınıfta T, herhangi bir tip için kullanılabilir.
+    void insert(const T&) { ... }
+};
+
+// Derleme esnasında derleyici aslında, parametreleri yerine konmuş şekilde herbir şablonu üretir,
+// bu yüzden sınıfın tam tanımı her çağrılma sırasında var olmak zorundadır. Bu nedenle şablon sınıflarını
+// tamamen header dosyalarında görürsün.
+
+// Stack'ta şablon sınıfın bir örneğini oluşturmak için:
+Box<int> intBox;
+
+// ve, anladığın gibi, kullanabilirsin:
+intBox.insert(123);
+
+// Tabi, şablonları içiçe geçirebilirsin:
+Box<Box<int> > boxOfBox;
+boxOfBox.insert(intBox);
+
+// C++11'den önce iki '>' arasına boşluk koymak zorundaydık yoksa sağa kaydırma 
+// operatörü olarak algılanabilirdi.
+
+// Bazen şunu da görebilirsin
+//   template<typename T>
+// 'class' ve 'typename' anahtar sözcükleri çoğunlukla 
+// birbirlerinin yerine kullanılabilir. Tam açıklama için, bknz.
+//   http://en.wikipedia.org/wiki/Typename
+// (evet, bu anahtar sözcüğün kendi Wikipedia sayfası var).
+
+// Benzer şekilde, bir şablon fonksiyon:
+template<class T>
+void barkThreeTimes(const T& input)
+{
+    input.bark();
+    input.bark();
+    input.bark();
+}
+
+// Dikkat edersen tip parametresi hakkında birşey belirtilmedi. Derleyici bunları üretecek
+// ve her parametre geçişinde tip-kontrolü yapacaktır, bu nedenle de fonksiyon herhangi bir T
+// tipi için çalışacaktır!
+
+Dog fluffy;
+fluffy.setName("Fluffy")
+barkThreeTimes(fluffy); // Üç kere "Fluffy barks" yazdırır.
+
+// Şablonun parametresi sınıf olmak zorunda değildir:
+template<int Y>
+void printMessage() {
+  cout << "Learn C++ in " << Y << " minutes!" << endl;
+}
+
+// Ve template'i daha etkili kod için dışarıdan özelleştirebilirsin. 
+// Tabiki gerçek-dünya kullanımlarında özelleştirme bunun kadar kolay değildir.
+// Dikkat edersen, bütün parametreleri dıştan özelleştirmiş olsak bile
+// hala fonksiyonu (veya sınıfı( template olarak tanımlamamız gerekli.
+template<>
+void printMessage<10>() {
+  cout << "Learn C++ faster in only 10 minutes!" << endl;
+}
+
+printMessage<20>();  // "Learn C++ in 20 minutes!" yazdırır
+printMessage<10>();  // "Learn C++ faster in only 10 minutes!" yazdırır
+
+
+///////////////////////////////////////////////
+// İstisnai Durum Yönetimi (Exception Handling)
+///////////////////////////////////////////////
+
+// Standard kütüphane bazı istisnai tipler sağlar
+// (bknz http://en.cppreference.com/w/cpp/error/exception)
+// ama herhangi bir tip de istisnai durum fırlatabilir 
+
+#include <exception>
+#include <stdexcept>
+
+// _try_ bloğu içinde fırlatılan bütün istisnai durumlar, takip eden, _catch_ ile 
+// yakalanabilir.
+try {
+    // _new_ kullanarak heap'ten istisnai durumlar için yer ayırma
+    throw std::runtime_error("A problem occurred");
+}
+
+// istisnai durumlar nesne ise  const reference ile yakala
+catch (const std::exception& ex)
+{
+    std::cout << ex.what();
+}
+
+// Bir önceki _catch_ bloğundan kaçan istisnai durum burda yakala
+catch (...)
+{
+    std::cout << "Unknown exception caught";
+    throw; // Tekrardan istisnai durum fırlatır
+}
+
+///////
+// RAII
+///////
+
+// RAII, "Resource Acquisition Is Initialization" kelimelerinin kısaltmasıdır.
+// Bu Türkçe, "Kaynak alımı aynı zamanda ilk değer atamasıdır." olarak çevrilebilir.
+// Bunu basitçe constructor ile ayrılan hafızanın destructor ile iade edilmesi olarak 
+// düşünebiliriz.
+
+// Bunun ne şekilde kullanışlı olduğunu görmek için
+// bir C dosyasının, dosya işleme biçimine bakabiliriz:
+void doSomethingWithAFile(const char* filename)
+{
+    // Başlangıçta herşeyin yolunda gittiğini düşünelim
+
+    FILE* fh = fopen(filename, "r"); // Dosyayı okuma modunda aç
+
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+    fclose(fh); // Dosyayı kapat
+}
+
+// Malesef hatalarla başa çıkmaya çalışırken işler hızlıca karmaşıklaşır.
+// Mesela fopen'ın başarısız olduğunu varsayalım, ve doSoomethingWithTheFile ve 
+// doSomethingWithIt hata kodları gönderdi.
+//  (İstisnai durumlar yonetimi, hata koduna tercih ediler bir yöntemdir, ama bazı
+//   programcılar, özellikle C arkaplanı olanlar, aynı fikirde değildir.
+// Bu durumda her bir fonksiyon çağrısını kontrol etmeli ve bir problem oluştuysa
+// dosyayı kapatmalıyız.
+
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r");  // Dosyayı okuma modunda aç
+    if (fh == nullptr) // Başarısız olma durumunda dönen değer null olur
+        return false; // Başarısız olma durumunu çağırıcıya bildir
+
+    // Başarısız olma durumunda her iki fonksiyonun da false döndürdüğünü kabul edelim
+    if (!doSomethingWithTheFile(fh)) {
+        fclose(fh); // Dosyayı kapatalım, akıntı olmasın.
+        return false; // Hatayı bildir
+    }
+    if (!doSomethingElseWithIt(fh)) {
+        fclose(fh); // Dosyayı kapatalım, akıntı olmasın.
+        return false; // Hatayı bildir
+    }
+
+    fclose(fh); // Dosyayı kapat
+    return true; // Başarı durumunu ifade eder
+}
+
+// C programcıları biraz goto kullanarak bu durumu temizler
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r");
+    if (fh == nullptr)
+        return false;
+
+    if (!doSomethingWithTheFile(fh))
+        goto failure;
+
+    if (!doSomethingElseWithIt(fh))
+        goto failure;
+
+    fclose(fh); // Dosyayı kapat 
+    return true; // Başarı durumunu ifade eder
+
+failure:
+    fclose(fh);
+    return false; // Hatayı bildir
+}
+
+// Eğer fonksiyon istisnai durum yönetimi araçlarını kullanırsa
+// işler daha temiz olur ama hala en iyi durumun altında kalır.
+void doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); 
+    if (fh == nullptr)
+        throw std::runtime_error("Could not open the file.");
+
+    try {
+        doSomethingWithTheFile(fh);
+        doSomethingElseWithIt(fh);
+    }
+    catch (...) {
+        fclose(fh); // Hata durumunda dosyayı kapattığından emin ol
+        throw; // Sonra, tekrardan istisnai durum fırlat
+    }
+
+    fclose(fh); // Dosyayı kapat
+    // Herşey başarılı
+}
+
+// Şimdi aynı şeyi C++'ın dosya stream sınıfıyla (fstream) karşılaştıralım
+// fstream, dosyayı kapatmak için kendi destructor'ını kullanır.
+// Destructor'ın, nesne scope dışına çıktığında otomatik olarak çağrıldığını 
+// hatırlayın.
+void doSomethingWithAFile(const std::string& filename)
+{
+    std::ifstream fh(filename); // Dosyayı aç
+
+    // Dosyayla birşeyler yap
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+} // Dosya, destructor tarafından otomatik olarak kapatıldı
+
+// Bunun _çok büyük_ avantajları var:
+// 1. Ne olursa olursun,
+//    kaynak (bu örnekte dosya tutucusu) temizlenecektir.
+//    Destructor doğru yazıldığında,
+//    Tutucuyu kapatmayı unutma ve kaynak akıntısı _imkansız_dır.
+// 2. Kodun çok daha temiz olduğuna dikkat edin.
+//    Destructor, dosyayı kapatma işini, endilenmemize gerek kalmadan
+//    arka planda halleder.
+// 3. Kod, istisnai durumlara karşı korunaklıdır.
+//    İstisnai durum fonksiyonun herhangi bir yerinde fırlatılabilir ve
+//    temizleme işi gene de yapılır.
+
+// Bütün C++ kodu deyimleri RAII prensibini tüm kaynakları için kullanır.
+// Ek örnekler şunlardır:
+// - unique_ptr ve shared_ptr ile hafıza kullanımı
+// - Tutucular - standard kütüphane linked list,
+//   vector (yani kendiliğinden boyu ayarlanan dizi), hash map vs.
+//   scope'un dışına çıktığında içerini otomatik olarak yok eden tüm yapılar.
+// - lock_guard ve unique_lock kullanan mutex'ler
+
+///////////////////////////////////////
+// Lambda İfadeleri (C++11 ve yukarısı)
+///////////////////////////////////////
+
+// lambda'lar, tam olarak çağrıldığı yerde bir anonim fonksiyon tanımlamak
+// veya fonksiyona argüman geçmek için uygun bir yoldur.
+
+// Mesela, pair'lardan oluşan bir vector'u, pair'ın ikinci değerine 
+// göre sıralamak isteyelim
+
+vector<pair<int, int> > tester;
+tester.push_back(make_pair(3, 6));
+tester.push_back(make_pair(1, 9));
+tester.push_back(make_pair(5, 0));
+
+// sort fonksiyonuna üçüncü argüman olarak lambda ifadesini geç
+// sort, <algorithm> başlığında tanımlı
+
+sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs) {
+        return lhs.second < rhs.second;
+    });
+
+// Lambda ifadesinin söz dizimine dikkat edin, 
+// lambda'daki [], değişkenleri "tutmak" için kullanılır
+// "Tutma listesi", fonksiyon gövdesinde nelerin, ne şekilde erişilebilir olduğunu tanımlar
+// Şunlardan biri olabilir:
+// 	1. bir değer : [x]
+//	2. bir referans : [&x]
+//	3. mevcut scope içindeki herhangi bir değişkene referans ile [&]
+//	4. 3 ile aynı, ama değer ile [=]
+// Mesela:
+vector<int> dog_ids;
+// number_of_dogs = 3;
+for(int i = 0; i < 3; i++) {
+	dog_ids.push_back(i);
+}
+
+int weight[3] = {30, 50, 10};
+
+// Mesela dog_ids vector'unu dog'ların ağırlıklarına göre sıralamak isteyelim
+// Yani en sonunda şöyle olmalı: [2, 0, 1]
+
+// Burada lambda ifadesi oldukça kullanışlıdır
+
+sort(dog_ids.begin(), dog_ids.end(), [&weight](const int &lhs, const int &rhs) {
+        return weight[lhs] < weight[rhs];
+    });
+// Dikkat edersen "weight" dizisini referans ile aldık.
+// C++'da lambdalar hakkında daha fazla bilgi için : http://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11
+
+//////////////////////////////////
+// Akıllı For (C++11 ve yukarısı)
+//////////////////////////////////
+
+// Akıllı for döngüsünü bir tutucuyu dolaşmak için kullanabilirsin
+int arr[] = {1, 10, 3};
+
+for(int elem: arr){
+	cout << elem << endl;
+}
+
+// Tutucunun elemanlarının tipi için endişe etmeden "auto" kullanabilirsin
+// Mesela:
+
+for(auto elem: arr) {
+	// arr dizisinin elemanlarıyla ilgili bir şeyler yap
+}
+
+////////////////
+// Güzel Şeyler
+////////////////
+
+// C++ dilinin bakış açısı yeni başlayanlar için (hatta dili iyi bilenler için bile)
+// şaşırtıcı olabilir. 
+// Bu bölüm, ne yazık ki, büyük ölçüde tam değil; C++ kendi ayağına ateş edilebilecek kolay
+// dillerden biridir.
+
+// private metodları override edebilirsin!
+class Foo {
+  virtual void bar();
+};
+class FooSub : public Foo {
+  virtual void bar();  // Foo::bar fonksiyonu override edilir!
+};
+
+
+// 0 == false == NULL (çoğu zaman)!
+bool* pt = new bool;
+*pt = 0; // 'pt'nin gösterdiği değere false atar.
+pt = 0;  // 'pt'ye null pointer atar. Her iki satır uyarısız derlenir.
+
+// nullptr'ın bu meselenin bazılarını çözmesi beklenmiştir:
+int* pt2 = new int;
+*pt2 = nullptr; // Derlenmez.
+pt2 = nullptr;  // pt2'ye null atar.
+
+// bool tipleri için bir istisna vardır.
+// Bu null pointer'ları if(!ptr) ile test etmek içindir.
+// ama sonuç olarak bir bool değerine nullptr atayabilirsin!
+*pt = nullptr;  // '*pt' değeri bir boll olmasına rağmen, hala derlenir!
+
+
+// '=' != '=' != '='!
+// Calls Foo::Foo(const Foo&) or some variant (see move semantics) copy
+// Foo::Foo(const Foo&) çağrısını veya kopyalama constructor'ının bir çeşidinin çağrısınıyapar(taşıma semantiklerine bknz.)
+Foo f2;
+Foo f1 = f2;
+
+// Foo::operator=(Foo&) çağrısını yapar.
+Foo f1;
+f1 = f2;
+
+
+///////////////////////////////////////
+// Tuple (C++11 ve yukarısı)
+///////////////////////////////////////
+
+#include<tuple>
+
+// Ana fikir olarak, Tuple, eski veri yapılarına (C'deki struct'lar) benzer ama isimli veri üyeleri yerine 
+// elemanlarına tuple içindeki sırasına göre erişilir.
+
+// Tuple'ı inşa ederek başlayalım
+// değişkenleri tuple içinde paketliyoruz
+auto first = make_tuple(10, 'A');
+const int maxN = 1e9;
+const int maxL = 15;
+auto second = make_tuple(maxN, maxL);
+
+// 'first' tuple'ının değerlerini yazdırma
+cout << get<0>(first) << " " << get<1>(first) << "\n"; // 10 A yazdırır
+
+// 'second' tuple'ının değerlerini yazdırma
+cout << get<0>(second) << " " << get<1>(second) << "\n"; // 1000000000 15 yazdırır
+
+// Değişkenleri tuple'dan çıkarma
+
+int first_int;
+char first_char;
+tie(first_int, first_char) = first;
+cout << first_int << " " << first_char << "\n";  // 10 A yazdırır
+
+// Ayrıca şu şekide de tuple oluşturabiliriz.
+
+tuple<int, char, double> third(11, 'A', 3.14141);
+// tuple_size, tuple'daki eleman sayısını (constexpr olarak) döndürür
+
+cout << tuple_size<decltype(third)>::value << "\n"; // 3 yazdırır
+
+// tuple_cat, tuple'daki tüm elemanları aynı sırada birleştirir.
+
+auto concatenated_tuple = tuple_cat(first, second, third);
+// concatenated_tuple = (10, 'A', 1e9, 15, 11, 'A', 3.14141) olur
+
+cout << get<0>(concatenated_tuple) << "\n"; // 10 yazdırır
+cout << get<3>(concatenated_tuple) << "\n"; // 15 yazdırır
+cout << get<5>(concatenated_tuple) << "\n"; // 'A' yazdırır
+
+
+/////////////////////
+// Tutucular
+/////////////////////
+
+// Tutucular veya Standard Şablon Kütüphanesi(STL) önceden tanımlanmış şablonlar sunar.
+// Bunlar elemanları için ayrılan hafıza alanını yönetir
+// ve onlara erişim ve değiştirmek için üye fonksiyonlar sağlar
+
+// Bazı tutucular şunlardır:
+
+// Vector (Dinamik Dizi)
+// koşma anında nesne dizisi veya list oluşturmamızı sağlar
+#include <vector>
+string val;
+vector<string> my_vector; // vector'ü tanımla
+cin >> val;
+my_vector.push_back(val); // val değerini my_vector vectörüne push edecektir
+my_vector.push_back(val); // val değerini yeniden push edecektir (şu an iki elemanı var)
+
+// vector içinde dolaşmak için iki seçenek var:
+// ya klasik döngüyle (0. index'ten son index'e kadar iterasyon yaparak)
+for (int i = 0; i < my_vector.size(); i++) {
+	cout << my_vector[i] << endl; // vector'ün elemanlarına uşamak için [] operatörünü kullanabiliriz
+}
+
+// ya da iteratör kulllanarak:
+vector<string>::iterator it; // vector için iterator tanımla
+for (it = my_vector.begin(); it != my_vector.end(); ++it) {
+	cout << *it  << endl;
+}
+
+// Set(Küme)
+// Set'ler benzersiz(unique) elemanları belirli bir sırada saklayan tutuculardır.
+// Set, benzersiz değerleri, herhangi bir fonksiyon veya kod gerektirmeksizin, sıralı olarak
+
+#include<set>
+set<int> ST;    // int tipi için set tanımlar
+ST.insert(30);  // ST kümesini 30 değerini dahil eder
+ST.insert(10);  // ST kümesini 10 değerini dahil eder
+ST.insert(20);  // ST kümesini 20 değerini dahil eder
+ST.insert(30);  // ST kümesini 30 değerini dahil eder
+// Şimdi kümedeki elemanlar aşağıdaki gibidir
+//  10 20 30
+
+// Bir eleman silmek için:
+ST.erase(20);  // 20 değerine sahip elemanı siler
+// Set ST: 10 30
+// Iterator kullanarak Set içinde iterasyon yapmak için:
+set<int>::iterator it;
+for(it=ST.begin();it<ST.end();it++) {
+	cout << *it << endl;
+}
+// Output:
+// 10
+// 30
+
+// Tutucuyu tamamen silmek için Tutucu_Adi.clear() kullanırız
+ST.clear();
+cout << ST.size();  // ST kümesinin eleman sayısı(size)nı yazdırır.
+// Output: 0
+
+// NOTE: Aynı elemanlari içerebilen kümle için multiset kullanırız
+
+// Map(Harita)
+// Map, elemanları anahtar değer, haritalanmış değer şeklinde özel bir sırada saklar.
+// anahtar_değer -> haritalanmış_değer
+
+#include<map>
+map<char, int> mymap;  // Anahtar char ve değer int olacak şekilde map tanımlar
+
+mymap.insert(pair<char,int>('A',1));
+// 1 değeri için A anahtar değerini ekler
+mymap.insert(pair<char,int>('Z',26));
+// 26 değeri için Z anahtar değerini ekler
+
+// Map'te dolaşma
+map<char,int>::iterator it;
+for (it=mymap.begin(); it!=mymap.end(); ++it)
+    std::cout << it->first << "->" << it->second << '\n';
+// Output:
+// A->1
+// Z->26
+
+// Anahtar'a atanmış değeri bulmak için
+it = mymap.find('Z');
+cout << it->second;
+
+// Output: 26
+
+
+/////////////////////////////////////////////
+// Mantıksal ve Bit seviyesindeki operatörler
+/////////////////////////////////////////////
+
+// Pek çok C++ operatörleri diğer dillerdekiyle aynıdır
+
+// Mantıksal operatörler
+
+// C++, bool ifadelerinde Kısa-devre değerlendirmesini kullanır yani ikinci argüman yalnızca ilk argüman
+// ifadenin değerine karar vermek için yeterli değilse çalıştırılır
+
+true && false // **mantıksal ve** işlemi yapılır ve yanlış sonucu üretilir
+true || false // **mantıksal veya** işlemi yapılır ve true  sonucu üretilir 
+! true        // **mantıksal değil** işlemi yapılır ve yalnış sonucu üretilir
+
+// Sembolleri kullanmak yerine onlara karşılık gelen anahtar kelimeler kullanılabilir
+true and false // **mantıksal ve** işlemi yapılır ve yanlış sonucu üretilir
+true or false  // **mantıksal veya** işlemi yapılır ve true  sonucu üretilir 
+not true       // **mantıksal değil** işlemi yapılır ve yalnış sonucu üretilir
+
+// Bit seviyesindeki operatörler
+
+// **<<** Sola kaydırma operatörü
+// << bitleri sola kaydırır
+4 << 1 // 4'ün bitlerini 1 sola kaydırır ve 8 sonucunu verir
+// x << n, x * 2^n olarak düşünülebilir
+
+
+// **>>** Sağa kaydırma operatörü
+// >> bitleri sağa kaydırır
+4 >> 1 // 4'ün bitlerini 1 sağa kaydırır ve 2 sonucunu verir
+// x >> n, x / 2^n olarak düşünülebilir
+
+~4    // Bit seviyesinde değil işlemini gerçekleştirir
+4 | 3 // Bit seviyesinde veya işlemini gerçekleştirir
+4 & 3 // Bit seviyesinde ve işlemini gerçekleştirir
+4 ^ 3 // Bit seviyesinde xor işlemini gerçekleştirir
+
+// Eşdeğer anahtar kelimeler
+compl 4    // Bit seviyesinde değil işlemini gerçekleştirir
+4 bitor 3  // Bit seviyesinde veya işlemini gerçekleştiri
+4 bitand 3 // Bit seviyesinde ve işlemini gerçekleştirir
+4 xor 3    // Bit seviyesinde xor işlemini gerçekleştirir
+
+
+```
+İleri okuma:
+
+* Güncel bir referans [CPP Reference](http://cppreference.com/w/cpp) adresinde bulunabilir.
+* Ek kaynaklar [CPlusPlus](http://cplusplus.com) adresinde bulunabilir.
+* Dilin temellerini ve kodlama ortamını belirleyen bir öğretici [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb) adresinde bulunabilir.
diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
index 33544765..4ef12527 100644
--- a/tr-tr/c-tr.html.markdown
+++ b/tr-tr/c-tr.html.markdown
@@ -477,11 +477,11 @@ typedef void (*my_fnp_type)(char *);
 
 [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)'in bir kopyasını bulundurmak mükemmel olabilir
 
-Diğer bir iyi kaynak ise [Learn C the hard way](http://c.learncodethehardway.org/book/)
+Diğer bir iyi kaynak ise [Learn C the hard way](http://learncodethehardway.org/c/)
 
 It's very important to use proper spacing, indentation and to be consistent with your coding style in general.
 Readable code is better than clever code and fast code. For a good, sane coding style to adopt, see the
-[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle).
+[Linux kernel coding style](https://www.kernel.org/doc/Documentation/CodingStyle).
 
 Diğer taraftan google sizin için bir arkadaş olabilir.
 
diff --git a/tr-tr/clojure-tr.html.markdown b/tr-tr/clojure-tr.html.markdown
new file mode 100644
index 00000000..5ebe5ce6
--- /dev/null
+++ b/tr-tr/clojure-tr.html.markdown
@@ -0,0 +1,491 @@
+---
+language: clojure
+lang: tr-tr
+filename: learnclojure-tr.clj
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+    - ["Seçkin KÜKRER", "https://leavenha.github.io"]
+translators:
+    - ["Seçkin KÜKRER", "https://leavenha.github.io"]
+---
+
+[JVM]: https://tr.wikipedia.org/wiki/Java_sanal_makinesi
+[STM]: https://en.wikipedia.org/wiki/Software_transactional_memory
+
+Clojure, Lisp dialekti, barınan bir dildir. [JVM][JVM] üzerinde barınıyor. Clojure, Lisp'in tüm gücü ve kendi mantalitesi ile mükemmel bir genel-amaçlı programlama dilidir. Clojure, Eş-zamanlı programlama, Makrolar, Fonksiyonel Programlama, Tembel yapılar ve daha fazlasını vaadediyor.
+
+(Bu örnekleri çalıştırmak için Clojure 1.2 versionu veya daha yenisine sahip olmalısınız.)
+
+
+```clojure
+; Noktalı Virgül, satırı yorumlamak için kullanılır.
+
+; Clojure programları formlardan meydana gelir,
+; Parantezlerle çevirili değerler, boşluk ile ayrılır. --Virgül ile değil--
+;
+; Clojure okuyucusu*, listedeki ilk elemanı çağırılacak bir fonksiyon
+; Veya makro, geri kalan ifadeleri o çağırıma argüman olarak kabul eder.
+;
+
+; Bir dosyadaki ilk çağırım isim-uzayı tanımlamak için `ns` olmalı.
+(ns clojure-öğren)
+
+;
+; Bir diğer yorumlama seçeneği de, ifade-içi. Bu diyez (`#`), ve alt çizgi
+; İle başlar ve herhangi bir s-ifade'ye uygulanabilir.
+;
+#_(bu çağırım değerlendirilmeyecektir)
+
+; Öncelikle fonksiyon çağırımları ve temel işlemler:
+
+; Örnek bir fonksiyon çağırımı:
+; (örnek-bir-fonksiyon ilk-argüman ikinci-argüman)
+
+; `str` aldığı argümanları bir karakter katarı olarak geri verir.
+(str "Merhaba" " " "dünya!") ; => "Merhaba dünya!"
+
+; Matematik, oldukça sezgisel ve basit
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+
+; Eşitlik için `=`
+(= 1 1) ; => true
+(= 2 1) ; => false
+
+; `not` beklediğiniz gibi, mantıksal ifadeleri tersine çevirir.
+(not true) ; => false
+
+; Clojure formları, iç-içe çağırılabilir
+; Değerlendirilen çağırımlar bir üst form'a argüman
+; Olarak verilir.
+(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+
+; Tipler
+;;;;;;;;;;;;;
+
+; Clojure, Java'nın temel tipleri olan mantıksal (boolean),
+; Tam sayılar (int) ve karakter katarlarını (string) kullanır.
+; Değerleri denetlemek için `class` fonksiyonunu kullanın.
+(class 1) ; Tam sayı sabitleri ön-tanımlı olarak `java.lang.Long` ile tanımlanır.
+(class 1.); Kayan noktalı sayı sabitleri
+; Ön-tanımlı olarak `java.lang.Double` ile tanımlanır.
+(class ""); Karakter katarı sabitleri her zaman, --sadece-- çift tırnak
+; ile tanımlanır ve ön-tanımlı olarak `java.lang.String` tipindedir.
+(class false) ; Mantıksal değer sabitleri, `java.lang.Boolean`.
+(class nil); "Null", (tanımsız) değerler `nil` ile tanımlanır.
+
+; Clojure okuyucusu her paranter ifadesini bir çağırım olarak
+; değerlendirdiğinden bir liste tanımlamak için çağırımı durdurmalıyız.
+'(+ 1 2) ; => (+ 1 2)
+; ((quote (+ 1 2)) için bir kısa yoldur)
+
+; Alıntılanmış listeleri çağırabilirsiniz.
+(eval '(+ 1 2)) ; => 3
+
+; Koleksiyonlar ve Ardışıklar
+;;;;;;;;;;;;;;;;;;;
+
+; Listeler bağlı-liste veri yapısı,
+; Vektörler dizi altyapısı kullanır. 
+(class '(1 2 3)); => clojure.lang.PersistentList
+(class [1 2 3]); => clojure.lang.PersistentVector
+
+; Bir liste `(1 2 3)` şeklinde gösterilebilir, yazılabilir.
+; Fakat bu listeyi, Alıntılamalıyız --Quote--.
+; Bu, onu bir fonksiyon çağırımı olarak değil,
+; bir liste olarak değerlendirilmesini sağlayacaktır.
+; Ayrıca, `(list 1 2 3)` tamamen `'(1 2 3)` ifadesi ile
+; eşdeğerdir.
+
+; 'Koleksiyonlar' sadece bir veri grubudur.
+; Vektörler ve Listeler, koleksiyondur:
+(coll? '(1 2 3)) ; => true
+(coll? [1 2 3]) ; => true
+
+; 'Ardışıklar' (seqs), bir veri listesinin soyut tanımlamasıdır.
+; Sadece listeler ardışıktır.
+(seq? '(1 2 3)) ; => true
+(seq? [1 2 3]) ; => false
+
+; Bir ardışık, ulaşıldığında sadece giriş verisi vermelidir.
+; Yani, ardışıklar tembel olabilir. | Sonsuz ardışıklar tanımlanabilir.
+(range 4) ; => (0 1 2 3)
+(range) ; => (0 1 2 3 4 ...) (sonsuz bir ardışık)
+(take 4 (range)) ;  (0 1 2 3)
+
+; Bu yapılarda ekleme işlemi için `cons` kullanılır.
+(cons 4 [1 2 3]) ; => (4 1 2 3)
+(cons 4 '(1 2 3)) ; => (4 1 2 3)
+
+; `conj` bir koleksiyona en verimli şekilde veri ekler.
+; Bu, listeler için liste başına, vektörler için ise vektör sonuna demektir.
+(conj [1 2 3] 4) ; => [1 2 3 4]
+(conj '(1 2 3) 4) ; => (4 1 2 3)
+
+; `concat` koleksiyonları birleştirmek için kullanılır.
+(concat [1 2] '(3 4)) ; => (1 2 3 4)
+
+; `filter` ve `map` koleksiyonlarla işlem yapmak için
+; ön-tanımlı yüksek-seviyeli fonksiyonlardır.
+;
+; ps: `inc` argümanını bir arttıran bir fonksiyon.
+(map inc [1 2 3]) ; => (2 3 4)
+(filter even? [1 2 3]) ; => (2)
+
+; Koleksiyonları indirgemek için `reduce` kullanılır.
+(reduce + [1 2 3 4])
+; = (+ (+ (+ 1 2) 3) 4)
+; => 10
+
+; Reduce, bir ilk-tanım değeri alabilir.
+(reduce conj [] '(3 2 1))
+; = (conj (conj (conj [] 3) 2) 1)
+; => [3 2 1]
+
+; Fonksiyonlar
+;;;;;;;;;;;;;;;;;;;;;
+
+; Yeni bir fonksiyon oluşturmak için `fn` kullanın.
+; Bir fonksiyon her zaman son ifadesini döndürür.
+(fn [] "Merhaba Dünya!") ; => fn
+
+; Fonksiyonu çağırmak için bir çift paranteze daha ihtiyaç var.
+((fn [] "Merhaba Dünya!")) ; => "Merhaba Dünya!"
+
+; İsim uzayında bir değişken tanımlamak için `def`
+; kullanılır.
+(def x 1)
+x ; => 1
+
+; Bir değişkene fonksiyon değeri atamak için,
+(def merhaba-dünya (fn [] "Merhaba Dünya!"))
+(merhaba-dünya) ; => "Merhaba Dünya!"
+
+; Bu süreci, `defn` ile kısaltabiliriz.
+(defn hello-world [] "Merhaba Dünya!")
+
+; `defn` fonksiyon çağırımındaki üçüncü eleman
+; --vektör-- bir argüman listesidir. Fonksiyonun alacağı
+; argümanları tanımlar.
+(defn merhaba [isim]
+  (str "Merhaba " isim))
+(merhaba "Dünya!") ; => "Merhaba Dünya!"
+
+; Ayrıca, `#()` kısa yolunu, fonksiyon deklare etmek için
+; kullanabiliriz.
+(def merhaba2 #(str "Merhaba " %1))
+(merhaba2 "Dünya!") ; => "Merhaba Dünya!"
+
+; Çok düzeyli fonksiyonlar da tanımlanabilir,
+(defn merhaba3
+  ([] "Merhaba Dünya!")
+  ([isim] (str "Merhaba " isim)))
+(merhaba3) ; => "Merhaba Dünya!"
+(merhaba3 "A. NESİN!") ; => "Hello A. NESİN!"
+
+; Fonksiyonlar, belirsiz-sayıda argüman alabilir,
+; ve bunları sizin için bir ardışıkta depolayabilir.
+(defn argüman-sayısı [& argümanlarım]
+  (str "Verilen argüman sayısı:" (count argümanlarım) ", argümanlar: " argümanlarım))
+(argüman-sayısı "Öğün" "Çalış" "Güven")
+; => "Verilen argüman sayısı:3, argümanlar: ("Öğün" "Çalış" "Güven")"
+
+; Elbette, sıradan ve belirsiz-sayılı fonksiyon argümanlarını
+; harmanlayabilirsiniz.
+(defn merhabalar [ev-sahibi & misafirler]
+  (str "Merhabalar, " misafirler ". Benim adım " ev-sahibi "."))
+(merhabalar "İklim" "Ayşe" "Fatma" "Nurdan")
+; => "Merhabalar, (\"Ayşe\" \"Fatma\" \"Nurdan\"). Benim adım İklim."
+
+
+; Eşlemeler
+;;;;;;;;;;
+
+; Hash-Maps, Array-Maps
+; Hash-Eşlemeleri ve Dizi-Eşlemeleri bir arayüzü paylaşırlar.
+; Hash-Eşlemeleri daha hızlıdır, fakat anahtar sıralaması tutmazlar.
+(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
+(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
+
+; Dizi-Eşlemeleri bir çok işlem sırasında otomatik olarak Hash-Eşlemelerine
+; dönüşürler. Eğer yeterince büyürlerse, endişelenmenize gerek yoktur.
+
+; Eşlemeler anahtar değeri olarak herhangi hash-ifadesi (hashable)
+; alabilirler. Ama çoğunlukla, bu iş için anahtar-kelimeler `keyword`
+; kullanılır.
+; Anahtar-kelimeler, karakter katarları gibidirler, fakat
+; bir kaç artıları vardır.
+(class :a) ; => clojure.lang.Keyword
+
+(def karakterkatarı-eşlemesi {"a" 1, "b" 2, "c" 3})
+karakterkatarı-eşlemesi  ; => {"a" 1, "b" 2, "c" 3}
+
+(def anahtar-eşlemesi {:a 1, :b 2, :c 3})
+anahtar-eşlemesi ; => {:a 1, :c 3, :b 2}
+
+; Bu arada, virgüller her zaman boşluk olarak değerlendirilir
+; ve etkisizdirler.
+
+; Bir eşlemeleden fonksiyon notasyonu ile değer çağırmak,
+(karakterkatarı-eşlemesi "a") ; => 1
+(anahtar-eşlemesi :a) ; => 1
+
+; Keyword tipleri kendi değerlerini argüman olarak aldıkları bir
+; eşlemeden değer notasyonu ile çağırabilirler.
+(:b anahtar-eşlemesi) ; => 2
+
+; Bu notasyonu, bir karakter katarı ile denemeyiniz.
+;("a" karakterkatarı-eşlemesi)
+; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+
+; Verilmemiş bir değeri çağırmak, `nil` döndürecektir.
+(karakterkatarı-eşlemesi "d") ; => nil
+
+; Eşlemelere yeni değerler eklemek için `assoc` kullanırız.
+(def yeni-anahtar-eşlemesi (assoc anahtar-eşlemesi :d 4))
+yeni-anahtar-eşlemesi ; => {:a 1, :b 2, :c 3, :d 4}
+
+; Ama unutmayın, Clojure veri yapıları değişmezdir!
+anahtar-eşlemesi ; => {:a 1, :b 2, :c 3}
+
+; Değer silmek için ise `dissoc` kullanılır.
+(dissoc anahtar-eşlemesi :a :b) ; => {:c 3}
+
+; Kümeler
+;;;;;;
+
+(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
+(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
+
+; `conj` ile bir değer eklenir.
+(conj #{1 2 3} 4) ; => #{1 2 3 4}
+
+; `disj` ile değer çıkarılır.
+(disj #{1 2 3} 1) ; => #{2 3}
+
+; Fonksiyon notasyonu kümelerde de tanımlıdır.
+; Kendi içlerinde değer arayan bir fonksiyon olarak
+; kullanılabilirler.
+(#{1 2 3} 1) ; => 1
+(#{1 2 3} 4) ; => nil
+
+; `clojure.sets` isim-uzayında daha fazla fonksiyon vardır.
+
+; Kullanışlı Formlar
+;;;;;;;;;;;;;;;;;
+
+; Clojure için mantıksal yapılar bir özel-form'dur.
+; Ve diğer fonksiyonlar gibi kullanılabilir.
+; `if` fonksiyonunun ilk argümanı bir test ifadesidir.
+(if true "ya şundadır" "ya bunda") ; => "ya şundadır"
+; İkinci ifade doğru, üçüncü ifade ise yanlışsa ifadeleridir.
+; Eğer test terimi doğru olarak değerlendirilirse,
+; doğru ifadesi, yanlışsa yanlış ifadesi değerlendirilir ve döndürülür.
+;
+; Bir yanlışsa ifadesi yoksa `nil` döndürülür.
+(if false "a") ; => nil
+
+; Yerel geçici-değişken tanımlamak için `let` kullanılır.
+; İfadelerin varlığı `let` çağırımı ile sınırlıdır.
+(let [a 1 b 2]
+  (> a b)) ; => false
+
+; İfade ve çağırımları `do` ile gruplayabilirsiniz.
+; Çağırımların sonuncusu `do` ifadesinin değeri olarak 
+; döndürülecektir.
+(do
+  (print "Selamlar!")
+  "Dünya!") ; => "Dünya!" (prints "Selamlar!")
+
+; Fonksiyonlar kapalı bir `do` ifadesi ile çevrelenmiştir.
+(defn yazdır-ve-selamla! [isim]
+  (println "Merhaba, " isim "!")
+  (str "Merhaba, " isim "!"))
+(yazdır-ve-selamla! "Zübeyde") ;=> "Merhaba, Zübeyde!" ("Merhaba, Zübeyde!" yazdırır.)
+
+; `let` ifadesi de kapalı bir `do` ile gelmektedir.
+(let [isim "Ayten"]
+  (print "Merhabalar, " isim)
+  (str "Merhabalar, " isim)) ; => "Merhabalar, " ("Merhabalar, Ayten" yazdırır)
+
+; Sıralama-makroları (-> ve ->>) ile veri dönüşümünü daha temiz ifade
+; edebilirsiniz.
+; Bu makrolar ilk argümanı sonraki her çağırımın içine yerleştirir.
+;
+; `->` makrosu, ifadeyi çağırımların ilk argümanı olacak şekilde yerleştirir.
+(->
+   {:a 1 :b 2} 
+   (assoc :c 3) ;=> (assoc {:a 1 :b 2} :c 3)
+   (dissoc :b))
+   
+; Bu ifade aşağıdaki şekilde yazılabilir:
+; (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+; ve `{:a 1 :c 3}` olarak değer bulur.
+
+; Sondan-Sıralama-Makrosu (->>) ise aynı şeyi yapar,
+; tek fark ise, ifadeyi, çağırımların son argümanı olarak yerleştirir.
+;
+(->>
+   (range 10)    ;=> '(0 1 2 3 4 5 6 7 8 9)
+   (map inc)     ;=> (map inc (range 10))
+   (filter odd?) ;=> (filter odd? (map inc (range 10)))
+   (into []))    ;=> (into [] (filter odd? (map inc (range 10))))
+                 ; Sonuç: [1 3 5 7 9]
+
+; Bir ifadedeki önceki veri dönüşümlerinin sonucunu nereye
+; koyacağınız konusunda daha fazla özgürlük istediğiniz bir durumda,
+; Sıralama-Makrolarından daha özgür bi' şey kullanmak istersiniz;
+; `as->` makrosu ile dönüşümlerin çıktısına bir isim atayabilir
+; ve ardışık çağırımlarda yer tutucu olarak kullanabilirsiniz.
+
+(as-> [1 2 3] girdi
+  (map inc girdi);=> ifadeyi isterseniz çağırımın son argümanı olarak,
+  (nth girdi 2) ;=>  veya çağırımın ilk argümanı olarak, 
+  (conj [4 5 6] girdi [8 9 10])) ;=> ya da istediğiniz sırada kullanabilirsiniz.
+;=> [4 5 6 4 [8 9 10]]
+
+
+
+; Modüller
+;;;;;;;;;;;;;;;
+
+; `use` çağırdığınız modüldeki tüm tanımlara erişmenize olanak verir.
+(use 'clojure.set)
+
+; Şu anda, küme fonksiyonlarını kullanabiliriz.
+(intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
+(difference #{1 2 3} #{2 3 4}) ; => #{1}
+
+; Ayrıca eklenecek fonksiyonları seçebilirsiniz de:
+(use '[clojure.set :only [intersection]])
+
+; Bir modülü eklemek için `require` kullanılır. 
+(require 'clojure.string)
+
+; İsim-uzayı kapsamlı çağırımlar aşağıdaki şekildedir:
+; isim-uzayı/fonksiyon-ismi --isim uzayı ismi ve fonksiyon ismi
+; arasına eğik çizgi koymanız yeterli.
+; Burada, modül `clojure.string` ve fonksiyon ismi `blank?`
+(clojure.string/blank? "") ; => true
+
+; Ekleme sırasında, bir modüle takma-ad verilebilir.
+(require '[clojure.string :as str])
+(str/replace "Bu bir özet metindir, test için kullanılabilir!"
+  #"[aeıioöuü]" str/upper-case)
+; => "BU bIr ÖzEt mEtIndIr, tEst IçIn kUllAnIlAbIlIr!"
+; (#"", burada düzenli ifadeler için bir sözdizimsel-şekerlemeyi ifade eder)
+
+; Bir isim-uzayı tanımlamasında `require` kullanılabilir.
+; `ns` bir makrodur ve `require` (ve `use`, ama lütfen kullanmayın)
+; dahil olmak üzere bir çok çağırım için işlevsellik sağlamaktadır.
+; Bu notasyonu kullanırsanız, modüllerinizi alıntılamak zorunda kalmazsınız.
+(ns test
+  (:require
+    [clojure.string :as str]
+    [clojure.set :as set]))
+
+
+; Java
+;;;;;;;;;;;;;;;;;
+
+; Java, kocaman ve kullanışlı bir standart kütüphaneye sahip,
+; Clojure, Java etkileşimi ile, bundan yararlanabilirsiniz.
+
+; `import` diğer modüller gibi, bir java modülü de ele alabilir.
+; Date, bir Java modülü.
+(import java.util.Date)
+
+; `ns` çağırımında da kullanabilirsiniz.
+(ns test
+  (:import java.util.Date
+           java.util.Calendar))
+           
+; Bir Java nesnesinden oluşturmak için `new` çağırımını kullanabilirsiniz.
+(new Date)
+
+; Ayrıca Clojure Okuyucusu, size bunun daha farklı bir yolunu sunar:
+; Sınıf isminin sonuna koyulacak bir nokta `.` ile
+; bu yapılabilir.
+(Date.) ; <bir tarih nesnesi>
+
+; `.` --nokta-- çağırımı, size nesnelerdeki metotlara erişme imkanı verir.
+(. (new Date) getTime) ; <bir zaman-damgası>
+(.getTime (Date.)) ; Üstteki ifade ile tamamen aynı sonucu verir.
+
+; Sınıf içindeki statik metotlara erişmek için `/` ayracını
+; sınıf ile metot ismi birleştirmek için kullanabilirsiniz.
+; (örnekSınıf/statikMetot)
+(System/currentTimeMillis) ; <bir zaman-damgası> (`system` her zaman sunulur)
+
+; Sınıflarla işlem yaparken, `doto` bu süreci kolaylaştırabilir.
+; İlk argüman sınıf nesnesi, sonraki her çağırım, nesne üzerinde yapılır.
+(import java.util.Calendar)
+(doto (Calendar/getInstance)
+  (.set 2000 1 1 0 0 0) ; => `set` metodu, `doto` ifadesine verilen
+                        ; sınıf nesnesi üzerinde çağırılır.
+  .getTime) ; => Bir tarih nesnesi. set to 2000-01-01 00:00:00
+
+
+; STM
+;;;;;;;;;;;;;;;;;
+
+; 'Software Transactional Memory' Clojure'un değişmez veri yapılarını
+; ele alırken kullandığı bir mekanizmadır. Clojure içinde bunu kullanan
+; birkaç yapı vardır.
+
+; Bir `atom` en basitidir. Bir ilkleme-değeri verin.
+(def benim-atomum (atom {}))
+
+; Bir atomu güncellemek için `swap!` kullanılır.
+; `swap!` fonksiyonu, ilk argüman olarak aldığı atomu, ikinci argüman
+; olarak aldığı fonksiyona uygular. Bu fonksiyona ek argümanlar ise
+; fonksiyondan sonra gelirler.
+(swap! benim-atomum assoc :a 1)
+; benim-atomum'un değerini (assoc {} :a 1) ifadesinin sonucu ile değiştirir.
+(swap! benim-atomum assoc :b 2)
+; benim-atomum'un değerini (assoc {:a 1} :b 2) ifadesinin sonucu ile değiştirir.
+
+; `deref` ile, atomun değerini çözümleyebilirsiniz. 
+benim-atomum  ;=> Atom<#...> (Atom ifadesi döndürür)
+@benim-atomum ; => {:a 1 :b 2}
+
+; İşte, `atom` kullanan basit bir sayaç.
+(def sayaç (atom 0)) ;=> Şu anki isim uzayına, `sayaç` ile, 0 başlangıç
+; değeri ile bir atom tanımladık.
+(defn sayaç-arttır [benim-atomum]
+  (swap! sayaç inc)) ;=> Atom'un değerini bir arttır.
+
+(sayaç-arttır sayaç)
+(sayaç-arttır sayaç)
+(sayaç-arttır sayaç)
+(sayaç-arttır sayaç)
+(sayaç-arttır sayaç)
+(sayaç-arttır sayaç)
+
+@sayaç ; => 6
+
+; Diğer STM yapıları `ref`'ler ve `agent`'lar.
+; Ref'ler: http://clojure.org/refs
+; Agent'lar: http://clojure.org/agents
+```
+
+### Çevirim-içi içerikler
+
+Bu içerik, Rich Hickey'nin derin yazılım geliştirme anlayışına ve John McCarthy'nin vizyonu olan Lisp'in, Clojure'a miras verdiklerini anlamak için elbette yeterli değildir. Fakat fonksiyonel paradigma ve bu paradigmanın modern bir Lisp lehçesinde kullanımına göz kırpmış oldunuz.
+
+Clojure.org, bir çok içerik ve makale var. (İngilizce içerik):
+[http://clojure.org/](http://clojure.org/)
+
+Clojuredocs.org, örneklerle bezenmiş Clojure dökümantasyonu:
+[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+
+4Clojure, interaktif bir şekilde FP ve Clojure yeteneklerinizi geliştirmenize olanak veriyor:
+[http://www.4clojure.com/](http://www.4clojure.com/)
+
+Clojure-doc.org, Başlangıç için bir içeriklere sahip:
+[http://clojure-doc.org/](http://clojure-doc.org/)
+
+BraveClojure, bir başka clojure öğreten web sitesi:
+[https://www.braveclojure.com/](https://www.braveclojure.com/)
diff --git a/tr-tr/css-tr.html.markdown b/tr-tr/css-tr.html.markdown
new file mode 100644
index 00000000..d13dadcc
--- /dev/null
+++ b/tr-tr/css-tr.html.markdown
@@ -0,0 +1,304 @@
+---
+language: css
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+    - ["Connor Shea", "https://github.com/connorshea"]
+    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+    - ["Brett Taylor", "https://github.com/glutnix"]
+    - ["Tyler Mumford", "https://tylermumford.com"]
+filename: learncss-tr.css
+translators:
+    - ["Fatih Turan", "http://fatihturan.com"]
+lang: tr-tr
+---
+
+Web sayfaları bir sayfanın içeriğini belirleyen HTML ile inşa edilirler. CSS (Basamaklı Biçim Sayfaları) ise bir sayfanın **görünümünü** belirleyen ayrı bir dildir.
+
+CSS kodu statik *kurallardan* oluşur. Her kural bir ya da daha fazla *seçici* alır ve görsel *özelliklere* belirli *değerleri* verir. Sonrasında bu özellikler seçiciler tarafından belirlenen sayfa unsurlarına uygulanır.
+
+Bu rehber, CSS 3'ün yeni özellikleri ile genişletilen CSS 2 ile dikkate alınarak yazılmıştır.
+
+**NOT:** CSS görsel sonuçlar ürettiğinden dolayı, öğrenmek için herşeyi bir CSS oyun alanı içinde ([dabblet](http://dabblet.com) gibi) denemeniz gerekmektedir. Bu makale sözdizimi kuralları ve genel ipuçları üzerine odaklanmaktadır.
+
+## Sözdizimi
+
+```css
+/* yorumlar bu satırdaki gibi taksim-yıldız içinde görünür
+CSS'te "tek satırlık yorumlar" bulunmamaktadır; bu sadece tek bir yorum yazma stilidir */
+
+/* ####################
+   ## SEÇİCİLER
+   #################### */
+
+/* seçici bir sayfadaki unsuru hedeflemek için kullanılır. */
+seçici { özellik: değer; /* daha fazla özellikler...*/ }
+
+/*
+İşte bir örnek:
+
+<div class='class1 class2' id='anID' attr='value' otherAttr='en-us foo bar' />
+*/
+
+/*   */
+
+/* CSS sınıflarının birini kullanarak hedefleyebilirsiniz */
+.class1 { }
+
+/* veya her iki sınıfı birden!*/
+.class1.class2 { }
+
+/* veya sadece ögenin adını yazarak */
+div { }
+
+/* veya onun ID adını */
+#anID { }
+
+/* veya onun aldığı bir özelliği kullanarak! */
+[attr] { font-size:smaller; }
+
+/* veya onun aldığı özelliğin belirli bir değeri varsa */
+[attr='value'] { font-size:smaller; }
+
+/* bir değer ile başlıyorsa (CSS 3) */
+[attr^='val'] { font-size:smaller; }
+
+/*  veya bir değer ile bitiyorsa (CSS 3)*/
+[attr$='ue'] { font-size:smaller; }
+
+/* veya boşlukla ayrılmış liste içinde bir değer içeriyorsa */
+[otherAttr~='foo'] { }
+[otherAttr~='bar'] { }
+
+/*  veya tire ile ayrılmış bir liste içinde bir değer içeriyorsa, örneğin: "-" (U+002D) */
+[otherAttr|='en'] { font-size:smaller; }
+
+/*  Farklı seçicileri birleştirerek daha fazla odaklanmış bir seçici oluşturabilirsiniz. Seçiciler arasında boşluk bırakmayın. */
+div.some-class[attr$='ue'] { }
+
+/*  Başka bir ögenin alt ögesi olan bir ögeyi seçebilirsiniz. */
+div.some-parent > .class-name { }
+
+/* veya bir başka ögeden türeyeni seçebilirsiniz. Alt ögeler onların ebeveynlerinin direkt türünden gelir, sadece ağacın bir alt ögeleridirler. Soyundan gelenler ağacın herhangi bir alt seviyesinde olabilir. */
+
+div.some-parent .class-name { }
+
+/* Uyarı: Seçiciler arasında bir boşluk bırakmazsanız aynı seçicinin başka bir anlamı olur.
+Ne olduğunu tahmin edebilir misiniz?  */
+
+div.some-parent.class-name { }
+
+/*  Ayrıca bir ögenin bitişik kardeşini temel alarak bir ögeyi seçebilirsiniz. */
+.i-am-just-before + .this-element { }
+
+/*  veya kendisinden önce gelen herhangi bir kardeş ögeyi */
+.i-am-any-element-before ~ .this-element { }
+
+/* Yalnızca belli bir durumda bir öge seçmek için kullanılan sahte sınıflar adı verilen bazı seçiciler vardır. */
+
+/* Örneğin, imleç bir ögenin üzerine geldiğinde  */
+selector:hover { }
+
+/* veya bir bağlantı ziyaret edildiğinde  */
+selector:visited { }
+
+/*  veya ziyaret edilmediğinde */
+selected:link { }
+
+/*  veya bir ögeye odaklanıldığında */
+selected:focus { }
+
+/*  Ebeveyninin ilk alt ögesi olan herhangi bir öge */
+selector:first-child {}
+
+/*  Ebeveyninin son alt ögesi olan herhangi bir öge */
+selector:last-child {}
+
+/* Sahte sınıflar gibi sahte elementler de bir dokümanın belirli bir parçasına  stil vermenize izin verir. */
+
+/* Seçilen ögenin sanal ilk alt ögesiyle eşleşir. */
+selector::before {}
+
+/* Seçilen ögenin sanal son alt ögesiyle eşleşir. */
+selector::after {}
+
+/* Uygun yerlerde yıldız karakteri ile bütün ögeleri seçmek için joker olarak kullanılabilir. */
+
+* { } /* Bütün ögeler */
+.parent * { } /* Tüm alt ögeler */
+.parent > * { } /* Tüm çocuk ögeler */
+
+/* ####################
+   ## ÖZELLİKLER
+   #################### */
+
+selector {
+	
+	/* Ölçü birimleri kesin veya göreceli olabilir.*/
+
+	/* Göreceli birimler */
+    width: 50%;       /* Ebeveyn elementin yüzdesel olarak genişliği */
+    font-size: 2em;   /* Öğenin özgün yazı tipi boyutunda katları */
+    font-size: 2rem;  /* veya kök ögenin yazı tipi boyutu */
+    font-size: 2vw;   /* Görüntüleme çerçevesinin genişliğinin %1 olarak katları (CSS 3) */
+    font-size: 2vh;   /* veya onun yüksekliğinin */
+	font-size: 2vmin; /* Bir vh veya vw'nin hangisi küçükse */
+	font-size: 2vmax; /* veya daha büyük... */
+
+	/* Kesin birimler */
+    width: 200px;     /* Piksel */
+    font-size: 20pt;  /* Nokta */
+    width: 5cm;       /* Santimetre */
+    min-width: 50mm;  /* Milimetre */
+    max-width: 5in;   /* İnç */
+
+    /* Renkler */
+    color: #F6E;                 /* Kısa onaltılık (HEX) biçimi */
+    color: #FF66EE;              /* Uzun onaltılık (HEX) biçimi */
+    color: tomato;               /* Bir isim verilen renk */
+    color: rgb(255, 255, 255);   /* RGB değerleri verilen türde */
+    color: rgb(10%, 20%, 50%);   /* RGB yüzdeleri verilen türde */
+    color: rgba(255, 0, 0, 0.3); /* RGBA değerleri verilen türde (CSS 3) Not: 0 <= a <= 1 */
+    color: transparent;          /* Şeffaflık değerinin sıfır olması ile eşdeğer */
+    color: hsl(0, 100%, 50%);    /* HSL yüzdeleri verilen türde (CSS 3) */
+    color: hsla(0, 100%, 50%, 0.3); /* HSL ile beraber şeffaflık değeri verilen türde */
+
+    /* Kenarlıklar */
+    border-width:5px;
+    border-style:solid;
+    border-color:red;      /* background-color'ın ayarlanışına benzer şekilde */
+    border: 5px solid red; /* Bu aynı şeyin kısayol ile yazılışıdır */
+    border-radius:20px;    /* Bu bir CSS3 özelliğidir  */
+
+    /* Görseller ve Ögelerin Arkaplanları  */
+    background-image: url(/img-path/img.jpg); /* url() içindeki tırnak işaretleri isteğe bağlı */
+
+    /* Yazı tipleri */
+    font-family: Arial;
+    /* Eğer yazı tipi ailesi isminde bir boşluk var ise tırnak işareti içine alınmalıdır. */
+    font-family: "Courier New";
+    /* Eğer ilk sıradaki bulunamazsa, tarayıcı bir sonrakini kullanır */
+    font-family: "Courier New", Trebuchet, Arial, sans-serif;
+}
+```
+
+## Kullanım
+
+CSS dosyasınızı `.css`uzantısı ile kaydedin.
+
+```html
+<!-- CSS dosyanızı sayfanın içindeki <head> alanına dahil etmeniz gerekiyor. Bu önerilen yöntemdir. Bakın: http://stackoverflow.com/questions/8284365 -->
+<link rel='stylesheet' type='text/css' href='path/to/style.css'>
+
+<!-- Bazı CSS kodları satır içi olarak yazabilirsiniz. -->
+<style>
+   a { color: purple; }
+</style>
+
+<!-- Veya ögenin üzerinde CSS özelliklerini direkt ayarlayabilirsiniz. -->
+<div style="border: 1px solid red;">
+</div>
+```
+
+## Öncelik veya Basamak
+
+Bir öge birden çok seçici tarafından hedef alınabilir ve bir özellik kümesine birden fazla kez sahip olabilir. Bunun gibi durumlarda, kurallardan biri diğerlerine göre önceliklidir. Daha spesifik bir seçiciye sahip kurallar, daha az spesifik bir seçicinin önceliğini alır ve kural daha sonra stil sayfasında bir önceki kuralın üzerine yazar.
+
+Bu işleme geçiş denir ve olayısıyla Geçişli/Basamaklı Stil Sayfaları adı da buradan gelmiştir.
+
+Aşağıdaki CSS göz önüne alındığında:
+
+```css
+/* A */
+p.class1[attr='değer']
+
+/* B */
+p.class1 { }
+
+/* C */
+p.class2 { }
+
+/* D */
+p { }
+
+/* E */
+p { özellik: değer !important; }
+```
+
+ve aşağıdaki biçimlendirmeyi:
+
+```html
+<p style='/*F*/ özellik:değer;' class='class1 class2' attr='değer'>
+```
+
+Stilin önceliği ise aşağıdaki gibidir. Unutmayın, öncelik **her bir özellik için ayrı ayrı geçerlidir**, tüm blok için geçerli değildir.
+
+* `E` `!important` kelimesi yüzünden en yüksek önceliğe sahiptir. Kullanımından kaçınmanız önerilir.
+* `F` satıriçi stil olduğu için bir sonraki önceliğe sahiptir.
+* `A` bir sonraki önceliğe sahiptir. Çünkü her şeyden daha "özgüdür". 3 belirteci vardır: `p` ögesinin adı, sınıf` class1`, bir öznitelik `attr = 'değer'.
+* `C`, `B` ile aynı özdeşliğe sahip olsa da, bundan sonra geldiğinden dolayı öncelik hakkına sahiptir.
+* `B` bir sonraki önceliğe sahiptir.
+* Sonuncu önceliğe sahip olan`D`'dir.
+
+## Medya Sorguları
+
+CSS Medya Sorguları, CSS 3'te belirli CSS kurallarının ne zaman uygulanması gerektiğini (örneğin basılan zaman veya belirli boyutlar veya piksel yoğunluğu olan bir ekranda olduğunda) belirlemenize izin veren bir özelliktir. Medya Sorguları, seçicilere önceliğk eklemez.
+
+```css
+/* Tüm cihazlarda kullanılacak olan bir kural */
+h1 {
+  font-size: 2em;
+  color: white;
+  background-color: black;
+}
+
+/* h1 ögesini değiştirip bir yazıcıda  daha az mürekkep kullanın*/
+@media print {
+  h1 {
+    color: black;
+    background-color: white;
+  }
+}
+
+/* En az 480 piksel genişliğinde bir ekran gösterildiğinde font yüksekliğini daha büyük yap */
+@media screen and (min-width: 480px) {
+  h1 {
+    font-size: 3em;
+    font-weight: normal;
+  }
+}
+```
+
+Medya sorguları aşağıdaki bu özellikleri içerebilir:
+`width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. Bu özelliklerin birçoğunu `min-` veya `max-` öneki ile kullanabilirsiniz. 
+
+`resolution` özelliği eski cihazlarda desteklenmediğinden ötürü `device-pixel-ratio` kullanın.
+
+Eğer `viewport` meta etiketi sağlanmadıkça birçok akıllı telefon ve tabletler, sayfayı masaüstü bilgisayardaymış gibi göstermeye çalışacaktır.
+
+```html
+<head>
+  <meta name="viewport" content="width=device-width; initial-scale=1.0">
+</head>
+```
+
+## Uyumluluk
+
+CSS 2'deki çoğu özellik (ve CSS 3'deki birçoğu) bütün tarayıcılar ve cihazlar için bulunmaktadır. Ancak yeni bir özelliği kullanmadan önce kontrol etmek her zaman iyi bir uygulamadır.
+
+## Kaynaklar
+
+* [CanIUse](http://caniuse.com) (Detaylı uyumluluk bilgileri)
+* [Dabblet](http://dabblet.com/) (CSS oyun alanı)
+* [Mozilla Geliştirici Ağının CSS belgelendirmesi](https://developer.mozilla.org/en-US/docs/Web/CSS) (Eğitseller ve referanslar)
+* [Codrops' CSS Referansı](http://tympanus.net/codrops/css_reference/) (Referans)
+
+## Daha Fazla Okuma
+
+* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+* [Selecting elements using attributes](https://css-tricks.com/almanac/selectors/a/attribute/)
+* [QuirksMode CSS](http://www.quirksmode.org/css/)
+* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
+* [SASS](http://sass-lang.com/) and [LESS](http://lesscss.org/) for CSS pre-processing
+* [CSS-Tricks](https://css-tricks.com)
diff --git a/tr-tr/dynamic-programming-tr.html.markdown b/tr-tr/dynamic-programming-tr.html.markdown
new file mode 100644
index 00000000..e6a734a7
--- /dev/null
+++ b/tr-tr/dynamic-programming-tr.html.markdown
@@ -0,0 +1,55 @@
+---
+language: Dynamic Programming
+filename: dynamic-tr.txt
+contributors:
+    - ["Akashdeep Goel", "https://github.com/akashdeepgoel"]
+translators:
+    - ["Mehmet Cem Yaraş", "https://www.linkedin.com/in/yarascem/"]
+lang: tr-tr
+---
+
+# Dinamik Programlama
+
+## Giriş
+
+Dinamik Programlama, göreceğimiz gibi belirli bir problem sınıfını çözmek için kullanılan güçlü bir tekniktir. Fikir çok basittir, verilen girdiyle ilgili bir sorunu çözdüyseniz, aynı sorunun tekrar çözülmesini önlemek için sonucunu gelecekte referans olarak kaydedilmesine dayanır.
+
+Her zaman hatırla! "Geçmiş hatırlayamayanlar, aynı şeyleri tekrar yaşamaya mahkumlardır!"
+
+## Bu tür sorunların çözüm yolları
+
+1. Yukarıdan aşağıya:
+Verilen problemi çözerek çözmeye başlayın. Sorunun zaten çözüldüğünü görürseniz, kaydedilen cevabı döndürmeniz yeterlidir. Çözülmemişse, çözünüz ve cevabı saklayınız. Bu genellikle düşünmek kolaydır ve çok sezgiseldir. Buna Ezberleştirme denir.
+
+2. Aşağıdan yukarıya:
+Sorunu analiz edin ve alt problemlerin çözülme sırasını görün ve önemsiz alt sorundan verilen soruna doğru başlayın. Bu süreçte, problemi çözmeden önce alt problemlerin çözülmesi gerekmektedir. Buna Dinamik Programlama denir.
+
+## Örnek
+
+En Uzun Artan Subsequence problemi belirli bir dizinin en uzun artan alt dizini bulmaktır. `S = {a1, a2, a3, a4, ............., an-1}` dizisi göz önüne alındığında, en uzun bir alt kümeyi bulmak zorundayız, böylece tüm j ve i, `j<I` için , `aj<ai` alt kümesinde. Her şeyden önce, en son alt dizgenin (LSi) değerini dizinin son elemanı olan ai'nin her indeksinde bulmalıyız. Daha sonra en büyük LSi, verilen dizideki en uzun alt dizin olacaktır. Başlamak için, ai, dizinin elemanı olduğundan (Son öğe) LSi atanır. Sonra tüm j için `j<i` ve `aj<ai` gibi, En Büyük LSj'yi buluruz ve LSi'ye ekleriz. Sonra algoritma `O(n2)` zaman alır.
+
+En uzun artan alt dizinin uzunluğunu bulmak için sözde kod:
+Bu algoritmaların karmaşıklığı dizi yerine daha iyi veri yapısı kullanılarak azaltılabilir. Büyük dizin ve dizin gibi selefi dizi ve değişkeni saklama çok zaman kazandıracaktır.
+
+Yönlendirilmiş asiklik grafiğinde en uzun yolu bulmak için benzer bir kavram uygulanabilir.
+
+```python
+for i=0 to n-1
+    LS[i]=1
+    for j=0 to i-1
+        if (a[i] >  a[j] and LS[i]<LS[j])
+            LS[i] = LS[j]+1
+for i=0 to n-1
+    if (largest < LS[i])
+    
+```  
+
+### Bazı Ünlü Dinamik Programlama Problemleri
+
+- Floyd Warshall Algorithm - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
+- Integer Knapsack Problem - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
+- Longest Common Subsequence - Tutorial and C Program source code : [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
+
+## Online Kaynaklar
+
+- [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/tr-tr/edn-tr.html.markdown b/tr-tr/edn-tr.html.markdown
new file mode 100644
index 00000000..9a2ac1ff
--- /dev/null
+++ b/tr-tr/edn-tr.html.markdown
@@ -0,0 +1,157 @@
+---
+language: edn
+filename: learnedn-tr.edn
+lang: tr-tr
+contributors:
+  - ["Seçkin KÜKRER", "https://github.com/LeaveNhA"]
+---
+
+# Y = 20 Dakika.
+
+### Genişletilebilir Veri Notasyonu (EDN, Extensible Data Notation).
+
+### Okunuşu: (Türkçe: ey-di-en), (English: eed-n)
+
+### Kodlama Türü: UTF-8
+
+EDN Clojure sözdiziminin bir alt kümesidir. Bu alt küme, amacı gereği kod barındırmaz. Ve kendisi bir tip sistemi değildir. Bir şeması da yoktur. En basit tabirle; Genişletilebilir Veri Notasyonu kabul edilebilir elemanların bir kümesidir.
+
+EDN elementleri, akışları ve dosyaları UTF-8 kullanılarak kodlanmalıdır. Üstelik, dökümanı çevreleyen işaretçiler de olmadığı için akış, dağıtık programlama mesaj arayüzü ve diğer dinamik sistemler için idealdir.
+
+
+```clojure
+; Yorumlar, yorumlarımız, noktalı virgül ile başlıyor.
+;; Genellikle ikili olarak kullanılıyorlar.
+
+;; |--------------------------------|
+;  |--------- Genel Yapısı ---------|
+;; |--------------------------------|
+
+;; Boşluklar --whitespaces--, elementler için en yaygın ayıraçtır.
+"Mustafa" "Kemal" "ATATÜRK"
+;; Fakat okunuşu arttırdığı gerekçesiyle "," (virgüller --commas--) EDN yorumlayıcısı tarafından görmezden gelinir ve boşluk olarak nitelendirilir.
+"Mustafa","Kemal","PAŞA"
+;; Üstelik bu yenilikçi sözdizimsel kurala rağmen, {}, [] () gibi koleksiyon karakterlerini ayırmak için boşluğa ya da boşluğa çözümlenen virgüle ihtiyacınız yoktur.
+[["MUSTAFA"] ["KEMAL"] [[{"ATA" "ATATÜRK"}]]]
+;; Üst düzey vektör elemanlarını birbirinden ayıran boşlukları da kaldırabilirsiniz.
+;; Fakat bu size, okunması zor bir vektör dışında hiç bir şey vermeyecektir.
+
+;; |--------------------------------|
+;  |-------- Atomik Yapılar --------|
+;; |--------------------------------|
+
+; Mantıksal Değerler
+;; Mantıksal Doğru, çoğu teknolojide aynı gösterimi var.
+true
+;; Mantıksal Yanlış.
+false
+
+; Karakter Katarları
+;; Karakter katarları, --SADECE-- çift tırnak ile belirtilebilir.
+"İzmirin dağlarında çiçekler açar!"
+;; C, C++, Java v.b. gibi dillerin desteklediği kaçış sekanslarını da destekler.
+"Altın güneş orda sırmalar saçar.\nBozulmuş düşmanlar yel gibi kaçar."
+;; Kaçış sekansları için bknz: $!$
+
+; Karakter Sabitleri
+;; Karakter sabitleri önlerinde bir ters eğik çizgi ile temsil edilirler.
+\T \Ü \R \K
+;; Üstelik, belirli kaçıl sekanslarının da karşılığı Karakter Sabiti olarak var.
+\newline \return
+
+; Anahtar Kelimeler
+;; Anahtar Kelimeler, önlerinde bir ":" iki nokta --colon--
+:yımırta
+:kaşar
+:bıngıl
+
+; Semboller
+;; Semboller tanımlayıcıları temsil etmek için kullanılır.
+;; "/" karakteri, Sembol Sabitlerinde isim-uzayı ayıracı olarak kullanılıyor.
+izmir/kızları
+;; "mutfak" isim uzayındaki "ekmek-bıçağı" isimli sembole çözümlenir.
+
+banyo/fayans
+parke
+laminat
+
+; Sayısal Değerler
+;; Tam Sayı sabiti.
+1991
+;; Kayan Noktalı Sabiti.
+19.67
+
+; Listeler
+;; Listeler, yukarıdaki temel tiplerin ardışıklanmasıdır.
+(bomba :bomba nokta \c \o \m)
+
+; Vektörler
+;; Vektörler bir bakıma Listelere benzeseler de, bir çok açıdan farklıdırlar.
+;; Mesela Listenin aksine Vektörler, Rastgele Erişime imkan verir.
+[[] "şimdi" "asker"]
+
+; Eşlemeler
+;; Sıfır veya daha fazla Anahtar-Değer çifti kabul eder.
+;; Not: Clojure Veri Yapıları Soyutlaması ile Eşlemeler de, teknik olarak ardışık olarak işlenebilir.
+{:canı :neler-ister?
+ :uykuda "mevlam"}
+;; Bu ve diğer tüm Veri Yapıları Homojendir, birbirilerini barındırabilir, kapsayabilir, içerebilirler.
+;; Ayrıca okunurluk gibi farklı sebeplerle virgül kullanımında özgürsünüz.
+{{:id_ "129u391824981237981237" :kim "BEN"}, göster!}
+
+; Kümeler
+;; Kümeler eşsiz eleman barındıran bir yapıdır.
+;; Matematikteki karşılığını veriyor dersek yanlış olmaz.
+#{:sen 3 milyar 750 milyon}
+
+;; |--------------------------------|
+;  |------ Etiketli Elemanlar ------|
+;; |--------------------------------|
+
+;; EDN (Genişletilebilir Veri Notasyonu), # sembolü ile genişletilebilir.
+
+#benimuygulamam/bağlantı {:içerik "Y dakikada EDN Öğren" :url "https://learnxinyminutes.com/docs/tr-tr/edn-tr" :tıhlama-aksiyonu yırrttılll!}
+
+;; Ve bu yapıyı yorumlayacak bir de yapı gerekiyor.
+(defn ->bağlantı [props]
+  (str "<a href='" (:url props) "'" ">"
+        (:içerik props)
+        "</a>"))
+
+;; Bu örnekte yorumlayıcıya, basit bir fonksiyon veriyoruz.
+;; `clojure.edn/read-string` aslında bir ayarlar Eşlemesi kabul ediyor.
+;; (Bu tür fonksiyon genişlemeleri, Clojure ekosisteminde yaygındır.)
+
+(clojure.edn/read-string
+  {:readers {'benimuygulamam/bağlantı ->bağlantı}}
+  "#benimuygulamam/bağlantı {:içerik \"Y dakikada EDN Öğren\" :url \"https://learnxinyminutes.com/docs/tr-tr/edn-tr\" :tıhlama-aksiyonu yırrttılll!}")
+;=> "<a href='https://learnxinyminutes.com/docs/tr-tr/edn-tr'>Y dakikada EDN Öğren</a>"
+
+;; |--------------------------------|
+;  |--- Ön Tanımlı Genişletmeler ---|
+;; |--------------------------------|
+
+; Tarih Etiketi
+;; Bu etiket `inst` ön-ekinden sonra bir RFC-3339 formatında bir karakter katarı beklemektedir.
+#inst "2013-10-21T14:50:00+00:00" ; => Formatlanmış bir şekilde: 21/10/2013 14:50:00
+
+; UUID Etiketi
+;; Bu etiket `uuid` ön-ekinden sonra bir UUID karşılığını karakter katarı olarak kabul eder.
+#uuid "11k12fae-7d3c-11k0-a765-0010ckke6hgk"
+
+```
+
+# Son Ek
+Bu içerik, EDN'i tanıtmakta kısıtlı bir açıyla, özet bilgiler sunmaktadır.
+Fakat, Clojure ve diğer Veri Odaklı dillerde, Verinin yolculuğunu anlamak için önemli bir rol oynamaktadır.
+EDN'in var olan probleme çözümü ve artı/eksilerinin doğru şekilde kavranması mühimdir.
+Ben bu dökümanı hazırlarken, EDN ve gerçek dünya kullanımını anlatan yoktu. Fakat ümidim, Clojure ve diğer teknolojiler üzerinde kullanımının artmasından sonra birinin bu ihtiyacı giderecek özgün kaynak çıkarmasıdır.
+
+Başarılar!
+
+# Referanslar
+
+- [EDN Formatı Standardı](https://github.com/edn-format/edn)
+- [Gerçeklemeler](https://github.com/edn-format/edn/wiki/Implementations)
+- [Etiketlenmiş Elementler](http://www.compoundtheory.com/clojure-edn-walkthrough/)
+- [Clojure.Docs EDN İçeriği](https://clojuredocs.org/clojure.edn)
diff --git a/tr-tr/git-tr.html.markdown b/tr-tr/git-tr.html.markdown
new file mode 100644
index 00000000..87c1820c
--- /dev/null
+++ b/tr-tr/git-tr.html.markdown
@@ -0,0 +1,596 @@
+---
+category: tool
+lang: tr-tr
+tool: git
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Leo Rudberg" , "http://github.com/LOZORD"]
+    - ["Betsy Lorton" , "http://github.com/schbetsy"]
+    - ["Bruno Volcov", "http://github.com/volcov"]
+    - ["Andrew Taylor", "http://github.com/andrewjt71"]
+    - ["Jason Stathopulos", "http://github.com/SpiritBreaker226"]
+    - ["Milo Gilad", "http://github.com/Myl0g"]
+    - ["Adem Budak", "https://github.com/p1v0t"]
+    
+filename: LearnGit-tr.txt
+---
+
+Git dağınık versiyon kontrol ve kaynak kod yönetim sistemidir.
+
+Bunu projenin bir seri anlık durumunu kaydederek yapar ve bu anlık durumları 
+kullanarak versiyon ve kaynak kodu yönetmeni sağlar.
+
+## Versiyonlama Konseptleri
+
+### Versiyon kontrol nedir?
+
+Versiyon kontrol, zaman içerisinde dosya(lar)daki değişikliği kaydeden sistemdir.
+
+### Merkezi Versiyonlama vs. Dağınık Versiyonlama
+
+* Merkezi versiyon kontrolü dosyaların eşitlenmesine, takibine ve yedeklenmesine odaklanır. 
+* Dağınık versiyon kontrolü değişimin paylaşılmasına odaklanır. Her değişiminin benzersiz bir adı vardır.
+* Dağınık sistemlerin belirlenmiş bir yapısı yoktur. Git ile kolayca SVN'deki gibi merkezi bir sistem elde edebilirsin. 
+
+[Daha fazla bilgi](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
+
+### Neden Git?
+
+* Çevrimdışı çalışabilir
+* Diğerleriyle beraber çalışmak kolaydır!
+* Dallanma kolaydır!
+* Dallanma hızlıdır!
+* Git hızlıdır
+* Git esnektir
+
+## Git Mimarisi
+
+### Repository
+
+Bir grup dosya, dizin, geriye dönük kayıt, commit, head. Bunları kaynak kodun veri
+yapısı gibi düşünebilirsin, herbir kaynak kod "elemanı" seni kendi revizyon geçmişine 
+eriştirir. 
+
+Bir git repo'su .git dizini ve çalışma ağacından oluşur. 
+
+### .git Dizini (repository bileşeni)
+
+.git dizini bütün konfigrasyon, log, dallanma, HEAD ve daha fazlasını tutar.
+[detaylı liste](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Çalışma Ağacı (repository bileşeni)
+
+Temelde repo'daki dizinlerin ve dosyalarındır. Sıkça çalışma ağacın olarak anılır.
+
+### Index (.git dizininin birleşeni)
+
+Index git'in evreleme alanıdır (staging area). Temelde çalışma ağacını Git repo'sundan 
+ayıran bir katmandır. Bu geliştiricilere neyin Git repo'suna gönderileceği hakkında daha 
+fazla güç verir. 
+
+### Commit
+
+Bir git commit'i Çalışma Ağacındaki bir takım değişiklerdir. Mesela 5 tane dosya
+eklemişsindir ve diğer 2 tanesini silmişindir, bu değişikler commit'te (anlık kayıtta) 
+tutulacaktır. Bu commit daha sonra diğer repo'lara bastırılabilir (pushed) ve bastırılmaz!
+
+### Branch
+
+Bir branch esasen yaptığın son commit'e göstericidir(pointer). Commit'lemeye devam ettiğinde,
+bu gösterici otomatik olarak son commit'e güncellenir.
+
+### Tag
+
+Bir tag, tarihteki belirli bir noktanın işaretidir. İnsanlar bunu genelde 
+sürüm notları için kullanır (v1.0 vs.)
+
+### HEAD ve head (.git dizininin birleşenleri)
+
+HEAD mevcut branch'a bir göstericidir. Bir repository yalnızca 1 *aktif*
+HEAD'e sahiptir.
+head, commit'e bir göstericidir. Bir repository herhangi bir sayıda head'e sahip olabilir.
+
+### Git'in Stage'leri
+* Modified - Dosyada değişikler yapıldı ama henüz Git Veritabanına commit yapılmadı.
+* Staged - Modified edilmiş bir dosyayı, sonraki commit'e gitmek üzere işaretler.
+* Committed - Dosyalar Git Veritabanına commit'lendi.  
+
+### Kavramsal Kaynaklar 
+
+* [Bilgisayar Bilimciler için Git](http://eagain.net/articles/git-for-computer-scientists/)
+* [Tasarımcılar için Git](http://hoth.entp.com/output/git_for_designers.html)
+
+## Komutlar
+
+### init
+
+Boş bir Git repository'si oluştur. Git repository'sinin ayarları, depolanmış
+bilgileri ve daha fazlası ".git" adlı dizinde (bir klasör) tutulur.
+
+```bash
+$ git init
+```
+
+### config
+
+Ayarları yapılandırmak için. Repository, sistemin kendisi veya global yapılandırmalar
+için olarabilir. (global yapılandırma dosyası `~/.gitconfig`).
+
+```bash
+# Print & Set Some Basic Config Variables (Global)
+$ git config --global user.email "MyEmail@Zoho.com"
+$ git config --global user.name "My Name"
+```
+
+[git config hakkında daha fazla bilgi için.](http://git-scm.com/docs/git-config)
+
+### help
+
+Her bir komutun detaylı kılavuzuna hızlı bir erişim için. Ya da sadece bazı şeylerin
+anlamı için hızlı bir hatırlatıcı için.
+
+```bash
+# Quickly check available commands
+$ git help
+
+# Check all available commands
+$ git help -a
+
+# Command specific help - user manual
+# git help <command_here>
+$ git help add
+$ git help commit
+$ git help init
+# or git <command_here> --help
+$ git add --help
+$ git commit --help
+$ git init --help
+```
+
+### dosyaları ignore etme 
+
+git'in bazı dosya(ları) ve klasör(leri) kasıtlı olarak takip etmemesi için. Genel
+olarak,repository'de ne de olsa paylaşılacak, private ve temp dosyaları için.
+
+```bash
+$ echo "temp/" >> .gitignore
+$ echo "private_key" >> .gitignore
+```
+
+### status
+
+index dosyası(temelde çalıştığın repo) ve mevcut HEAD commit arasındaki farkı göstermek için.
+
+```bash
+# Will display the branch, untracked files, changes and other differences
+$ git status
+
+# To learn other "tid bits" about git status
+$ git help status
+```
+
+### add
+
+Dosyaları staging area'ya eklemek için. Eğer yeni dosyaları staging area'ya `git add` 
+yapmazsanız, commit'lere eklenmez!
+
+```bash
+# add a file in your current working directory
+$ git add HelloWorld.java
+
+# add a file in a nested dir
+$ git add /path/to/file/HelloWorld.c
+
+# Regular Expression support!
+$ git add ./*.java
+
+# You can also add everything in your working directory to the staging area.
+$ git add -A
+```
+Bu yalnızca dosyayı staging area'a/index'e ekler, çalışılan dizine/repo'ya commit etmez.
+
+### branch
+
+Branch'ları yönetir. Bu komutu kullanarak, branch'ları görebilir, düzenleyebilir, oluşturabilir, silebilirsin.
+
+```bash
+# list existing branches & remotes
+$ git branch -a
+
+# create a new branch
+$ git branch myNewBranch
+
+# delete a branch
+$ git branch -d myBranch
+
+# rename a branch
+# git branch -m <oldname> <newname>
+$ git branch -m myBranchName myNewBranchName
+
+# edit a branch's description
+$ git branch myBranchName --edit-description
+```
+
+### tag
+
+tag'leri yönetir
+
+```bash
+# List tags
+$ git tag
+
+# Create a annotated tag
+# The -m specifies a tagging message, which is stored with the tag.
+# If you don’t specify a message for an annotated tag,
+# Git launches your editor so you can type it in.
+$ git tag -a v2.0 -m 'my version 2.0'
+
+# Show info about tag
+# That shows the tagger information, the date the commit was tagged,
+# and the annotation message before showing the commit information.
+$ git show v2.0
+
+# Push a single tag to remote
+$ git push origin v2.0
+
+# Push a lot of tags to remote
+$ git push origin --tags
+```
+
+### checkout
+
+index'in versiyonun eşlemek için çalışma ağacındaki,veya belirtilen ağactaki, tüm dosyaları günceller.
+
+```bash
+# Checkout a repo - defaults to master branch
+$ git checkout
+
+# Checkout a specified branch
+$ git checkout branchName
+
+# Create a new branch & switch to it
+# equivalent to "git branch <name>; git checkout <name>"
+
+$ git checkout -b newBranch
+```
+
+### clone
+
+Varolan bir repository'i yeni bir dizine clone'lar veya kopyalar. 
+Ayrıca clone'lanmış repodaki her bir branch için, uzak branch'a bastırmana izin veren,
+uzak takip branch'ları ekler.
+
+```bash
+# Clone learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+
+# shallow clone - faster cloning that pulls only latest snapshot
+$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
+
+# clone only a specific branch
+$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
+```
+
+### commit
+
+index'in mevcut içeriğini yeni bir "commit"te saklar. Bu commit, kullanıcının oluşturduğu
+bir mesajı ve yapılan değişiklikleri saklar. 
+
+```bash
+# commit with a message
+$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
+
+# signed commit with a message (user.signingkey must have been set
+# with your GPG key e.g. git config --global user.signingkey 5173AAD5)
+$ git commit -S -m "signed commit message"
+
+# automatically stage modified or deleted files, except new files, and then commit
+$ git commit -a -m "Modified foo.php and removed bar.php"
+
+# change last commit (this deletes previous commit with a fresh commit)
+$ git commit --amend -m "Correct message"
+```
+
+### diff
+
+Shows differences between a file in the working directory, index and commits.
+Bir dosyanın, çalışma ağacı, index ve commit'ler arasındaki farklarını göster.
+
+```bash
+# Show difference between your working dir and the index
+$ git diff
+
+# Show differences between the index and the most recent commit.
+$ git diff --cached
+
+# Show differences between your working dir and the most recent commit
+$ git diff HEAD
+```
+
+### grep
+
+Bir repository'de hızlıca arama yapmana izin verir.
+
+İsteğe Bağlı Yapılandırmalar:
+
+```bash
+# Thanks to Travis Jeffery for these
+# Set line numbers to be shown in grep search results
+$ git config --global grep.lineNumber true
+
+# Make search results more readable, including grouping
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Search for "variableName" in all java files
+$ git grep 'variableName' -- '*.java'
+
+# Search for a line that contains "arrayListName" and, "add" or "remove"
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+```
+
+Daha fazla örnek için
+[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Repository'deki commitleri gösterir.
+
+```bash
+# Show all commits
+$ git log
+
+# Show only commit message & ref
+$ git log --oneline
+
+# Show merge commits only
+$ git log --merges
+
+# Show all commits represented by an ASCII graph
+$ git log --graph
+```
+
+### merge
+
+Dış commit'lerdeki değişiklikleri mevcut branch'a "merge" et (birleştir).
+
+```bash
+# Merge the specified branch into the current.
+$ git merge branchName
+
+# Always generate a merge commit when merging
+$ git merge --no-ff branchName
+```
+
+### mv
+
+Bir dosyayı yeniden taşı veya yeniden adlandır
+
+```bash
+# Renaming a file
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Moving a file
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Force rename or move
+# "existingFile" already exists in the directory, will be overwritten
+$ git mv -f myFile existingFile
+```
+
+### pull
+
+Bir repository'den çeker ve diğer branch'a merge eder.
+
+```bash
+# Update your local repo, by merging in new changes
+# from the remote "origin" and "master" branch.
+# git pull <remote> <branch>
+$ git pull origin master
+
+# By default, git pull will update your current branch
+# by merging in new changes from its remote-tracking branch 
+$ git pull
+
+# Merge in changes from remote branch and rebase
+# branch commits onto your local repo, like: "git fetch <remote> <branch>, git 
+# rebase <remote>/<branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+Bir branch'taki değişikleri, uzak branch'a bastır ve birleştir.
+
+```bash
+# Push and merge changes from a local repo to a
+# remote named "origin" and "master" branch.
+# git push <remote> <branch>
+$ git push origin master
+
+# By default, git push will push and merge changes from
+# the current branch to its remote-tracking branch 
+$ git push
+
+# To link up current local branch with a remote branch, add -u flag:
+$ git push -u origin master
+# Now, anytime you want to push from that same local branch, use shortcut:
+$ git push
+```
+
+### stash
+
+Stash'leme çalışma dizinindeki kirli durumu alır ve bitmemiş değişiklikler 
+yığınına kaydeder. Bu değişikleri istediğin zaman tekrar uygulayabilirsin.
+
+Mesela git repo'nda bazı işler yaptın ama remote'dan pull yapmak istiyorsun.
+Bazı dosyalarında kirli (commit'lenmemiş) değişiklikler olduğundan `git pull`
+yapamazsın. Onun yerine önce `git stash` ile değişikliklerini yığına kaydet!
+
+(stash, sözlük anlamı: bir şeyi, özel bir yere güvenli biçimde saklamak)
+
+```bash
+$ git stash
+Saved working directory and index state \
+  "WIP on master: 049d078 added the index file"
+  HEAD is now at 049d078 added the index file
+  (To restore them type "git stash apply")
+```
+
+Şimdi pull yapabilirsin!
+
+```bash
+git pull
+```
+`...changes apply...`
+
+Herşeyin tamam olduğunu kontrol et
+
+```bash
+$ git status
+# On branch master
+nothing to commit, working directory clean
+```
+Şu ana kadar neleri stash'lediğini `git stash list` kullanarak görebilirsin.
+Stash'lenen şeyler Son-Giren-İlk-Çıkar şeklinde tutulduğundan en son değişim
+en üste olacaktır.
+
+```bash
+$ git stash list
+stash@{0}: WIP on master: 049d078 added the index file
+stash@{1}: WIP on master: c264051 Revert "added file_size"
+stash@{2}: WIP on master: 21d80a5 added number to log
+```
+Şimdi de kirli değişiklileri yığından çıkarıp uygulayalım.
+
+```bash
+$ git stash pop
+# On branch master
+# Changes not staged for commit:
+#   (use "git add <file>..." to update what will be committed)
+#
+#      modified:   index.html
+#      modified:   lib/simplegit.rb
+#
+```
+
+`git stash apply` da aynı şeyi yapar
+
+Şimdi kendi işine dönmeye hazırsın!
+
+[Ek Okuma.](http://git-scm.com/book/en/v1/Git-Tools-Stashing)
+
+### rebase (dikkat)
+
+Branch'ta commit'lenen tüm değişimleri al ve onları başka bir branch'ta tekrar oynat
+*Public repo'ya push edilmiş commit'leri rebase etme*
+
+```bash
+# Rebase experimentBranch onto master
+# git rebase <basebranch> <topicbranch>
+$ git rebase master experimentBranch
+```
+
+[Ek Okuma.](http://git-scm.com/book/en/Git-Branching-Rebasing)
+
+### reset (dikkat)
+
+Reset the current HEAD to the specified state. This allows you to undo merges,
+pulls, commits, adds, and more. It's a great command but also dangerous if you 
+don't know what you are doing.
+
+HEAD'i belirtilen duruma resetle. Bu merge'leri, pull'ları, commit'leri, add'leri
+ve daha fazlasını geriye almanı sağlar. Muhteşem bir komuttur ama aynı zamanda, ne
+yaptığını bilmiyorsan, tehlikelidir.
+
+```bash
+# Reset the staging area, to match the latest commit (leaves dir unchanged)
+$ git reset
+
+# Reset the staging area, to match the latest commit, and overwrite working dir
+$ git reset --hard
+
+# Moves the current branch tip to the specified commit (leaves dir unchanged)
+# all changes still exist in the directory.
+$ git reset 31f2bb1
+
+# Moves the current branch tip backward to the specified commit
+# and makes the working dir match (deletes uncommitted changes and all commits
+# after the specified commit).
+$ git reset --hard 31f2bb1
+```
+
+### reflog (dikkat)
+
+Reflog, verilen zaman içinde,default olarak 90 gündür, yaptığın git komutlarını listeler.
+
+Bu sana beklemediğin şekilde yanlış giden komutları geriye çevirme şansı verir. 
+(mesela, eğer bir rebase uygulamanı kırdıysa)
+
+Şu şekilde yapıbilirsin:
+
+1. `git reflog` rebase için tüm git komutlarını listele
+
+```
+38b323f HEAD@{0}: rebase -i (finish): returning to refs/heads/feature/add_git_reflog
+38b323f HEAD@{1}: rebase -i (pick): Clarify inc/dec operators
+4fff859 HEAD@{2}: rebase -i (pick): Update java.html.markdown
+34ed963 HEAD@{3}: rebase -i (pick): [yaml/en] Add more resources (#1666)
+ed8ddf2 HEAD@{4}: rebase -i (pick): pythonstatcomp spanish translation (#1748)
+2e6c386 HEAD@{5}: rebase -i (start): checkout 02fb96d
+```
+2. Nereye reset'leyeceğini seç, şu durumda `2e6c386` veya `HEAD@{5}`
+3. 'git reset --hard HEAD@{5}' bu repo'nu seçilen head'e eşitler 
+4. Rebase'e yeniden başlayabilir veya onu yalnız bırakabilirsin.
+
+[Ek Okuma.](https://git-scm.com/docs/git-reflog)
+
+### revert
+
+Revert commit'leri geri almada kullanılır. Projenin durumunu önceki bir noktaya 
+alan reset ile karıştırılmamalıdır. Revert, belirtilen commit'in tersine yeni bir
+commit ekleyecektir.
+
+```bash
+# Revert a specified commit
+$ git revert <commit>
+```
+
+### rm
+
+git add'in tersine, git rm çalışma ağacından dosyaları kaldırır.
+
+```bash
+# remove HelloWorld.c
+$ git rm HelloWorld.c
+
+# Remove a file from a nested dir
+$ git rm /pather/to/the/file/HelloWorld.c
+```
+
+## Daha Fazla Bilgi
+
+* [tryGit - Git'i öğrenmek için eğlenceli interaktif bir yol](http://try.github.io/levels/1/challenges/1)
+
+* [Git Dallanmayı Öğren -  Git'i web üzerinde öğrenmek için en görsel ve interaktif yol](http://learngitbranching.js.org/)
+
+* [Udemy Git Tutorial: Kapsayıcı bir kılavuz](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/)
+
+* [Git Immersion - Git'in temelinden başlayan bir tur](http://gitimmersion.com/)
+
+* [git-scm - Video Tutorial](http://git-scm.com/videos)
+
+* [git-scm - Dökümantasyon](http://git-scm.com/docs)
+
+* [Atlassian Git - Tutorial & Workflow](https://www.atlassian.com/git/)
+
+* [SalesForce Kopya Kağıdı](http://res.cloudinary.com/hy4kyit2a/image/upload/SF_git_cheatsheet.pdf)
+
+* [GitGuys](http://www.gitguys.com/)
+
+* [Git - Basit bir kılavuz](http://rogerdudler.github.io/git-guide/index.html)
+
+* [Pro Git](http://www.git-scm.com/book/en/v2)
+
+* [Yeni başlayanlar için Git ve Github](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
diff --git a/tr-tr/html-tr.html.markdown b/tr-tr/html-tr.html.markdown
new file mode 100644
index 00000000..b4afe7df
--- /dev/null
+++ b/tr-tr/html-tr.html.markdown
@@ -0,0 +1,157 @@
+---
+language: html
+filename: learnhtml-tr.txt
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Kemal MUTLU", "https://github.com/kemtake"]
+    - ["Nuri Akman", "https://github.com/vedia"]
+lang: tr-tr
+---
+
+HTML, HyperText Markup Language (Hiper Metin İşaretleme Dili) anlamına gelir.
+
+Web sayfaları yazmamızı sağlayan bir dildir. Bu işaretleme dili, metin ve verilerin nasıl gösterilmesi gerektiği kodlanarak web sayfaları yazmamızı sağlar. Aslında, html dosyaları basit metin dosyalarıdır.
+
+Bu işaretleme nedir? Sayfanın verilerini, açılış etiketleri ve kapanış etiketleri ile çevreleyerek düzenleme yöntemidir. Bu işaretleme, içerdiği metne anlam vermeyi sağlar. Diğer bilgisayar dillerinde olduğu gibi, HTML’nin birçok sürümü vardır. Burada HTML5 hakkında konuşacağız. 
+
+**NOT :** Etkilerin nasıl çalıştıklarını anlamak, çıktılarını görebilmek için [codepen](https://codepen.io/) gibi bir siteden de faydalanabilirsiniz. Bu makale temel olarak HTML sözdizimi ve bazı yararlı ipuçlarıyla ilgilidir.
+
+```html
+<!-- Yorumlar bu satır gibi eklenir! -->
+
+<!--
+	Yorumlar
+    birden
+	fazla
+	satıra
+	yayılabilir!
+-->
+
+<!-- #################### Başlık #################### -->
+
+<!-- İşte, analiz edeceğimiz örnek bir HTML dosyası. -->
+
+
+<!doctype html>
+	<html>
+		<head>
+			<title>Benim Sitem</title>
+		</head>
+		<body>
+			<h1>Merhaba dünya!</h1>
+			<a href="http://codepen.io/anon/pen/xwjLbZ">
+				Bunun ne olduğuna bir bak.
+			</a>
+			<p>Bu bir paragraftır.</p>
+			<p>Bu başka bir paragraf.</p>
+			<ul>
+				<li>Bu, numaralandırılmamış bir listede bulunan bir öğe/maddedir (madde imi)</li>
+				<li>Bu başka bir öğe</li>
+				<li>Ve bu listedeki son öğe </li>
+			</ul>
+		</body>
+	</html>
+
+<!--
+Bir HTML dosyası, tarayıcıya her zaman sayfanın HTML olduğunu belirterek başlar.
+-->
+<!doctype html>
+
+<!-- Bundan sonra, bir <html> etiketi açılarak başlar. -->
+<html>
+
+<!-- dosyanın sonu </html> etiketi ile kapatılır.  -->
+</html>
+
+<!-- Sayfada, bu son etiketten sonra hiçbir şey bulunmamalıdır. -->
+
+<!-- Açılış ve kapanış etiketleri arasında (<html> </html>) şunları bulunur: -->
+
+<!-- <head> ile tanımlanan bir sayfa başlığu (bu, </head> ile kapatılmalıdır). -->
+<!-- Baslik, gösterilmeyen bazi aciklamalar ve ek bilgiler icerir; buna üstveri denir. -->
+
+<head>
+	<!-- <title> etiketi, tarayıcıda gösterilecek başlığı gösterir. Pencerenin başlık çubuğu ve sekme adı.-->
+	<title>Benim Sitem</title>
+</head>
+
+<!-- <head> bölümünden sonra, <body> etiketi gelir. -->
+<!-- Bu noktaya kadar, tarif edilen hiçbir şey tarayıcı penceresinde görünmez. -->
+<!-- <body> etiketinden sonra  görüntülenecek içeriğe yer verilir. -->
+
+<body>
+	<!-- h1 etiketi bir başlık oluşturur. -->
+	<h1>Merhaba Dünya!</h1>
+	<!--
+		Ayrıca başlıklar <h1> etiketinden  <h6> etiketine kadar gidebilir.
+		<h1> etiketi en önemli, <h6> etiketi en düşük öncelikli başlığı yazmamızı sağlar.
+	-->
+
+	<!-- href="" özniteliğine verilen URL'ye bir köprü oluşturur.  -->
+	<a href="http://codepen.io/anon/pen/xwjLbZ">
+		Bunun ne olduğuna bir bak.
+	</a>
+
+	<!--  <p> etiketi, html sayfasına metin eklememize izin verir. -->
+	<p>Bu bir paragraftır.</p>
+	<p>Bu başka bir paragraf.</p>
+
+	<!-- <ul> etiketi bir madde imi listesi oluşturur. -->
+	<!--
+          Numaralandırılmış bir listeye sahip olmak için <ol> etiketi de kullanılabilir. Bu durumda 1. madde 2. madde vb. şekilde gider.
+	-->
+	<ul>
+		<li>Bu, numaralandırılmamış bir bir liste kalemidir (madde imi)</li>
+		<li>Bu başka bir öğe</li>
+		<li>Ve bu listedeki son öğe</li>
+	</ul>
+</body>
+
+<!-- İşte bir html dosyası oluşturmak bu kadar basit. -->
+
+<!-- Ancak birçok farklı HTML etiketi türü de eklenebilir. -->
+
+<!-- <img /> etiketi bir resim eklemek için kullanılır. -->
+<!--
+Resmin kaynağı, src = "" özniteliği kullanılarak belirtilir.
+Kaynak, bir URL veya bilgisayarınızdaki bir dosyanın yolu olabilir.
+-->
+<img src="http://i.imgur.com/XWG0O.gif"/>
+
+<!-- HTML'de bir Tablo oluşturmak da mümkündür. -->
+
+<!--  Bir <table> elemanı açarız. -->
+<table>
+
+	<!-- <tr> bir satır oluşturmamızı sağlar. -->
+	<tr>
+		<!-- <th> tablo sütununa bir başlık vermemize izin verir. -->
+		<th>Birinci Başlık</th>
+		<th>İkinci Başlık</th>
+	</tr>
+
+	<tr>
+		<!-- <td> bir tablo hücresi oluşturmamızı sağlar. -->
+		<td>ilk satırın, ilk hücresi (sutunu)</td>
+		<td>ilk satırın, ikinci hücresi (sutunu)</td>
+	</tr>
+
+	<tr>
+		<td>ikinci satırın, ilk hücresi (sutunu) </td>
+		<td>ikinci satırın, ikinci hücresi (sutunu)</td>
+	</tr>
+</table>
+
+```
+
+## Kullanım
+
+HTML içeriği, .html veya .htm ile biten dosyalara yazılır. Mim türü text/html .
+HTML olarak yazılmış dosyalar,  `.html` veya `.htm` dosya uzantısına sahiptirler. mime type'ı ise `text/html` dir.
+
+## Daha fazla bilgi için
+
+* [wikipedia](https://en.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
diff --git a/tr-tr/jquery-tr.html.markdown b/tr-tr/jquery-tr.html.markdown
new file mode 100644
index 00000000..4a4ebeae
--- /dev/null
+++ b/tr-tr/jquery-tr.html.markdown
@@ -0,0 +1,338 @@
+---
+category: tool
+tool: jquery
+contributors:
+    - ["Seçkin KÜKRER", "https://github.com/leavenha"]
+filename: jquery-tr-tr.js
+lang: tr-tr
+---
+
+# Tanım
+
+jQuery, (IPA: ˈd͡ʒeɪˌkwɪəɹiː).
+j + Query, olarak isimlendirilmiş, çünkü çoğunlukla HTML elementlerini sorgulamak ve onları manipüle etmek için kullanılır.
+
+jQuery, 2006 yılında geliştirilmiş ve günümüzde halen kullanımı yaygın, görece en popüler çapraz-platform JavaScript kütüphanelerinden birisidir. Şimdilerde jQuery ekibi tarafından gelişimi devam etmektedir. Dünyanın bir çok yerinden büyük şirketler ve bağımsız yazılım ekipleri tarafından kullanılmaktadır.
+
+Genel kullanım amacı animasyonlardır; Galeri, ek menü, sayfa geçişleri, ve diğer tüm gerçeklemelere sağladığı kolaylıkla birlikte Flash'ın alternatifi olarak yorumlanabilir. [Ajax][ajax-wikipedia-page] işlemleri de dahil olmak üzere olay-yönetimi, döküman manipülasyonu ve bir çok programlama görevini kolaylaştırır.
+
+Resmi sitesinden ([jQuery][jquery-official-website]) indirip web sitenize yükleyebilirsiniz. jQuery günümüz JavaScript kütüphaneleri gibi, küçültülmüş boyutlarda bulut tabanlı İçerik Dağıtım Ağı sistemleri sayesinde bağımsız olarak da sitenize eklenebilir.
+
+Kütüphanenin kullanımı ile, jQueryUI gibi ek paketlerle gelişmiş ve modern arayüzler gerçekleyebilirsiniz.
+
+Fakat, jQuery'ye giriş yapmadan önce elbetteki bu kütüphanenin üzerine kurulduğu teknoloji olan [JavaScript'i öğrenmelisiniz][javascript-learnxinyminutes-page].
+
+```js
+
+// Bu belgedeki değişken isimleri Türkçe,
+// ve [Lower Camel Case] notasyonu uygulamaktadır.
+// Bu belgedeki kod parçalarının çıktıları,
+// onları uyguladığınız dökümanın içeriğine bağlı olarak değişmektedir.
+
+// Döküman boyunca, aşağıdaki gösterimde
+// Kod - Çıktı ikilisi ile içeriğin anlamlandırılması
+// kolaylaştırılmaya çalışmıştır.
+// ornek_kod_parcasi();
+// => "ÖRNEK ÇIKTI"
+
+// *. Konsept
+// jQuery DOM nesnelerini seçmek için inovatif bir yol sunar.
+// `$` değişkeni, `jQuery` kütüphanesine işaret eder.
+// Fonksiyon notasyonu ile DOM nesnelerini elde eder
+// ve üzerinde işlemler gerçekleştirirsiniz.
+$(window)
+// => jQuery [Window] (1)
+// Bize tarayıcının belirlediği window nesnesini verir.
+
+// 1. Seçiciler
+// Tüm nesneleri seçmek için `*` çağırımı yapılır.
+const hepsi = $('*');
+// => jQuery [<html>, <head>, <meta>,
+// .... <meta>, <title>, <meta>, <meta>,
+// .... <meta>, <link>, <link>, …] (1134) = $1
+
+// Seçiciler, jQuery'de bir nesne seçmek için kullanılırlar,
+const sayfa = $(window);
+// => jQuery [window] (1)
+// Sayfa, açık döküman nesnesini seçer.
+
+// Elementler, kendileri için seçicidirler.
+const tumParagraflar = $('p');
+// => jQuery [<p>, <p>, <p>] (3)
+
+// Seçiciler aynı zamanda CSS seçicileri olabilir.
+const mavi = $('.mavi');
+// => jQuery [<p class='mavi'] (1)
+
+// Aynı zamanda element ile birlikte kullanılabilirler.
+const maviParagraf = $('p.mavi');
+// => jQuery [<p class='mavi'>] (1)
+
+// Özellik seçicileri de mevcuttur,
+// Elementin özelliği için seçim yaparlar.
+const isimSecicisi = $('input[name*="kayit.form"]');
+// => jQuery [<input name='kayit.form.sifre'>,
+//            <input name='kayit.form.dogumtarihi'> ...] (10)
+
+// Diğer özellik seçiciler;
+/*
+- Özelliğin içinde arayan; *=
+- Özelliğin içinde verilen kelimeleri arayan; ~=
+  |-(kelimeler boşlukla ayrılmalı, *='den farkına dikkat ediniz.)
+- Özelliğin başlangıç verisini arayan; ^=
+- Özelliğin bitiş verisini arayan; $=
+- Özelliği tamamen karşılaştıran; =
+- Özelliğin eşitsizlik durumunu karşılaştıran; !=
+
+Diğer tüm seçiciler için resmi siteyi kontrol ediniz.
+*/
+
+// 2. Olaylar ve Efektler
+// - Olaylar 
+// jQuery kullanıcı ile tarayıcı arasındaki etkileşimi olaylar ile ele alır.
+
+// En yaygın kullanımı tartışmasız ki Dökümanın Yüklenmesi olayıdır.
+
+// $.ready fonksiyonu, argüman olarak aldığı fonksiyonu,
+// seçilen eleman tamamen yüklendiğinde çağıracaktır.
+$(document).ready(function(){
+  // Dökümanın tamamı yüklendiğine göre, iş mantığımı çağırabiliriz.
+  console.info('Döküman yüklendi!');
+})
+// => jQuery [#document] (1)
+
+// Bir dökümanın tamamının yüklenmeden,
+// herhangi bir iş mantığı çalıştırmanın
+// neden kötü bir fikir olduğunu merak ediyorsanız,
+// ileri okuma kısmına danışabilirsiniz.
+
+// Önce Olay tanımlayalım.
+
+// Tıklama olayı için `$.click` olay tetikleyicisi kullanılıyor.
+$('.mavi').click(function(){
+  // Unutmayın ki, önceden tanımlanmış
+  // bir fonksiyonu da argüman olarak verebilirsiniz.
+  console.info('Mavi butona tıkladın!');
+})
+// => jQuery [<button>, <button>, <button>, <button>, <button>, …] (365)
+
+// Çift Tıklama olayı için `$.dblclick` olay tetikleyicisi kullanılıyor.
+$('.mavi').dblclick(function(){
+  console.info('Mavi butona çift tıkladın!');
+})
+// => jQuery [<button>, <button>, <button>, <button>, <button>, …] (365)
+
+// Seçilen Elemente birden fazla tetiklenecek fonksiyon tanımalamak
+// istersek, Olayları ve Fonksiyonları Anahtar-Değer yapısı sağlayan
+// Objeleri kullanarak da çağırabiliriz.
+
+// => tetiklenecekFonksiyon
+$('.mor').on({
+  click: () => console.info('Tek tıklama ile tetiklendim!'),
+  dblclick: () => console.info('Çift tıklama ile tetiklendim!'),
+  // ...
+});
+// => jQuery [<button>, <button>, <button>, <button>, <button>, …] (365)
+
+// Diğer olay tetikleyicileri;
+/*
+Elemente,
+- Fokus/Odaklanma; $.focus
+- Fokus/Odaklanmanın kaybedilmesi; $.blur
+- Farenin alanına girmesi; $.mouseenter
+- Farenin alanından çıkması; $.mouseleave
+
+Diğer tüm olay tetikleyicileri için resmi siteyi kontrol ediniz.
+*/
+
+// Tanımlanan olayları tetiklemek için,
+// Kullanıcı-Tarayıcı etkileşimi yerine elle çağrı yapmak da mümkün.
+// Tanımlama ile çağırım arasındaki fark sadece sağlanan argümanlardır.
+// Argümansız çağırım, olayı tetikler.
+
+// Tıklama olayını tetiklemek için.
+$('.mavi').click();
+// => Mavi butona tıkladın!
+// => jQuery [<button>] (1) 
+
+// Çift Tıklama olayını tetiklemek için.
+$('.mavi').dblclick();
+// => Mavi butona çift tıkladın!
+// => jQuery [<button>] (1) 
+
+// - Efektler
+// jQuery bir çok ön-tanımlı efekt sunmakta.
+// Bu efektler, belirli parametlerle, farklı iş mantıklarını
+// gerçeklemenize izin verebilir.
+// Önce parametresiz işlevlere göz atalım.
+
+// Elementleri saklayabilir,
+$('#slaytresmi').hide();
+// => jQuery [<img id='slaytresmi'>] (1)
+
+// Gizlenen elementleri tekrar görünür yapabilir,
+$('#slaytresmi').show();
+// => jQuery [<img id='slaytresmi'>] (1)
+
+// Yada dilediğiniz CSS niteliğini anime edebilirsiniz,
+
+// Bu parametre, anime etmek istediğiniz CSS özelliklerini
+// belirleyen Obje bilgisidir.
+// Yükseklik ve Genişlik bilgileri için değerler belirliyoruz.
+const animeEdilecekCSSOzellikleri =
+  {
+    weight: "300px",
+    height: "300px"
+  };
+
+// Diğer anime edilebilir CSS özellikleri;
+/*
+Elementin,
+- Opaklık; opacity
+- Dış çevre mesafesi; margin
+- Çerçeve yüksekliği; borderWidth
+- Satır yüksekliği; lineHeight
+
+Diğer tüm özellikler için resmi siteyi kontrol ediniz.
+*/
+
+// Bu parametre animasyonun süresini belirler.
+const milisaniyeCinsindenAnimasyonSuresi =
+  1200;
+
+// Bu parametre, 'linear' yada 'swing' metin
+// bilgilerinden birini alır ve animasyonun
+// akıcılığını belirler.
+// x ∈ {'linear', 'swing'}
+const animasyonAkiciligi = 'linear';
+
+// Bu parametre, bir fonksiyondur ve
+// animasyondan sonra çağırılır.
+// Bir geri-çağırım (callback*) olarak değerlendirilebilir.
+const animasyonGeriCagirimFonksiyonu = function(){
+  console.info('Animasyon bitti!');
+};
+
+// Şimdi tanımlanan bilgilerimizle animasyonu çağırıyoruz.
+$('#slaytresmi').animate(animeEdilecekCSSOzellikleri,
+                         milisaniyeCinsindenAnimasyonSuresi,
+                         animasyonAkiciligi,
+                         animasyonGeriCagirimFonksiyonu);
+// => jQuery [<img id='slaytresmi'>] (1)
+
+// Kütüphane `$.animate` fonksiyonu için, anime edeceğiniz
+// CSS özellikleri dışındaki tüm argümanlar için
+// ön tanımlı değerler sağlamaktadır.
+// Bu değerler için resmi siteyi kontrol ediniz.
+
+// Diğer ön tanımlı efektler;
+/*
+Elementi,
+- Yukarı kaydırır; $.slideUp
+- Verilen saydamlık değerine anime eder; $.fadeTo
+- Görünür yada görünmez yapar (geçerli durumuna bağlı); $.toggle
+
+Diğer tüm efektler için resmi siteyi kontrol ediniz.
+*/
+
+// 3. Manipülasyon
+
+// jQuery'de, HTML elementlerinin isteğiniz doğrultusunda
+// değiştirilmesi için araçlar sunulmakta.
+
+// Bir ön-tanımlı CSS sınıfımız olduğunu hayal edebilirsiniz.
+// Bu sınıfı istediğimiz elemente uygulamak için,
+$('#slaytresmi').addClass('inanilmaz-bir-cerceve-sinifi');
+// => jQuery [<img id='slaytresmi' class='inanilmaz-bir-cerceve-sinifi'>] (1)
+
+// Bu CSS sınıfını istediğimiz zaman silebiliriz,
+$('#slaytresmi').removeClass('inanilmaz-bir-cerceve-sinifi');
+// => jQuery [<img id='slaytresmi'>] (1)
+
+// Bu HTML elementini, istediğimiz başka bir element ile çevreleyebiliriz,
+$('#slaytresmi').wrap('<div class="farkli-bir-cerceve"></div>');
+// => jQuery [<img id='slaytresmi'>] (1)
+// Sonucun gözlemlenebilmesi için, elementin çevreleme işlemi sonrası
+// döküman üzerindeki yapısını temel bir seçici ile gözlemleyebiliriz;
+$('.farli-bir-cerceve')
+// => jQuery [<div class='farkli-bir-cerceve>] (1)
+// => <div class="farkli-bir-cerceve">
+//      <img id='slaytresmi'>
+//    </div>
+
+// Elemente içerik ekleyebiliriz,
+// Eklemeler döküman içeriğinin sonuna yapılacaktır.
+// Bu süreci daha iyi gözlemleyebilmek için içeriğine bakmamız yeterli,
+// Ekleme öncesinde;
+$('.farkli-bir-cerceve');
+// => jQuery [<div class='farkli-bir-cerceve>] (1)
+// => <div class="farkli-bir-cerceve">
+//      <img id='slaytresmi'>
+//    </div>
+
+// `$.append` fonksiyonu ile ekleme işlemini yapıyoruz.
+$('.farkli-bir-cerceve').append('<h1>Bu çerçeve farklı!</h1>');
+// => jQuery [<div class='farkli-bir-cerceve>] (1)
+// => <div class="farkli-bir-cerceve">
+//      <img id='slaytresmi'>
+//      <h1>Bu çerçeve farklı!</h1>
+//    </div>
+
+// Dökümandan element silebiliriz,
+$('.farkli-bir-cerceve > h1').remove();
+// => jQuery [<h1>] (1)
+
+// Dökümanın güncel halini görmek için seçiciyi çağırıyoruz,
+$('.farkli-bir-cerceve');
+// => jQuery [<div class='farkli-bir-cerceve>] (1**
+// => <div class="farkli-bir-cerceve">
+//      <img id='slaytresmi'>
+//    </div>
+
+// Elementlerin özniteliklerini değiştirebilir yada
+// silebiliriz.
+// Öznitelik erişici ve değiştiricisi,
+// Bir fonksiyon notasyonuyla yapılanmış durumda.
+// Eğer bir öznitelik bilgisini almak istiyorsak, ilgili öznitelik
+// ismini;
+
+$('.farkli-bir-cerceve > img').attr('id');
+// => 'slaytresmi'
+
+// Eğer bir öznitelik bilgisini güncellemek istiyorsak,
+// ilgili öznitelik ismi ve sonrasında yeni değerini argüman
+// olarak $.attr fonksiyonuna iletiyoruz;
+
+$('.farkli-bir-cerceve > img').attr('id', 'cercevelislaytresmi');
+// => jQuery [<img id='cercevelislaytresmi'>] (1)
+
+// Diğer ön fonksiyonlar;
+/*
+Elementin,
+- Yükseklik değeri, $.height
+- HTML döküman içeriği, $.html
+- Girdi içeriği, $.val
+- Verilen CSS sınıfına sahipliği, $.hasClass
+
+Diğer tüm manipülasyon fonksiyonları için resmi siteyi kontrol ediniz.
+*/
+
+```
+
+## Notlar
+
+- Yaygın bir yanlış bilineni düzeltmek adına; jQuery bir çalışma-çatısı değil, bir *kütüphanedir*.
+- [Lower Camel Case][lower-camel-case-notasyonu] notasyonu için Wikipedia sayfası.
+
+## İleri Okuma
+
+### İngilizce
+
+- [jQuery][jquery-official-website] resmi sitesi.
+
+- [Jakob Jenkov | $(document).ready article](http://tutorials.jenkov.com/jquery/document-ready.html)
+
+[jquery-official-website]: https://jquery.com
+[ajax-wikipedia-page]: https://en.wikipedia.org/wiki/Ajax_(programming)
+[javascript-learnxinyminutes-page]: https://learnxinyminutes.com/docs/javascript/
+[lower-camel-case-notasyonu]: https://en.wikipedia.org/wiki/Camel_case#Programming_and_coding
diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown
new file mode 100644
index 00000000..4d2dd291
--- /dev/null
+++ b/tr-tr/kotlin-tr.html.markdown
@@ -0,0 +1,474 @@
+---
+language: kotlin
+filename: kotlin-tr.kt
+contributors:
+        - ["Baha Can Aydın", "https://github.com/bahacan19"]
+lang: tr-tr
+---
+Kotlin, JVM, Android ve tarayıcı için statik olarak yazılmış bir programlama dilidir.
+Java %100 birlikte çalışabilir.
+[Daha:](https://kotlinlang.org/)
+
+```kotlin
+
+// Tek satır yoruma almak için : //
+/*
+    Birkaç satırı yoruma almak için
+*/
+
+//  "package" anahtar kelimesi tıpkı Java'da olduğu gibidir.
+package com.learnxinyminutes.kotlin
+
+/*
+Bir Kotlin programının başlama noktası (Java'da olduğu gibi) "com.learnxinyminutes.kotlin.main" metodudur.
+Bu metoda komut satırından bir 'Array' gönderilebilir.
+*/
+fun main(args: Array<String>) {
+    /*
+    Bir değer tanımlamak için "var" ya da "val" anahtar kelimeleri kullanılıyor.
+    "val" tanımlananlar tekrar atanamazken "var" tanımlananlar atanabilir.
+    */
+    val fooVal = 10 // fooVal değerini daha sonra tekrar atayamıyoruz
+    var fooVar = 10
+    fooVar = 20 // fooVar tekrar atanabilir.
+
+    /*
+    Çoğu zaman, Kotlin bir değişkenin tipini anlayabilir,
+    bu yüzden her zaman belirtmeye gerek yoktur.
+    Bir değişkenin tipini şöyle belirtebiliriz:
+    */
+    val foo: Int = 7
+
+    /*
+    String değerler Java'da olduğu gibi tanımlanır.
+    */
+    val fooString = "İşte String bu!"
+    val barString = "Yeni satıra geçiyorum...?\nGeçtim!"
+    val bazString = "Tab mı istedin?\tAl bakalım!"
+    println(fooString)
+    println(barString)
+    println(bazString)
+
+    /*
+    Raw string, üçlü çift-tırnak sınırlandırılan String bloklarıdır.
+    Tıpkı bir text editör gibi String tanımlamaya izin verir.
+    */
+    val fooRawString = """
+fun helloWorld(val name : String) {
+   println("Merhaba, dünya!")
+}
+"""
+    println(fooRawString)
+
+    /*
+    String değerler, ($) işareti ile birtakım deyimler ve değerler içererbilir
+    */
+    val fooTemplateString = "$fooString değerinin ${fooString.length} adet karakteri vardır."
+    println(fooTemplateString)
+
+    /*
+    Null atanabilen bir değişken nullable olarak tanımlanmalıdır.
+    Bu, deişken tipinin sonuna ? eklenerek yapılabilir.
+    Erişim ise '?.' operatörü ile yapılır.
+    Bir değişken null ise, yerine kullaılacak alternatif bir değer belirtmek için
+    '?:' operatörünü kullanırız.
+    */
+    var fooNullable: String? = "abc"
+    println(fooNullable?.length) // => 3
+    println(fooNullable?.length ?: -1) // => 3
+    fooNullable = null
+    println(fooNullable?.length) // => null
+    println(fooNullable?.length ?: -1) // => -1
+
+    /*
+    Metodlar "fun" anahtar kelimesi ile tanımlanır.
+    Metod argümanları, Metod adından sonra  parantez içinde belirtilir.
+    Metod argümanlarının opsiyonel olarak default (varsayılan) değerleri olabilir.
+    Metodun dönüş tipi, gerekirse, metod parentezinden sonra ':' operatörü ile belirtilir.
+    */
+    fun hello(name: String = "dünya"): String {
+        return "Merhaba, $name!"
+    }
+    println(hello("foo")) // => Merhaba, foo!
+    println(hello(name = "bar")) // => Merhaba, bar!
+    println(hello()) // => Merhaba, dünya!
+
+    /*
+    Bir metoda çokca argüman göndermek için 'vararg' anahtar kelimesi
+    kullanılır.
+    */
+    fun varargExample(vararg names: Int) {
+        println("${names.size}  adet arguman paslanmıştır")
+    }
+    varargExample() // => 0 adet arguman paslanmıştır
+    varargExample(1) // => 1 adet arguman paslanmıştır
+    varargExample(1, 2, 3) // => 3 adet arguman paslanmıştır
+
+    /*
+    Bir metod tek bir ifadeden oluşuyorsa
+    süslü parantezler yerine '=' kullanılabilir.
+    */
+    fun odd(x: Int): Boolean = x % 2 == 1
+    println(odd(6)) // => false
+    println(odd(7)) // => true
+
+    // Eğer dönüş tipi anlaşılabiliyorsa ayrıca belirtmemize gerek yoktur.
+    fun even(x: Int) = x % 2 == 0
+    println(even(6)) // => true
+    println(even(7)) // => false
+
+    // Metodlar, metodları arguman ve dönüş tipi olarak alabilir
+    fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+        return {n -> !f.invoke(n)} // bu satırdaki !f.invoke(n) metodu !f(n) şeklinde sadeleştirilebilir.
+    }
+
+
+    // Bir metodu sadece '::' ön eki ile de arguman olarak çağırabiliriz
+    println(not(::odd)(4)) // ==> true
+
+    // Metodlar değişken gibi atanabilir.
+    val notOdd = not(::odd)
+    val notEven = not(::even)
+
+    // Lambda ifadeleri arguman olarak paslanabilir.
+    val notZero = not {n -> n == 0}
+    /*
+    Eğer bir lambda fonksiyonu sadece bir arguman alıyorsa,
+    '->' ifadesi atlanabilir, 'it' ifadesi ile belirtilebilir.
+    */
+    val notPositive = not { it > 0} // not(n -> n > 0) ifadesi ile aynı
+
+    for (i in 0..4) {
+        println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+    }
+
+    /*
+    * Diğer for döngüleri
+    * */
+    val myInt = 3
+    for (i in 1..100) {  }  // kapalı aralık. 100 dahil.
+    for (i in 1 until 100) {  } // 100 dahil değil
+    for (x in 2..10 step 2) {  } // ikişer adımlı
+    for (x in 10 downTo 1) {  } // Ondan geriye doğru. 1 dahil.
+    if (myInt in 1..10) {  }
+
+
+
+    /*
+    Bir sınıf tanımlamak için 'class' anahtar kelimesi kullanılır.
+    Kotlin'de bütün sınıflar varsayılan olarak 'final' tanımlanırlar.
+    * */
+    class ExampleClass(val x: Int) {
+
+        fun memberFunction(y: Int): Int {
+            return x + y
+        }
+
+        infix fun yTimes(y: Int): Int {
+            return x * y
+        }
+    }
+    /*
+    * Bir sınıfı türetilebilir yapmak için 'open' anahtar kelimesi kullanılır.
+    * */
+    open class A
+
+    class B : A()
+
+
+    /*
+    Yeni bir instance oluşturmak için doğrudan constructor çağırılır.
+    Kotlinde 'new' anahtar kelimesi yoktur.
+    */
+    val fooExampleClass = ExampleClass(7)
+    // Bir sınıfa üye metodları . (nokta) ile çağırabiliriz.
+    println(fooExampleClass.memberFunction(4)) // => 11
+    /*
+    'infix' ön eki ile tanımlanan metodlar
+    alışılan metod çağrısını daha kolay bir söz dizimine dönüştürür.
+    */
+    println(fooExampleClass yTimes 4) // => 28
+
+    /*
+    Data class lar sadece veri tutan sınıflar için uygun bir çözümdür.
+    Bu şekilde tanımlanan sınıfların "hashCode"/"equals" ve "toString" metodları
+    otomatik olarak oluşur.
+    */
+    data class DataClassExample (val x: Int, val y: Int, val z: Int)
+    val fooData = DataClassExample(1, 2, 4)
+    println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+    // Data class ların copy metodları olur.
+    val fooCopy = fooData.copy(y = 100)
+    println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+    // Destructuring Declarations, bir objeyi çoklu değişkenler ile ifade etme yöntemidir.
+    val (a, b, c) = fooCopy
+    println("$a $b $c") // => 1 100 4
+
+    // bir 'for' döngüsü içinde 'Destructuring' :
+    for ((a, b, c) in listOf(fooData)) {
+        println("$a $b $c") // => 1 100 4
+    }
+
+    val mapData = mapOf("a" to 1, "b" to 2)
+    // Map.Entry de destructurable gösterilebilir.
+    for ((key, value) in mapData) {
+        println("$key -> $value")
+    }
+
+    // 'with' metodu ile bir objeye bir lamda metodu uygulayabiliriz.
+    data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+    val fooMutableData = MutableDataClassExample(7, 4, 9)
+    with (fooMutableData) {
+        x -= 2
+        y += 2
+        z--
+    }
+
+    println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+    /*
+    'listOf' metodu ile bir liste oluşturulabilir.
+    Oluşan liste immutable olacaktır, yani elaman eklenemez ve çıkarılamaz.
+    */
+    val fooList = listOf("a", "b", "c")
+    println(fooList.size) // => 3
+    println(fooList.first()) // => a
+    println(fooList.last()) // => c
+    // Elemanlara indexleri ile erişilebilir.
+    println(fooList[1]) // => b
+
+    // Mutable bir liste ise 'mutableListOf' metodu ile oluşturabilir.
+    val fooMutableList = mutableListOf("a", "b", "c")
+    fooMutableList.add("d")
+    println(fooMutableList.last()) // => d
+    println(fooMutableList.size) // => 4
+
+    // Bir 'set' oluşturmak için 'setOf' metodunu kullanabiliriz.
+    val fooSet = setOf("a", "b", "c")
+    println(fooSet.contains("a")) // => true
+    println(fooSet.contains("z")) // => false
+
+    // 'mapOf' metodu ile 'map' oluşturabiliriz.
+    val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+    // Map değerlerine ulaşmak için :
+    println(fooMap["a"]) // => 8
+
+    /*
+    Sequence, Kotlin dilinde lazy-hesaplanan collection ları temsil eder.
+    Bunun için 'generateSequence' metodunu kullanabiliriz. Bu metod bir önceki değerden
+    bir sonraki değeri hesaplamak için gerekli bir lamda metodunu arguman olarak alır.
+    */
+    val fooSequence = generateSequence(1, { it + 1 })
+
+    val x = fooSequence.take(10).toList()
+    println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    // Örneğin fibonacci serisi oluşturabilen bir 'Sequence' oluşturmak için:
+    fun fibonacciSequence(): Sequence<Long> {
+        var a = 0L
+        var b = 1L
+
+        fun next(): Long {
+            val result = a + b
+            a = b
+            b = result
+            return a
+        }
+
+        return generateSequence(::next)
+    }
+    val y = fibonacciSequence().take(10).toList()
+    println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+
+    // Kotlin Collection lar ile çalışmak için higher-order metodlar sağlar.
+    val z = (1..9)
+            .map {it * 3} // her bir elamanı 3 ile çarp
+            .filter {it < 20} // 20 den küçük değerleri ele
+            .groupBy {it % 2 == 0} // ikiye tam bölünen ve bölünmeyen şeklinde grupla (Map)
+            .mapKeys {if (it.key) "even" else "odd"} // oluşan map in boolen 'key' lerini String bir değere dönüştür.
+    println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+    // Bir 'for' döngüsü 'itearator' sağlayan her objeye uygulanabilir.
+    for (c in "merhaba") {
+        println(c)
+    }
+
+    // 'while' döngüsü diğer dillere benzer şekilde çalışır.
+    var ctr = 0
+    while (ctr < 5) {
+        println(ctr)
+        ctr++
+    }
+    do {
+        println(ctr)
+        ctr++
+    } while (ctr < 10)
+
+    /*
+    'if' bir dönüş değeri olan deyim gibi de kullanılabilir.
+    Bu sebepten Kotlin, Java'da bulunan '?:' ifadesi içermez.
+    */
+    val num = 5
+    val message = if (num % 2 == 0) "even" else "odd"
+    println("$num is $message") // => 5 is odd
+
+    // 'if-else if' yapıları için 'when' kullanılabilir.
+    val i = 10
+    when {
+        i < 7                         ->    println("first block")
+        fooString.startsWith("hello") ->    println("second block")
+        else                          ->    println("else block")
+    }
+
+    // 'when' bir parametre ile de kullanılabilir.
+    when (i) {
+        0, 21 -> println("0 or 21")
+        in 1..20 -> println("in the range 1 to 20")
+        else -> println("none of the above")
+    }
+
+    // 'when' dönüş değeri olan bir metod gibi de davranabilir.
+    var result = when (i) {
+        0, 21 -> "0 or 21"
+        in 1..20 -> "in the range 1 to 20"
+        else -> "none of the above"
+    }
+    println(result)
+
+
+    /*
+    Bir objenin tipini 'is' operatörü ile tayin edebiliriz.
+    Eğer obje tip kontrolünü geçerse, cast etmeden doğrudan
+    o tipteymiş gibi kullanılabilir.
+    */
+    fun smartCastExample(x: Any) : Boolean {
+        if (x is Boolean) {
+            // x otomatik olarak Boolean'a cast edilir.
+            return x
+        } else if (x is Int) {
+            // x otomatik olarak Int tipine cast edilir.
+            return x > 0
+        } else if (x is String) {
+            // x otomatik olarak String tipine cast edilir.
+            return x.isNotEmpty()
+        } else {
+            return false
+        }
+    }
+    println(smartCastExample("Merhaba, dünya!")) // => true
+    println(smartCastExample("")) // => false
+    println(smartCastExample(5)) // => true
+    println(smartCastExample(0)) // => false
+    println(smartCastExample(true)) // => true
+
+    // Smartcast 'when' bloğu ile de çalışır.
+    fun smartCastWhenExample(x: Any) = when (x) {
+        is Boolean -> x
+        is Int -> x > 0
+        is String -> x.isNotEmpty()
+        else -> false
+    }
+
+    /*
+    Extension lar, bir sınıfa fonksinolalite eklemenin bir yoludur.
+    */
+    fun String.remove(c: Char): String {
+        return this.filter {it != c}
+    }
+    println("Merhaba, dünya!".remove('a')) // => Merhb, düny!
+
+
+
+    //Biraz detaylı Kotlin
+
+
+    /*
+     * Delegated Properties, bir değişken tanımlarken kullanılan birkaç standart yöntemler içerir.
+     * https://kotlinlang.org/docs/reference/delegated-properties.html
+     * En bilinen delegate property metodları: lazy(), observable()
+     * */
+
+    /*
+     * Lazy, bir değişkeni ilk erişimde çalıştırılacak olan bir lambda ile tanımlama metodudur.
+     * Sonraki erişimlerde değişkene atanan değer hatırlanır.
+     * Lazy, synchronized bir delegation yöntemidir; değer sadece bir thread içinde hesaplanır,
+     * tüm thread ler aynı değere erişir. Eğer senkronizasyon gerekli değilse, lazy metodu içine
+     * LazyThreadSafetyMode.PUBLICATION paslanabilir.
+     * */
+
+    val lazyValue: String by lazy( {
+        println("bi sn... hesaplıyorum....")
+        "Selam!"
+    })
+
+    println(lazyValue)// bi sn... hesaplıyorum.... Selam!
+    println(lazyValue) // Selam!
+    /*
+     * Observable, bir değişkende olabilecek yeniden atama değişikliklerini dinleme yöntemidir.
+     * İki arguman alır; değişkenin ilk değeri, değiştiğinde çağrılan bir handler metodu. Handler
+     * metodu değişken her değiştiğinde çağırılır.
+     * */
+    var myObservableName: String by Delegates.observable("<isim yok>") {
+        prop, old, new ->
+        println("$old -> $new")
+    }
+    myObservableName = "Baha" //<isim yok> -> Baha
+    myObservableName = "Can"  //Baha -> Can
+
+
+    /*
+     * Eğer değişkenin yeniden atanmasını denetlemek isterek vetoable()
+     * metodunu kullanabiliriz.
+     * */
+
+    var myVetoableName : String by Delegates.vetoable("<isim yok>"){
+        property, oldValue, newValue ->
+        if (newValue.length < 2) {
+            println("Tek harfli isim kabul etmiyoruz!")
+            false
+        } else {
+            println("$oldValue -> $newValue")
+            true
+        }
+    }
+
+    myVetoableName = "Baha" //<isim yok> -> Baha
+    myVetoableName = "C"    //Tek harfli isim kabul etmiyoruz!
+    println(myVetoableName) //Baha
+
+
+    //singleton değişkene ulaşmak:
+    println(ObjectExample.hello()) // => Merhaba
+}
+
+// Enum class lar Java'daki enum lara benzerdir.
+enum class EnumExample {
+    A, B, C
+}
+
+/*
+'object' anahtar kelimesi ile singleton nesneler oluşturulabilir.
+Bu şekilde tanımlanan sınıflardan yeni nesneler oluşturulamaz, sadece adı ile refere edilebilir.
+*/
+object ObjectExample {
+    fun hello(): String {
+        return "Merhaba"
+    }
+}
+
+fun useObject() {
+    ObjectExample.hello()
+    val someRef: Any = ObjectExample
+}
+
+```
+
+### İlerisi için:
+
+* [Kotlin tutorials](https://kotlinlang.org/docs/tutorials/)
+* [Try Kotlin in your browser](http://try.kotlinlang.org/)
+* [A list of Kotlin resources](http://kotlin.link/)
+* [Kotlin Koans in your IDE](https://kotlinlang.org/docs/tutorials/koans.html/)
diff --git a/tr-tr/markdown-tr.html.markdown b/tr-tr/markdown-tr.html.markdown
index b8f11e39..6caba1da 100644
--- a/tr-tr/markdown-tr.html.markdown
+++ b/tr-tr/markdown-tr.html.markdown
@@ -11,7 +11,7 @@ filename: markdown-tr.md
 Markdown, 2004 yılında John Gruber tarafından oluşturuldu. Asıl amacı kolay okuma ve yazmayı sağlamakla beraber kolayca HTML (artık bir çok diğer formatlara) dönüşüm sağlamaktır.
 
 
-```markdown
+```md
 <!-- Markdown, HTML'i kapsar, yani her HTML dosyası geçerli bir Markdown dosyasıdır, bu demektir
 ki Markdown içerisinde HTML etiketleri kullanabiliriz, örneğin bu yorum elementi, ve
 markdown işleyicisinde etki etmezler. Fakat, markdown dosyası içerisinde HTML elementi oluşturursanız,
diff --git a/tr-tr/python-tr.html.markdown b/tr-tr/python-tr.html.markdown
index 01285080..6d9cdcbe 100644
--- a/tr-tr/python-tr.html.markdown
+++ b/tr-tr/python-tr.html.markdown
@@ -1,316 +1,344 @@
 ---
-language: python
-filename: learnpython-tr.py
+language: Python
 contributors:
-    - ["Louie Dinh", "http://ldinh.ca"]
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Batuhan Osman T.", "https://github.com/BTaskaya"]
 translators:
-    - ["Haydar KULEKCI", "http://scanf.info/"]
+    - ["Eray AYDIN", "http://erayaydin.me/"]
 lang: tr-tr
+filename: learnpython-tr.py
 ---
-Python Guido Van Rossum tarafından 90'ların başında yaratılmıştır. Şu anda 
-varolanlar arasında en iyi dillerden birisidir. Ben (Louie Dinh) Python
-dilinin syntax'ının belirginliğine aşığım. O basit olarak çalıştırılabilir 
-pseudocode'dur.
 
-Geri bildirimlerden son derece mutluluk duyarım! Bana [@louiedinh](http://twitter.com/louiedinh)
-adresinden ya da louiedinh [at] [google's email service] adresinden ulaşabilirsiniz.
+Python,90ların başlarında Guido Van Rossum tarafından oluşturulmuştur. En popüler olan dillerden biridir. Beni Python'a aşık eden sebep onun syntax beraklığı. Çok basit bir çalıştırılabilir söz koddur.
 
-Çeviri için geri bildirimleri de [@kulekci](http://twitter.com/kulekci) 
-adresine yapabilirsiniz. 
+Not: Bu makale Python 3 içindir. Eğer Python 2.7 öğrenmek istiyorsanız [burayı](http://learnxinyminutes.com/docs/pythonlegacy/) kontrol edebilirsiniz.
 
-Not: Bu yazıdaki özellikler Python 2.7 için geçerlidir, ama Python 2.x için de 
-uygulanabilir. Python 3 için başka bir zaman tekrar bakınız. 
+```python
 
+# Tek satırlık yorum satırı kare(#) işareti ile başlamaktadır.
 
-```python
-# Tek satır yorum hash işareti ile başlar.
-""" Çoklu satır diziler üç tane çift tırnak 
-    arasında yazılır. Ve yorum olarak da 
-    kullanılabilir
+""" Çok satırlı olmasını istediğiniz yorumlar
+    üç adet tırnak(") işareti ile
+    yapılmaktadır
 """
 
-
 ####################################################
-## 1. İlkel Veri Tipleri ve Operatörler
+## 1. Temel Veri Türleri ve Operatörler
 ####################################################
 
 # Sayılar
-3 #=> 3
+3  # => 3
+
+# Tahmin edebileceğiniz gibi matematik
+1 + 1  # => 2
+8 - 1  # => 7
+10 * 2  # => 20
+
+# Bölme işlemi varsayılan olarak onluk döndürür
+35 / 5  # => 7.0
+
+# Tam sayı bölmeleri, pozitif ve negatif sayılar için aşağıya yuvarlar
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # onluklar için de bu böyledir
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
 
-# Matematik beklediğiniz gibi
-1 + 1 #=> 2
-8 - 1 #=> 7
-10 * 2 #=> 20
-35 / 5 #=> 7
+# Onluk kullanırsanız, sonuç da onluk olur
+3 * 2.0 # => 6.0
 
-# Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız
-# sonuç otomatik olarak kırpılır. 
-5 / 2 #=> 2
+# Kalan operatörü
+7 % 3 # => 1
 
-# Bölünme işlemini düzenlemek için kayan noktalı sayıları bilmeniz gerekir.
-2.0     # Bu bir kayan noktalı sayı
-11.0 / 4.0 #=> 2.75 ahhh...daha iyi
+# Üs (2 üzeri 4)
+2**4 # => 16
 
-# İşlem önceliğini parantezler ile sağlayabilirsiniz.
-(1 + 3) * 2 #=> 8
+# Parantez ile önceliği değiştirebilirsiniz
+(1 + 3) * 2  # => 8
 
-# Boolean değerleri bilindiği gibi
+# Boolean(Doğru-Yanlış) değerleri standart
 True
 False
 
-# not ile nagatif(mantıksal) değerini alma
-not True #=> False
-not False #=> True
+# 'değil' ile terse çevirme
+not True  # => False
+not False  # => True
 
-# Eşitlik ==
-1 == 1 #=> True
-2 == 1 #=> False
+# Boolean Operatörleri
+# "and" ve "or" büyük küçük harf duyarlıdır
+True and False #=> False
+False or True #=> True
 
-# Eşitsizlik !=
-1 != 1 #=> False
-2 != 1 #=> True
+# Bool operatörleri ile sayı kullanımı
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True 
+2 == True #=> False 
+1 == True #=> True
 
-# Daha fazla karşılaştırma
-1 < 10 #=> True
-1 > 10 #=> False
-2 <= 2 #=> True
-2 >= 2 #=> True
+# Eşitlik kontrolü ==
+1 == 1  # => True
+2 == 1  # => False
 
-# Karşılaştırma zincirleme yapılabilir!
-1 < 2 < 3 #=> True
-2 < 3 < 2 #=> False
+# Eşitsizlik Kontrolü !=
+1 != 1  # => False
+2 != 1  # => True
 
-# Karakter dizisi " veya ' ile oluşturulabilir
-"This is a string."
-'This is also a string.'
+# Diğer karşılaştırmalar
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
 
-# Karakter dizileri birbirleri ile eklenebilir
-"Hello " + "world!" #=> "Hello world!"
+# Zincirleme şeklinde karşılaştırma da yapabilirsiniz!
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
 
-# A string can be treated like a list of characters
-# Bir string'e karakter listesi gibi davranabilirsiniz. 
-"This is a string"[0] #=> 'T'
+# Yazı(Strings) " veya ' işaretleri ile oluşturulabilir
+"Bu bir yazı."
+'Bu da bir yazı.'
 
-# % karakter dizisini(string) formatlamak için kullanılır, bunun gibi:
-"%s can be %s" % ("strings", "interpolated")
+# Yazılar da eklenebilir! Fakat bunu yapmanızı önermem.
+"Merhaba " + "dünya!"  # => "Merhaba dünya!"
 
-# String'leri formatlamanın yeni bir yöntem ise format metodudur. 
-# Bu metod tercih edilen yöntemdir.
-"{0} can be {1}".format("strings", "formatted")
-# Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz.
-"{name} wants to eat {food}".format(name="Bob", food="lasagna")
+# Bir yazı(string) karakter listesi gibi işlenebilir
+"Bu bir yazı"[0]  # => 'B'
 
-# None bir objedir
-None #=> None
+# .format ile yazıyı biçimlendirebilirsiniz, şu şekilde:
+"{} da ayrıca {}".format("yazılar", "işlenebilir")
 
-# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın.
-# Onun yerine "is" kullanın.
-"etc" is None #=> False
-None is None  #=> True
+# Biçimlendirme işleminde aynı argümanı da birden fazla kullanabilirsiniz.
+"{0} çeviktir, {0} hızlıdır, {0} , {1} üzerinden atlayabilir".format("Ahmet", "şeker çubuğu")
+#=> "Ahmet çeviktir, Ahmet hızlıdır, Ahmet , şeker çubuğu üzerinden atlayabilir"
 
-# 'is' operatörü obje kimliği için test etmektedir. Bu ilkel değerler
-# için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır.
+# Argümanın sırasını saymak istemiyorsanız, anahtar kelime kullanabilirsiniz.
+"{isim} yemek olarak {yemek} istiyor".format(isim="Ahmet", yemek="patates") #=> "Ahmet yemek olarak patates istiyor"
 
-# None, 0 ve boş string/list'ler False olarak değerlendirilir.
-# Tüm eşitlikler True döner
-0 == False  #=> True
-"" == False #=> True
+# Eğer Python 3 kodunuz ayrıca Python 2.5 ve üstünde çalışmasını istiyorsanız, 
+# eski stil formatlamayı kullanabilirsiniz:
+"%s bu %s yolla da %s" % ("yazılar", "eski", "biçimlendirilebilir")
 
 
-####################################################
-## 2. Değişkenler ve Kolleksiyonlar
-####################################################
+# Hiçbir şey(none) da bir objedir
+None  # => None
 
-# Ekrana yazdırma oldukça kolaydır.
-print "I'm Python. Nice to meet you!"
+# Bir değerin none ile eşitlik kontrolü için "==" sembolünü kullanmayın
+# Bunun yerine "is" kullanın. Obje türünün eşitliğini kontrol edecektir.
+"vb" is None  # => False
+None is None  # => True
 
+# None, 0, ve boş yazılar/listeler/sözlükler hepsi False değeri döndürü.
+# Diğer veriler ise True değeri döndürür
+bool(0)  # => False
+bool("")  # => False
+bool([]) #=> False
+bool({}) #=> False
 
-# Değişkenlere bir değer atamadan önce tanımlamaya gerek yoktur.
-some_var = 5    # Değişken isimlerinde gelenek küçük karakter ve alt çizgi 
-                # kullanmaktır.
-some_var #=> 5
 
-# Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye 
-# çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla 
-# bilgi için kontrol akışı kısmına göz atınız.
-some_other_var  # isim hatası fırlatılır
+####################################################
+## 2. Değişkenler ve Koleksiyonlar
+####################################################
 
-# isterseniz "if"i bir ifade gibi kullanabilirsiniz.
-"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
+# Python bir yazdırma fonksiyonuna sahip
+print("Ben Python. Tanıştığıma memnun oldum!")
 
-# Listeler
+# Değişkenlere veri atamak için önce değişkeni oluşturmanıza gerek yok. 
+# Düzenli bir değişken için hepsi_kucuk_ve_alt_cizgi_ile_ayirin
+bir_degisken = 5
+bir_degisken  # => 5
+
+# Önceden tanımlanmamış değişkene erişmek hata oluşturacaktır.
+# Kontrol akışları başlığından hata kontrolünü öğrenebilirsiniz.
+bir_bilinmeyen_degisken  # NameError hatası oluşturur
+
+# Listeler ile sıralamaları tutabilirsiniz
 li = []
-# Önceden değerleri tanımlanmış listeler
-other_li = [4, 5, 6]
-
-# Bir listenin sonuna birşeyler eklemek
-li.append(1)    #li şu anda [1]
-li.append(2)    #li şu anda [1, 2]
-li.append(4)    #li şu anda [1, 2, 4]
-li.append(3)    #li şu anda [1, 2, 4, 3]
-# pop ile sondan birşeyler silmek
-li.pop()        #=> 3 and li is now [1, 2, 4]
-# Tekrar sonuna eklemek
-li.append(3)    # li is now [1, 2, 4, 3] again.
-
-# Dizi gibi listenin elemanlarına erişmek
-li[0] #=> 1
-# Son elemanın değerine ulaşmak
-li[-1] #=> 3
-
-# Listede bulunmayan bir index'teki elemana erişirken "IndexError" hatası 
-# fırlatılır 
-li[4] # IndexError fırlatılır
-
-# slice syntax'ı ile belli aralıktakı değerlere bakabilirsiniz.
-# (Açık ve kapalı aralıklıdır.)
-li[1:3] #=> [2, 4]
-# Başlangıcı ihmal etme
-li[2:] #=> [4, 3]
-# Sonu ihmal etme
-li[:3] #=> [1, 2, 4]
-
-# "del" ile istenilen bir elemanı listeden silmek
-del li[2] # li is now [1, 2, 3]
-
-# Listeleri birbiri ile birleştirebilirsiniz.
-li + other_li #=> [1, 2, 3, 4, 5, 6] - Not: li ve other_li yanlız bırakılır
-
-# extend ile listeleri birleştirmek
-li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]
-
-# bir değerin liste içerisinde varlığını "in" ile kontrol etmek
-1 in li #=> True
-
-# "len" ile listenin uzunluğunu bulmak
-len(li) #=> 6
-
-# Tüpler listeler gibidir sadece değişmezler(immutable)
+# Önceden doldurulmuş listeler ile başlayabilirsiniz
+diger_li = [4, 5, 6]
+
+# 'append' ile listenin sonuna ekleme yapabilirsiniz
+li.append(1)    # li artık [1] oldu
+li.append(2)    # li artık [1, 2] oldu
+li.append(4)    # li artık [1, 2, 4] oldu
+li.append(3)    # li artık [1, 2, 4, 3] oldu
+# 'pop' ile listenin son elementini kaldırabilirsiniz
+li.pop()        # => 3 ve li artık [1, 2, 4]
+# Çıkarttığımız tekrardan ekleyelim
+li.append(3)    # li yeniden [1, 2, 4, 3] oldu.
+
+# Dizi gibi listeye erişim sağlayın
+li[0]  # => 1
+# Son elemente bakın
+li[-1]  # => 3
+
+# Listede olmayan bir elemente erişim sağlamaya çalışmak IndexError hatası oluşturur
+li[4]  # IndexError hatası oluşturur
+
+# Bir kısmını almak isterseniz.
+li[1:3]  # => [2, 4]
+# Başlangıç belirtmezseniz
+li[2:]  # => [4, 3]
+# Sonu belirtmesseniz
+li[:3]  # => [1, 2, 4]
+# Her ikişer objeyi seçme
+li[::2]   # =>[1, 4]
+# Listeyi tersten almak
+li[::-1]   # => [3, 4, 2, 1]
+# Kombinasyonları kullanarak gelişmiş bir şekilde listenin bir kısmını alabilirsiniz
+# li[baslangic:son:adim]
+
+# "del" ile isteğe bağlı, elementleri listeden kaldırabilirsiniz
+del li[2]   # li artık [1, 2, 3] oldu
+
+# Listelerde de ekleme yapabilirsiniz
+# Not: değerler üzerinde değişiklik yapılmaz.
+li + diger_li   # => [1, 2, 3, 4, 5, 6] 
+
+# Listeleri birbirine bağlamak için "extend()" kullanılabilir
+li.extend(diger_li)   #  li artık [1, 2, 3, 4, 5, 6] oldu
+
+# Listedeki bir elementin olup olmadığı kontrolü "in" ile yapılabilir
+1 in li   # => True
+
+# Uzunluğu öğrenmek için "len()" kullanılabilir
+len(li)   # => 6
+
+
+# Tüpler listeler gibidir fakat değiştirilemez.
 tup = (1, 2, 3)
-tup[0] #=> 1
-tup[0] = 3  # TypeError fırlatılır.
-
-# Litelerde yapılanların hepsini tüplerde de yapılabilir
-len(tup) #=> 3
-tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
-tup[:2] #=> (1, 2)
-2 in tup #=> True
-
-# Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere
-# atanabilir
-a, b, c = (1, 2, 3)     # a şu anda 1, b şu anda 2 ve c şu anda 3
-# Eğer parantez kullanmaz iseniz tüpler varsayılan olarak oluşturulur
+tup[0]   # => 1
+tup[0] = 3  # TypeError hatası oluşturur
+
+# Diğer liste işlemlerini tüplerde de uygulayabilirsiniz
+len(tup)   # => 3
+tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
+tup[:2]   # => (1, 2)
+2 in tup   # => True
+
+# Tüpleri(veya listeleri) değişkenlere açabilirsiniz
+a, b, c = (1, 2, 3)     # 'a' artık 1, 'b' artık 2 ve 'c' artık 3
+# Eğer parantez kullanmazsanız varsayılan oalrak tüpler oluşturulur
 d, e, f = 4, 5, 6
-# şimdi iki değeri değiş tokuş etmek çok kolaydır.
-e, d = d, e     # d şimdi 5 ve e şimdi 4
+# 2 değeri birbirine değiştirmek bu kadar kolay
+e, d = d, e     # 'd' artık 5 ve 'e' artık 4
+
 
+# Sözlükler anahtar kodlarla verileri tutar
+bos_sozl = {}
+# Önceden doldurulmuş sözlük oluşturma
+dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
 
-# Sözlükler (Dictionaries) key-value saklanır.
-empty_dict = {}
-# Sözlüklere önceden değer atama örneği
-filled_dict = {"one": 1, "two": 2, "three": 3}
+# Değere bakmak için [] kullanalım
+dolu_sozl["bir"]   # => 1
 
-# Değere ulaşmak için [] kullanılır
-filled_dict["one"] #=> 1
+# Bütün anahtarları almak için  "keys()" kullanılabilir. 
+# Listelemek için list() kullanacağınız çünkü dönen değerin işlenmesi gerekiyor. Bu konuya daha sonra değineceğiz.
+# Not - Sözlük anahtarlarının sıralaması kesin değildir.
+# Beklediğiniz çıktı sizinkiyle tam uyuşmuyor olabilir.
+list(dolu_sozl.keys())   # => ["uc", "iki", "bir"]
 
-# Tüm anahtarlara(key) "keys()" metodu ile ulaşılır
-filled_dict.keys() #=> ["three", "two", "one"]
-# Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir
-# Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir 
 
-# Tüm değerleri almak için "values()" kullanabilirsiniz.
-filled_dict.values() #=> [3, 2, 1]
-# Not - Sıralama ile ilgili anahtarlar ile aynı durum geçerlidir.
+# Tüm değerleri almak için "values()" kullanacağız. Dönen değeri biçimlendirmek için de list() kullanmamız gerekiyor
+# Not - Sıralama değişebilir.
+list(dolu_sozl.values())   # => [3, 2, 1]
 
-# Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir
-"one" in filled_dict #=> True
-1 in filled_dict #=> False
 
-# Olmayan bir anahtar çağrıldığında KeyError fırlatılır.
-filled_dict["four"] # KeyError
+# Bir anahtarın sözlükte olup olmadığını "in" ile kontrol edebilirsiniz
+"bir" in dolu_sozl   # => True
+1 in dolu_sozl   # => False
 
-# "get()" metodu KeyError fırlatılmasını önler
-filled_dict.get("one") #=> 1
-filled_dict.get("four") #=> None
-# get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama
-# imknaı sağlar.
-filled_dict.get("one", 4) #=> 1
-filled_dict.get("four", 4) #=> 4
+# Olmayan bir anahtardan değer elde etmek isterseniz KeyError sorunu oluşacaktır.
+dolu_sozl["dort"]   # KeyError hatası oluşturur
 
-# "setdefault()" metodu sözlüğe yeni bir key-value eşleşmesi eklemenin 
-# güvenli bir yoludur.
-filled_dict.setdefault("five", 5) #filled_dict["five"] is set to 5
-filled_dict.setdefault("five", 6) #filled_dict["five"] is still 5
+# "get()" metodu ile değeri almaya çalışırsanız KeyError sorunundan kurtulursunuz
+dolu_sozl.get("bir")   # => 1
+dolu_sozl.get("dort")   # => None
+# "get" metoduna parametre belirterek değerin olmaması durumunda varsayılan bir değer döndürebilirsiniz.
+dolu_sozl.get("bir", 4)   # => 1
+dolu_sozl.get("dort", 4)   # => 4
 
+# "setdefault()" metodu sözlükte, belirttiğiniz anahtarın [olmaması] durumunda varsayılan bir değer atayacaktır
+dolu_sozl.setdefault("bes", 5)  # dolu_sozl["bes"] artık 5 değerine sahip
+dolu_sozl.setdefault("bes", 6)  # dolu_sozl["bes"] değişmedi, hala 5 değerine sahip
 
-# Sets store ... well sets
-empty_set = set()
-# Bir demek değer ile bir "set" oluşturmak
-some_set = set([1,2,2,3,4]) # some_set is now set([1, 2, 3, 4])
+# Sözlüğe ekleme
+dolu_sozl.update({"dort":4}) #=> {"bir": 1, "iki": 2, "uc": 3, "dort": 4}
+#dolu_sozl["dort"] = 4  #sözlüğe eklemenin bir diğer yolu
 
-# Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir
-filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
+# Sözlükten anahtar silmek için 'del' kullanılabilir
+del dolu_sozl["bir"]  # "bir" anahtarını dolu sözlükten silecektir
 
-# Bir set'e daha fazla eleman eklemek
-filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5}
 
-# "&" işareti ile iki set'in kesişimlerini alınabilir
-other_set = {3, 4, 5, 6}
-filled_set & other_set #=> {3, 4, 5}
+# Setler ... set işte :D 
+bos_set = set()
+# Seti bir veri listesi ile de oluşturabilirsiniz. Evet, biraz sözlük gibi duruyor. Üzgünüm.
+bir_set = {1, 1, 2, 2, 3, 4}   # bir_set artık {1, 2, 3, 4}
 
-# | işareti ile 
-filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
+# Sete yeni setler ekleyebilirsiniz
+dolu_set = bir_set
 
-# "-" işareti ile iki set'in farkları alınabilir
-{1,2,3,4} - {2,3,5} #=> {1, 4}
+# Sete bir diğer öğe ekleme 
+dolu_set.add(5)   # dolu_set artık {1, 2, 3, 4, 5} oldu
 
-# "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz
-2 in filled_set #=> True
-10 in filled_set #=> False
+# Setlerin çakışan kısımlarını almak için '&' kullanabilirsiniz
+diger_set = {3, 4, 5, 6}
+dolu_set & diger_set   # => {3, 4, 5}
+
+# '|' ile aynı olan elementleri almayacak şekilde setleri birleştirebilirsiniz
+dolu_set | diger_set   # => {1, 2, 3, 4, 5, 6}
+
+# Farklılıkları almak için "-" kullanabilirsiniz
+{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
+
+# Bir değerin olup olmadığının kontrolü için "in" kullanılabilir
+2 in dolu_set   # => True
+10 in dolu_set   # => False
 
 
 ####################################################
-## 3. Akış Denetimi
+## 3. Kontrol Akışları ve Temel Soyutlandırma
 ####################################################
 
-# Bir değişken oluşturmak
-some_var = 5
+# Bir değişken oluşturalım
+bir_degisken = 5
 
-# Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir!
-# "some_var is smaller than 10" yazdırılır.
-if some_var > 10:
-    print "some_var is totally bigger than 10."
-elif some_var < 10:    # elif ifadesi isteğe bağlıdır
-    print "some_var is smaller than 10."
-else:           # Bu da isteğe bağlıdır.
-    print "some_var is indeed 10."
+# Burada bir "if" ifadesi var. Girinti(boşluk,tab) python için önemlidir!
+# çıktı olarak "bir_degisken 10 dan küçük" yazar
+if bir_degisken > 10:
+    print("bir_degisken 10 dan büyük")
+elif bir_degisken < 10:    # Bu 'elif' ifadesi zorunlu değildir.
+    print("bir_degisken 10 dan küçük")
+else:                  # Bu ifade de zorunlu değil.
+    print("bir_degisken değeri 10")
 
 
 """
-For döngüleri listeler üzerinde iterasyon yapar
-Ekrana yazdırılan:
-    dog is a mammal
-    cat is a mammal
-    mouse is a mammal
+Döngülerle lsiteleri döngüye alabilirsiniz
+çıktı:
+    köpek bir memeli hayvandır
+    kedi bir memeli hayvandır
+    fare bir memeli hayvandır
 """
-for animal in ["dog", "cat", "mouse"]:
-    # Biçimlendirmeleri string'e katmak için % kullanabilirsiniz
-    print "%s is a mammal" % animal
-    
+for hayvan in ["köpek", "kedi, "fare"]:
+    # format ile kolayca yazıyı biçimlendirelim
+    print("{} bir memeli hayvandır".format(hayvan))
+
 """
-"range(number)" ifadesi sıfırdan verilen sayıya kadar bir sayı listesi döner
-Ekrana yazdırılan:
+"range(sayi)" bir sayı listesi döndür
+0'dan belirttiğiniz sayıyıa kadar
+çıktı:
     0
     1
     2
     3
 """
 for i in range(4):
-    print i
+    print(i)
 
 """
-While döngüsü koşul sağlanmayana kadar devam eder
-Ekrana yazdırılan:
+'While' döngüleri koşul çalıştıkça işlemleri gerçekleştirir.
+çıktı:
     0
     1
     2
@@ -318,185 +346,295 @@ Ekrana yazdırılan:
 """
 x = 0
 while x < 4:
-    print x
-    x += 1  # Shorthand for x = x + 1
-
-# try/except bloğu ile hatalar ayıklanabilir
+    print(x)
+    x += 1  # Uzun hali x = x + 1
 
-# Python 2.6 ve üstü için çalışacaktır:
+# Hataları kontrol altına almak için try/except bloklarını kullanabilirsiniz
 try:
-    # "raise" bir hata fırlatmak için kullanılabilir
-    raise IndexError("This is an index error")
+    # Bir hata oluşturmak için "raise" kullanabilirsiniz
+    raise IndexError("Bu bir index hatası")
 except IndexError as e:
-    pass    # Pass is just a no-op. Usually you would do recovery here.
+    pass    # Önemsiz, devam et.
+except (TypeError, NameError):
+    pass    # Çoklu bir şekilde hataları kontrol edebilirsiniz, tabi gerekirse.
+else:   # İsteğe bağlı bir kısım. Eğer hiçbir hata kontrol mekanizması desteklemiyorsa bu blok çalışacaktır
+    print("Her şey iyi!")   # IndexError, TypeError ve NameError harici bir hatada bu blok çalıştı
+
+# Temel Soyutlandırma, bir objenin işlenmiş halidir.
+# Aşağıdaki örnekte; Obje, range fonksiyonuna temel soyutlandırma gönderdi.
+
+dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
+temel_soyut = dolu_sozl.keys()
+print(temel_soyut) #=> range(1,10). Bu obje temel soyutlandırma arayüzü ile oluşturuldu
+
+# Temel Soyutlandırılmış objeyi döngüye sokabiliriz.
+for i in temel_soyut:
+    print(i)    # Çıktısı: bir, iki, uc
+
+# Fakat, elementin anahtarına değerine.
+temel_soyut[1]  # TypeError hatası!
+
+# 'iterable' bir objenin nasıl temel soyutlandırıldığıdır.
+iterator = iter(temel_soyut)
+
+# 'iterator' o obje üzerinde yaptığımız değişiklikleri hatırlayacaktır
+# Bir sonraki objeyi almak için __next__ fonksiyonunu kullanabilirsiniz.
+iterator.__next__()  #=> "bir"
+
+# Bir önceki __next__ fonksiyonumuzu hatırlayıp bir sonraki kullanımda bu sefer ondan bir sonraki objeyi döndürecektir
+iterator.__next__()  #=> "iki"
+iterator.__next__()  #=> "uc"
+
+# Bütün nesneleri aldıktan sonra bir daha __next__ kullanımınızda, StopIterator hatası oluşturacaktır.
+iterator.__next__() # StopIteration hatası
+
+# iterator'deki tüm nesneleri almak için list() kullanabilirsiniz.
+list(dolu_sozl.keys())  #=> Returns ["bir", "iki", "uc"]
 
 
 ####################################################
 ## 4. Fonksiyonlar
 ####################################################
 
+# "def" ile yeni fonksiyonlar oluşturabilirsiniz
+def topla(x, y):
+    print("x = {} ve y = {}".format(x, y))
+    return x + y    # Değer döndürmek için 'return' kullanmalısınız
 
-# Yeni bir fonksiyon oluşturmak için "def" kullanılır
-def add(x, y):
-    print "x is %s and y is %s" % (x, y)
-    return x + y    # Return values with a return statement
+# Fonksiyonu parametleri ile çağırıyoruz
+topla(5, 6)   # => çıktı "x = 5 ve y = 6" ve değer olarak 11 döndürür
 
-# Fonksiyonu parametre ile çağırmak
-add(5, 6) #=> prints out "x is 5 and y is 6" and returns 11
+# Bir diğer fonksiyon çağırma yöntemi de anahtar değerleri ile belirtmek
+topla(y=6, x=5)   # Anahtar değeri belirttiğiniz için parametre sıralaması önemsiz.
 
-# Diğer bir yol fonksiyonları anahtar argümanları ile çağırmak
-add(y=6, x=5)   # Anahtar argümanlarının sırası farklı da olabilir
+# Sınırsız sayıda argüman da alabilirsiniz
+def argumanlar(*argumanlar):
+    return argumanlar
 
-# Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz
-def varargs(*args):
-    return args
+argumanlar(1, 2, 3)   # => (1, 2, 3)
 
-varargs(1, 2, 3) #=> (1,2,3)
+# Parametrelerin anahtar değerlerini almak isterseniz
+def anahtar_par(**anahtarlar):
+    return anahtar
 
-# Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da 
-# tanımlayabilirsiniz.
-def keyword_args(**kwargs):
-    return kwargs
+# Çalıştırdığımızda
+anahtar_par(anah1="deg1", anah2="deg2")   # => {"anah1": "deg1", "anah2": "deg2"}
 
-# Şu şekilde kullanılacaktır
-keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
 
-# Eğer isterseniz ikisini aynı anda da yapabilirsiniz
-def all_the_args(*args, **kwargs):
-    print args
-    print kwargs
+# İsterseniz, bu ikisini birden kullanabilirsiniz
+def tum_argumanlar(*argumanlar, **anahtarla):
+    print(argumanlar)
+    print(anahtarla)
 """
-all_the_args(1, 2, a=3, b=4) prints:
+tum_argumanlar(1, 2, a=3, b=4) çıktı:
     (1, 2)
     {"a": 3, "b": 4}
 """
 
-# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz!
-# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın.
-args = (1, 2, 3, 4)
-kwargs = {"a": 3, "b": 4}
-all_the_args(*args) # foo(1, 2, 3, 4) ile eşit
-all_the_args(**kwargs) # foo(a=3, b=4) ile eşit
-all_the_args(*args, **kwargs) # foo(1, 2, 3, 4, a=3, b=4) ile eşit
-
-# Python first-class fonksiyonlara sahiptir
-def create_adder(x):
-    def adder(y):
-        return x + y
-    return adder
+# Fonksiyonu çağırırken de aynısını kullanabilirsiniz
+argumanlar = (1, 2, 3, 4)
+anahtarla = {"a": 3, "b": 4}
+tum_argumanlar(*argumanlar)   # = foo(1, 2, 3, 4)
+tum_argumanlar(**anahtarla)   # = foo(a=3, b=4)
+tum_argumanlar(*argumanlar, **anahtarla)   # = foo(1, 2, 3, 4, a=3, b=4)
+
+
+# Fonksiyonlarda kullanacağımız bir değişken oluşturalım                                  
+x = 5
+
+def belirleX(sayi):
+    # Fonksiyon içerisindeki x ile global tanımladığımız x aynı değil
+    x = sayi # => 43
+    print (x) # => 43
+    
+def globalBelirleX(sayi):
+    global x
+    print (x) # => 5
+    x = sayi # global olan x değişkeni artık 6
+    print (x) # => 6
+
+belirleX(43)
+globalBelirleX(6)
 
-add_10 = create_adder(10)
-add_10(3) #=> 13
 
-# Anonymous fonksiyonlar da vardır
-(lambda x: x > 2)(3) #=> True
+# Sınıf fonksiyonları oluşturma
+def toplama_olustur(x):
+    def topla(y):
+        return x + y
+    return topla
+
+ekle_10 = toplama_olustur(10)
+ekle_10(3)   # => 13
 
-# Dahili yüksek seviye fonksiyonlar vardır
-map(add_10, [1,2,3]) #=> [11, 12, 13]
-filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+# Bilinmeyen fonksiyon
+(lambda x: x > 2)(3)   # => True
 
-# Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz. 
-[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
-[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+# TODO - Fix for iterables
+# Belirli sayıdan yükseğini alma fonksiyonu
+map(ekle_10, [1, 2, 3])   # => [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
 
+# Filtreleme işlemi için liste comprehensions da kullanabiliriz
+[ekle_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
 
 ####################################################
 ## 5. Sınıflar
 ####################################################
 
-# We subclass from object to get a class.
-class Human(object):
-    
-    # Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır.
-    species = "H. sapiens"
-
-    # Basic initializer
-    def __init__(self, name):
-        # Metoda gelen argümanın değerini sınıfın elemanı olan "name" 
-        # değişkenine atama
-        self.name = name
-
-    # Bir instance metodu. Tüm metodlar ilk argüman olarak "self" 
-    # parametresini alır
-    def say(self, msg):
-       return "%s: %s" % (self.name, msg)
-
-    # Bir sınıf metodu tüm "instance"lar arasında paylaşılır
-    # İlk argüman olarak sınıfı çağırarak çağrılırlar
+
+# Sınıf oluşturmak için objeden alt sınıf oluşturacağız.
+class Insan(object):
+
+    # Sınıf değeri. Sınıfın tüm nesneleri tarafından kullanılabilir
+    tur = "H. sapiens"
+
+    # Basit başlatıcı, Sınıf çağrıldığında tetiklenecektir.
+    # Dikkat edin, iki adet alt çizgi(_) bulunmakta. Bunlar
+    # python tarafından tanımlanan isimlerdir. 
+    # Kendinize ait bir fonksiyon oluştururken __fonksiyon__ kullanmayınız!
+    def __init__(self, isim):
+        # Parametreyi sınıfın değerine atayalım
+        self.isim = isim
+
+    # Bir metot. Bütün metotlar ilk parametre olarak "self "alır.
+    def soyle(self, mesaj):
+        return "{isim}: {mesaj}".format(isim=self.isim, mesaj=mesaj)
+
+    # Bir sınıf metotu bütün nesnelere paylaştırılır
+    # İlk parametre olarak sınıf alırlar
     @classmethod
-    def get_species(cls):
-        return cls.species
+    def getir_tur(snf):
+        return snf.tur
 
-    # Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır
+    # Bir statik metot, sınıf ve nesnesiz çağrılır
     @staticmethod
     def grunt():
         return "*grunt*"
 
 
-# Bir sınıf örneği oluşturmak
-i = Human(name="Ian")
-print i.say("hi")     # "Ian: hi" çıktısı verir
+# Sınıfı çağıralım
+i = Insan(isim="Ahmet")
+print(i.soyle("merhaba"))     # çıktı "Ahmet: merhaba"
 
-j = Human("Joel")
-print j.say("hello")  # "Joel: hello" çıktısı verir
+j = Insan("Ali")
+print(j.soyle("selam"))  # çıktı "Ali: selam"
 
-# Sınıf metodunu çağıralım
-i.get_species() #=> "H. sapiens"
+# Sınıf metodumuzu çağıraim
+i.getir_tur()   # => "H. sapiens"
 
-# Paylaşılan sınıf özellik değiştirelim.
-Human.species = "H. neanderthalensis"
-i.get_species() #=> "H. neanderthalensis"
-j.get_species() #=> "H. neanderthalensis"
+# Paylaşılan değeri değiştirelim
+Insan.tur = "H. neanderthalensis"
+i.getir_tur()   # => "H. neanderthalensis"
+j.getir_tur()   # => "H. neanderthalensis"
 
-# Statik metodu çağırma
-Human.grunt() #=> "*grunt*"
+# Statik metodumuzu çağıralım
+Insan.grunt()   # => "*grunt*"
 
 
 ####################################################
-## 6. Modüller
+## 6. Moduller
 ####################################################
 
-# Modülleri sayfaya dahil edebilirsiniz
+# Modülleri içe aktarabilirsiniz
 import math
-print math.sqrt(16) #=> 4
+print(math.sqrt(16))  # => 4.0
 
-# Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
+# Modülden belirli bir fonksiyonları alabilirsiniz
 from math import ceil, floor
-print ceil(3.7)  #=> 4.0
-print floor(3.7) #=> 3.0
+print(ceil(3.7))  # => 4.0
+print(floor(3.7))   # => 3.0
 
-# Modüldeki tüm fonksiyonları dahil edebilirsiniz
-# Uyarı: bu önerilmez
+# Modüldeki tüm fonksiyonları içe aktarabilirsiniz
+# Dikkat: bunu yapmanızı önermem.
 from math import *
 
-# Modülün adını kısaltabilirsiniz
+# Modül isimlerini değiştirebilirsiniz.
+# Not: Modül ismini kısaltmanız çok daha iyi olacaktır
 import math as m
-math.sqrt(16) == m.sqrt(16) #=> True
+math.sqrt(16) == m.sqrt(16)   # => True
 
-# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül 
-# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı
-# aynı olmalıdır.
+# Python modulleri aslında birer python dosyalarıdır.
+# İsterseniz siz de yazabilir ve içe aktarabilirsiniz Modulün
+# ismi ile dosyanın ismi aynı olacaktır.
 
-# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz.
+# Moduldeki fonksiyon ve değerleri öğrenebilirsiniz.
 import math
 dir(math)
 
 
+####################################################
+## 7. Gelişmiş
+####################################################
+
+# Oluşturucular uzun uzun kod yazmamanızı sağlayacak ve yardımcı olacaktır
+def kare_sayilar(nesne):
+    for i in nesne:
+        yield i + i
+
+# Bir oluşturucu(generator) değerleri anında oluşturur.
+# Bir seferde tüm değerleri oluşturup göndermek yerine teker teker her oluşumdan
+# sonra geri döndürür.  Bu demektir ki, kare_sayilar fonksiyonumuzda 15'ten büyük
+# değerler işlenmeyecektir.
+# Not: range() da bir oluşturucu(generator)dur. 1-900000000 arası bir liste yapmaya çalıştığınızda
+# çok fazla vakit alacaktır.
+# Python tarafından belirlenen anahtar kelimelerden kaçınmak için basitçe alt çizgi(_) kullanılabilir. 
+range_ = range(1, 900000000)
+# kare_sayilar'dan dönen değer 30'a ulaştığında durduralım
+for i in kare_sayilar(range_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Dekoratörler
+# Bu örnekte,
+# Eğer lutfen_soyle True ise dönen değer değişecektir.
+from functools import wraps
 
+
+def yalvar(hedef_fonksiyon):
+    @wraps(hedef_fonksiyon)
+    def metot(*args, **kwargs):
+        msj, lutfen_soyle = hedef_fonksiyon(*args, **kwargs)
+        if lutfen_soyle:
+            return "{} {}".format(msj, "Lütfen! Artık dayanamıyorum :(")
+        return msj
+
+    return metot
+
+
+@yalvar
+def soyle(lutfen_soyle=False):
+    msj = "Bana soda alır mısın?"
+    return msj, lutfen_soyle
+
+
+print(soyle())  # Bana soda alır mısın?
+print(soyle(lutfen_soyle=True))  # Ban soda alır mısın? Lutfen! Artık dayanamıyorum :(
 ```
 
-## Daha fazlası için hazır mısınız?
+## Daha Fazlasına Hazır Mısınız?
 
-### Ücretsiz Dökümanlar
+### Ücretsiz Online
 
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
-* [The Official Docs](http://docs.python.org/2.6/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [Python Module of the Week](http://pymotw.com/2/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
+* [Python 3 Computer Science Circles](http://cscircles.cemc.uwaterloo.ca/)
 
-### Dead Tree
+### Kitaplar
 
 * [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
 * [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
 * [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
deleted file mode 100644
index e53d5568..00000000
--- a/tr-tr/python3-tr.html.markdown
+++ /dev/null
@@ -1,640 +0,0 @@
----
-language: python3
-contributors:
-    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
-    - ["Steven Basart", "http://github.com/xksteven"]
-    - ["Andre Polykanine", "https://github.com/Oire"]
-    - ["Andre Polykanine", "https://github.com/Oire"]
-translators:
-    - ["Eray AYDIN", "http://erayaydin.me/"]
-lang: tr-tr
-filename: learnpython3-tr.py
----
-
-Python,90ların başlarında Guido Van Rossum tarafından oluşturulmuştur. En popüler olan dillerden biridir. Beni Python'a aşık eden sebep onun syntax beraklığı. Çok basit bir çalıştırılabilir söz koddur.
-
-Not: Bu makale Python 3 içindir. Eğer Python 2.7 öğrenmek istiyorsanız [burayı](http://learnxinyminutes.com/docs/python/) kontrol edebilirsiniz.
-
-```python
-
-# Tek satırlık yorum satırı kare(#) işareti ile başlamaktadır.
-
-""" Çok satırlı olmasını istediğiniz yorumlar
-    üç adet tırnak(") işareti ile
-    yapılmaktadır
-"""
-
-####################################################
-## 1. Temel Veri Türleri ve Operatörler
-####################################################
-
-# Sayılar
-3  # => 3
-
-# Tahmin edebileceğiniz gibi matematik
-1 + 1  # => 2
-8 - 1  # => 7
-10 * 2  # => 20
-
-# Bölme işlemi varsayılan olarak onluk döndürür
-35 / 5  # => 7.0
-
-# Tam sayı bölmeleri, pozitif ve negatif sayılar için aşağıya yuvarlar
-5 // 3     # => 1
-5.0 // 3.0 # => 1.0 # onluklar için de bu böyledir
--5 // 3  # => -2
--5.0 // 3.0 # => -2.0
-
-# Onluk kullanırsanız, sonuç da onluk olur
-3 * 2.0 # => 6.0
-
-# Kalan operatörü
-7 % 3 # => 1
-
-# Üs (2 üzeri 4)
-2**4 # => 16
-
-# Parantez ile önceliği değiştirebilirsiniz
-(1 + 3) * 2  # => 8
-
-# Boolean(Doğru-Yanlış) değerleri standart
-True
-False
-
-# 'değil' ile terse çevirme
-not True  # => False
-not False  # => True
-
-# Boolean Operatörleri
-# "and" ve "or" büyük küçük harf duyarlıdır
-True and False #=> False
-False or True #=> True
-
-# Bool operatörleri ile sayı kullanımı
-0 and 2 #=> 0
--5 or 0 #=> -5
-0 == False #=> True 
-2 == True #=> False 
-1 == True #=> True
-
-# Eşitlik kontrolü ==
-1 == 1  # => True
-2 == 1  # => False
-
-# Eşitsizlik Kontrolü !=
-1 != 1  # => False
-2 != 1  # => True
-
-# Diğer karşılaştırmalar
-1 < 10  # => True
-1 > 10  # => False
-2 <= 2  # => True
-2 >= 2  # => True
-
-# Zincirleme şeklinde karşılaştırma da yapabilirsiniz!
-1 < 2 < 3  # => True
-2 < 3 < 2  # => False
-
-# Yazı(Strings) " veya ' işaretleri ile oluşturulabilir
-"Bu bir yazı."
-'Bu da bir yazı.'
-
-# Yazılar da eklenebilir! Fakat bunu yapmanızı önermem.
-"Merhaba " + "dünya!"  # => "Merhaba dünya!"
-
-# Bir yazı(string) karakter listesi gibi işlenebilir
-"Bu bir yazı"[0]  # => 'B'
-
-# .format ile yazıyı biçimlendirebilirsiniz, şu şekilde:
-"{} da ayrıca {}".format("yazılar", "işlenebilir")
-
-# Biçimlendirme işleminde aynı argümanı da birden fazla kullanabilirsiniz.
-"{0} çeviktir, {0} hızlıdır, {0} , {1} üzerinden atlayabilir".format("Ahmet", "şeker çubuğu")
-#=> "Ahmet çeviktir, Ahmet hızlıdır, Ahmet , şeker çubuğu üzerinden atlayabilir"
-
-# Argümanın sırasını saymak istemiyorsanız, anahtar kelime kullanabilirsiniz.
-"{isim} yemek olarak {yemek} istiyor".format(isim="Ahmet", yemek="patates") #=> "Ahmet yemek olarak patates istiyor"
-
-# Eğer Python 3 kodunuz ayrıca Python 2.5 ve üstünde çalışmasını istiyorsanız, 
-# eski stil formatlamayı kullanabilirsiniz:
-"%s bu %s yolla da %s" % ("yazılar", "eski", "biçimlendirilebilir")
-
-
-# Hiçbir şey(none) da bir objedir
-None  # => None
-
-# Bir değerin none ile eşitlik kontrolü için "==" sembolünü kullanmayın
-# Bunun yerine "is" kullanın. Obje türünün eşitliğini kontrol edecektir.
-"vb" is None  # => False
-None is None  # => True
-
-# None, 0, ve boş yazılar/listeler/sözlükler hepsi False değeri döndürü.
-# Diğer veriler ise True değeri döndürür
-bool(0)  # => False
-bool("")  # => False
-bool([]) #=> False
-bool({}) #=> False
-
-
-####################################################
-## 2. Değişkenler ve Koleksiyonlar
-####################################################
-
-# Python bir yazdırma fonksiyonuna sahip
-print("Ben Python. Tanıştığıma memnun oldum!")
-
-# Değişkenlere veri atamak için önce değişkeni oluşturmanıza gerek yok. 
-# Düzenli bir değişken için hepsi_kucuk_ve_alt_cizgi_ile_ayirin
-bir_degisken = 5
-bir_degisken  # => 5
-
-# Önceden tanımlanmamış değişkene erişmek hata oluşturacaktır.
-# Kontrol akışları başlığından hata kontrolünü öğrenebilirsiniz.
-bir_bilinmeyen_degisken  # NameError hatası oluşturur
-
-# Listeler ile sıralamaları tutabilirsiniz
-li = []
-# Önceden doldurulmuş listeler ile başlayabilirsiniz
-diger_li = [4, 5, 6]
-
-# 'append' ile listenin sonuna ekleme yapabilirsiniz
-li.append(1)    # li artık [1] oldu
-li.append(2)    # li artık [1, 2] oldu
-li.append(4)    # li artık [1, 2, 4] oldu
-li.append(3)    # li artık [1, 2, 4, 3] oldu
-# 'pop' ile listenin son elementini kaldırabilirsiniz
-li.pop()        # => 3 ve li artık [1, 2, 4]
-# Çıkarttığımız tekrardan ekleyelim
-li.append(3)    # li yeniden [1, 2, 4, 3] oldu.
-
-# Dizi gibi listeye erişim sağlayın
-li[0]  # => 1
-# Son elemente bakın
-li[-1]  # => 3
-
-# Listede olmayan bir elemente erişim sağlamaya çalışmak IndexError hatası oluşturur
-li[4]  # IndexError hatası oluşturur
-
-# Bir kısmını almak isterseniz.
-li[1:3]  # => [2, 4]
-# Başlangıç belirtmezseniz
-li[2:]  # => [4, 3]
-# Sonu belirtmesseniz
-li[:3]  # => [1, 2, 4]
-# Her ikişer objeyi seçme
-li[::2]   # =>[1, 4]
-# Listeyi tersten almak
-li[::-1]   # => [3, 4, 2, 1]
-# Kombinasyonları kullanarak gelişmiş bir şekilde listenin bir kısmını alabilirsiniz
-# li[baslangic:son:adim]
-
-# "del" ile isteğe bağlı, elementleri listeden kaldırabilirsiniz
-del li[2]   # li artık [1, 2, 3] oldu
-
-# Listelerde de ekleme yapabilirsiniz
-# Not: değerler üzerinde değişiklik yapılmaz.
-li + diger_li   # => [1, 2, 3, 4, 5, 6] 
-
-# Listeleri birbirine bağlamak için "extend()" kullanılabilir
-li.extend(diger_li)   #  li artık [1, 2, 3, 4, 5, 6] oldu
-
-# Listedeki bir elementin olup olmadığı kontrolü "in" ile yapılabilir
-1 in li   # => True
-
-# Uzunluğu öğrenmek için "len()" kullanılabilir
-len(li)   # => 6
-
-
-# Tüpler listeler gibidir fakat değiştirilemez.
-tup = (1, 2, 3)
-tup[0]   # => 1
-tup[0] = 3  # TypeError hatası oluşturur
-
-# Diğer liste işlemlerini tüplerde de uygulayabilirsiniz
-len(tup)   # => 3
-tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
-tup[:2]   # => (1, 2)
-2 in tup   # => True
-
-# Tüpleri(veya listeleri) değişkenlere açabilirsiniz
-a, b, c = (1, 2, 3)     # 'a' artık 1, 'b' artık 2 ve 'c' artık 3
-# Eğer parantez kullanmazsanız varsayılan oalrak tüpler oluşturulur
-d, e, f = 4, 5, 6
-# 2 değeri birbirine değiştirmek bu kadar kolay
-e, d = d, e     # 'd' artık 5 ve 'e' artık 4
-
-
-# Sözlükler anahtar kodlarla verileri tutar
-bos_sozl = {}
-# Önceden doldurulmuş sözlük oluşturma
-dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
-
-# Değere bakmak için [] kullanalım
-dolu_sozl["bir"]   # => 1
-
-# Bütün anahtarları almak için  "keys()" kullanılabilir. 
-# Listelemek için list() kullanacağınız çünkü dönen değerin işlenmesi gerekiyor. Bu konuya daha sonra değineceğiz.
-# Not - Sözlük anahtarlarının sıralaması kesin değildir.
-# Beklediğiniz çıktı sizinkiyle tam uyuşmuyor olabilir.
-list(dolu_sozl.keys())   # => ["uc", "iki", "bir"]
-
-
-# Tüm değerleri almak için "values()" kullanacağız. Dönen değeri biçimlendirmek için de list() kullanmamız gerekiyor
-# Not - Sıralama değişebilir.
-list(dolu_sozl.values())   # => [3, 2, 1]
-
-
-# Bir anahtarın sözlükte olup olmadığını "in" ile kontrol edebilirsiniz
-"bir" in dolu_sozl   # => True
-1 in dolu_sozl   # => False
-
-# Olmayan bir anahtardan değer elde etmek isterseniz KeyError sorunu oluşacaktır.
-dolu_sozl["dort"]   # KeyError hatası oluşturur
-
-# "get()" metodu ile değeri almaya çalışırsanız KeyError sorunundan kurtulursunuz
-dolu_sozl.get("bir")   # => 1
-dolu_sozl.get("dort")   # => None
-# "get" metoduna parametre belirterek değerin olmaması durumunda varsayılan bir değer döndürebilirsiniz.
-dolu_sozl.get("bir", 4)   # => 1
-dolu_sozl.get("dort", 4)   # => 4
-
-# "setdefault()" metodu sözlükte, belirttiğiniz anahtarın [olmaması] durumunda varsayılan bir değer atayacaktır
-dolu_sozl.setdefault("bes", 5)  # dolu_sozl["bes"] artık 5 değerine sahip
-dolu_sozl.setdefault("bes", 6)  # dolu_sozl["bes"] değişmedi, hala 5 değerine sahip
-
-# Sözlüğe ekleme
-dolu_sozl.update({"dort":4}) #=> {"bir": 1, "iki": 2, "uc": 3, "dort": 4}
-#dolu_sozl["dort"] = 4  #sözlüğe eklemenin bir diğer yolu
-
-# Sözlükten anahtar silmek için 'del' kullanılabilir
-del dolu_sozl["bir"]  # "bir" anahtarını dolu sözlükten silecektir
-
-
-# Setler ... set işte :D 
-bos_set = set()
-# Seti bir veri listesi ile de oluşturabilirsiniz. Evet, biraz sözlük gibi duruyor. Üzgünüm.
-bir_set = {1, 1, 2, 2, 3, 4}   # bir_set artık {1, 2, 3, 4}
-
-# Sete yeni setler ekleyebilirsiniz
-dolu_set = bir_set
-
-# Sete bir diğer öğe ekleme 
-dolu_set.add(5)   # dolu_set artık {1, 2, 3, 4, 5} oldu
-
-# Setlerin çakışan kısımlarını almak için '&' kullanabilirsiniz
-diger_set = {3, 4, 5, 6}
-dolu_set & diger_set   # => {3, 4, 5}
-
-# '|' ile aynı olan elementleri almayacak şekilde setleri birleştirebilirsiniz
-dolu_set | diger_set   # => {1, 2, 3, 4, 5, 6}
-
-# Farklılıkları almak için "-" kullanabilirsiniz
-{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
-
-# Bir değerin olup olmadığının kontrolü için "in" kullanılabilir
-2 in dolu_set   # => True
-10 in dolu_set   # => False
-
-
-####################################################
-## 3. Kontrol Akışları ve Temel Soyutlandırma
-####################################################
-
-# Bir değişken oluşturalım
-bir_degisken = 5
-
-# Burada bir "if" ifadesi var. Girinti(boşluk,tab) python için önemlidir!
-# çıktı olarak "bir_degisken 10 dan küçük" yazar
-if bir_degisken > 10:
-    print("bir_degisken 10 dan büyük")
-elif bir_degisken < 10:    # Bu 'elif' ifadesi zorunlu değildir.
-    print("bir_degisken 10 dan küçük")
-else:                  # Bu ifade de zorunlu değil.
-    print("bir_degisken değeri 10")
-
-
-"""
-Döngülerle lsiteleri döngüye alabilirsiniz
-çıktı:
-    köpek bir memeli hayvandır
-    kedi bir memeli hayvandır
-    fare bir memeli hayvandır
-"""
-for hayvan in ["köpek", "kedi, "fare"]:
-    # format ile kolayca yazıyı biçimlendirelim
-    print("{} bir memeli hayvandır".format(hayvan))
-
-"""
-"range(sayi)" bir sayı listesi döndür
-0'dan belirttiğiniz sayıyıa kadar
-çıktı:
-    0
-    1
-    2
-    3
-"""
-for i in range(4):
-    print(i)
-
-"""
-'While' döngüleri koşul çalıştıkça işlemleri gerçekleştirir.
-çıktı:
-    0
-    1
-    2
-    3
-"""
-x = 0
-while x < 4:
-    print(x)
-    x += 1  # Uzun hali x = x + 1
-
-# Hataları kontrol altına almak için try/except bloklarını kullanabilirsiniz
-try:
-    # Bir hata oluşturmak için "raise" kullanabilirsiniz
-    raise IndexError("Bu bir index hatası")
-except IndexError as e:
-    pass    # Önemsiz, devam et.
-except (TypeError, NameError):
-    pass    # Çoklu bir şekilde hataları kontrol edebilirsiniz, tabi gerekirse.
-else:   # İsteğe bağlı bir kısım. Eğer hiçbir hata kontrol mekanizması desteklemiyorsa bu blok çalışacaktır
-    print("Her şey iyi!")   # IndexError, TypeError ve NameError harici bir hatada bu blok çalıştı
-
-# Temel Soyutlandırma, bir objenin işlenmiş halidir.
-# Aşağıdaki örnekte; Obje, range fonksiyonuna temel soyutlandırma gönderdi.
-
-dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
-temel_soyut = dolu_sozl.keys()
-print(temel_soyut) #=> range(1,10). Bu obje temel soyutlandırma arayüzü ile oluşturuldu
-
-# Temel Soyutlandırılmış objeyi döngüye sokabiliriz.
-for i in temel_soyut:
-    print(i)    # Çıktısı: bir, iki, uc
-
-# Fakat, elementin anahtarına değerine.
-temel_soyut[1]  # TypeError hatası!
-
-# 'iterable' bir objenin nasıl temel soyutlandırıldığıdır.
-iterator = iter(temel_soyut)
-
-# 'iterator' o obje üzerinde yaptığımız değişiklikleri hatırlayacaktır
-# Bir sonraki objeyi almak için __next__ fonksiyonunu kullanabilirsiniz.
-iterator.__next__()  #=> "bir"
-
-# Bir önceki __next__ fonksiyonumuzu hatırlayıp bir sonraki kullanımda bu sefer ondan bir sonraki objeyi döndürecektir
-iterator.__next__()  #=> "iki"
-iterator.__next__()  #=> "uc"
-
-# Bütün nesneleri aldıktan sonra bir daha __next__ kullanımınızda, StopIterator hatası oluşturacaktır.
-iterator.__next__() # StopIteration hatası
-
-# iterator'deki tüm nesneleri almak için list() kullanabilirsiniz.
-list(dolu_sozl.keys())  #=> Returns ["bir", "iki", "uc"]
-
-
-####################################################
-## 4. Fonksiyonlar
-####################################################
-
-# "def" ile yeni fonksiyonlar oluşturabilirsiniz
-def topla(x, y):
-    print("x = {} ve y = {}".format(x, y))
-    return x + y    # Değer döndürmek için 'return' kullanmalısınız
-
-# Fonksiyonu parametleri ile çağırıyoruz
-topla(5, 6)   # => çıktı "x = 5 ve y = 6" ve değer olarak 11 döndürür
-
-# Bir diğer fonksiyon çağırma yöntemi de anahtar değerleri ile belirtmek
-topla(y=6, x=5)   # Anahtar değeri belirttiğiniz için parametre sıralaması önemsiz.
-
-# Sınırsız sayıda argüman da alabilirsiniz
-def argumanlar(*argumanlar):
-    return argumanlar
-
-argumanlar(1, 2, 3)   # => (1, 2, 3)
-
-# Parametrelerin anahtar değerlerini almak isterseniz
-def anahtar_par(**anahtarlar):
-    return anahtar
-
-# Çalıştırdığımızda
-anahtar_par(anah1="deg1", anah2="deg2")   # => {"anah1": "deg1", "anah2": "deg2"}
-
-
-# İsterseniz, bu ikisini birden kullanabilirsiniz
-def tum_argumanlar(*argumanlar, **anahtarla):
-    print(argumanlar)
-    print(anahtarla)
-"""
-tum_argumanlar(1, 2, a=3, b=4) çıktı:
-    (1, 2)
-    {"a": 3, "b": 4}
-"""
-
-# Fonksiyonu çağırırken de aynısını kullanabilirsiniz
-argumanlar = (1, 2, 3, 4)
-anahtarla = {"a": 3, "b": 4}
-tum_argumanlar(*argumanlar)   # = foo(1, 2, 3, 4)
-tum_argumanlar(**anahtarla)   # = foo(a=3, b=4)
-tum_argumanlar(*argumanlar, **anahtarla)   # = foo(1, 2, 3, 4, a=3, b=4)
-
-
-# Fonksiyonlarda kullanacağımız bir değişken oluşturalım                                  
-x = 5
-
-def belirleX(sayi):
-    # Fonksiyon içerisindeki x ile global tanımladığımız x aynı değil
-    x = sayi # => 43
-    print (x) # => 43
-    
-def globalBelirleX(sayi):
-    global x
-    print (x) # => 5
-    x = sayi # global olan x değişkeni artık 6
-    print (x) # => 6
-
-belirleX(43)
-globalBelirleX(6)
-
-
-# Sınıf fonksiyonları oluşturma
-def toplama_olustur(x):
-    def topla(y):
-        return x + y
-    return topla
-
-ekle_10 = toplama_olustur(10)
-ekle_10(3)   # => 13
-
-# Bilinmeyen fonksiyon
-(lambda x: x > 2)(3)   # => True
-
-# TODO - Fix for iterables
-# Belirli sayıdan yükseğini alma fonksiyonu
-map(ekle_10, [1, 2, 3])   # => [11, 12, 13]
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
-
-# Filtreleme işlemi için liste comprehensions da kullanabiliriz
-[ekle_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
-[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
-
-####################################################
-## 5. Sınıflar
-####################################################
-
-
-# Sınıf oluşturmak için objeden alt sınıf oluşturacağız.
-class Insan(obje):
-
-    # Sınıf değeri. Sınıfın tüm nesneleri tarafından kullanılabilir
-    tur = "H. sapiens"
-
-    # Basit başlatıcı, Sınıf çağrıldığında tetiklenecektir.
-    # Dikkat edin, iki adet alt çizgi(_) bulunmakta. Bunlar
-    # python tarafından tanımlanan isimlerdir. 
-    # Kendinize ait bir fonksiyon oluştururken __fonksiyon__ kullanmayınız!
-    def __init__(self, isim):
-        # Parametreyi sınıfın değerine atayalım
-        self.isim = isim
-
-    # Bir metot. Bütün metotlar ilk parametre olarak "self "alır.
-    def soyle(self, mesaj):
-        return "{isim}: {mesaj}".format(isim=self.name, mesaj=mesaj)
-
-    # Bir sınıf metotu bütün nesnelere paylaştırılır
-    # İlk parametre olarak sınıf alırlar
-    @classmethod
-    def getir_tur(snf):
-        return snf.tur
-
-    # Bir statik metot, sınıf ve nesnesiz çağrılır
-    @staticmethod
-    def grunt():
-        return "*grunt*"
-
-
-# Sınıfı çağıralım
-i = Insan(isim="Ahmet")
-print(i.soyle("merhaba"))     # çıktı "Ahmet: merhaba"
-
-j = Insan("Ali")
-print(j.soyle("selam"))  # çıktı "Ali: selam"
-
-# Sınıf metodumuzu çağıraim
-i.getir_tur()   # => "H. sapiens"
-
-# Paylaşılan değeri değiştirelim
-Insan.tur = "H. neanderthalensis"
-i.getir_tur()   # => "H. neanderthalensis"
-j.getir_tur()   # => "H. neanderthalensis"
-
-# Statik metodumuzu çağıralım
-Insan.grunt()   # => "*grunt*"
-
-
-####################################################
-## 6. Moduller
-####################################################
-
-# Modülleri içe aktarabilirsiniz
-import math
-print(math.sqrt(16))  # => 4.0
-
-# Modülden belirli bir fonksiyonları alabilirsiniz
-from math import ceil, floor
-print(ceil(3.7))  # => 4.0
-print(floor(3.7))   # => 3.0
-
-# Modüldeki tüm fonksiyonları içe aktarabilirsiniz
-# Dikkat: bunu yapmanızı önermem.
-from math import *
-
-# Modül isimlerini değiştirebilirsiniz.
-# Not: Modül ismini kısaltmanız çok daha iyi olacaktır
-import math as m
-math.sqrt(16) == m.sqrt(16)   # => True
-
-# Python modulleri aslında birer python dosyalarıdır.
-# İsterseniz siz de yazabilir ve içe aktarabilirsiniz Modulün
-# ismi ile dosyanın ismi aynı olacaktır.
-
-# Moduldeki fonksiyon ve değerleri öğrenebilirsiniz.
-import math
-dir(math)
-
-
-####################################################
-## 7. Gelişmiş
-####################################################
-
-# Oluşturucular uzun uzun kod yazmamanızı sağlayacak ve yardımcı olacaktır
-def kare_sayilar(nesne):
-    for i in nesne:
-        yield i + i
-
-# Bir oluşturucu(generator) değerleri anında oluşturur.
-# Bir seferde tüm değerleri oluşturup göndermek yerine teker teker her oluşumdan
-# sonra geri döndürür.  Bu demektir ki, kare_sayilar fonksiyonumuzda 15'ten büyük
-# değerler işlenmeyecektir.
-# Not: range() da bir oluşturucu(generator)dur. 1-900000000 arası bir liste yapmaya çalıştığınızda
-# çok fazla vakit alacaktır.
-# Python tarafından belirlenen anahtar kelimelerden kaçınmak için basitçe alt çizgi(_) kullanılabilir. 
-range_ = range(1, 900000000)
-# kare_sayilar'dan dönen değer 30'a ulaştığında durduralım
-for i in kare_sayilar(range_):
-    print(i)
-    if i >= 30:
-        break
-
-
-# Dekoratörler
-# Bu örnekte,
-# Eğer lutfen_soyle True ise dönen değer değişecektir.
-from functools import wraps
-
-
-def yalvar(hedef_fonksiyon):
-    @wraps(hedef_fonksiyon)
-    def metot(*args, **kwargs):
-        msj, lutfen_soyle = hedef_fonksiyon(*args, **kwargs)
-        if lutfen_soyle:
-            return "{} {}".format(msj, "Lütfen! Artık dayanamıyorum :(")
-        return msj
-
-    return metot
-
-
-@yalvar
-def soyle(lutfen_soyle=False):
-    msj = "Bana soda alır mısın?"
-    return msj, lutfen_soyle
-
-
-print(soyle())  # Bana soda alır mısın?
-print(soyle(lutfen_soyle=True))  # Ban soda alır mısın? Lutfen! Artık dayanamıyorum :(
-```
-
-## Daha Fazlasına Hazır Mısınız?
-
-### Ücretsiz Online
-
-* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
-* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
-* [Dive Into Python](http://www.diveintopython.net/)
-* [Ideas for Python Projects](http://pythonpracticeprojects.com)
-* [The Official Docs](http://docs.python.org/3/)
-* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
-* [Python Course](http://www.python-course.eu/index.php)
-* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
-* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
-* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
-* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
-* [Python 3 Computer Science Circles](http://cscircles.cemc.uwaterloo.ca/)
-
-### Kitaplar
-
-* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
-* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
-* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
-
diff --git a/tr-tr/pythonlegacy-tr.html.markdown b/tr-tr/pythonlegacy-tr.html.markdown
new file mode 100644
index 00000000..cd757625
--- /dev/null
+++ b/tr-tr/pythonlegacy-tr.html.markdown
@@ -0,0 +1,502 @@
+---
+language: Python 2 (legacy)
+filename: learnpythonlegacy-tr.py
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+translators:
+    - ["Haydar KULEKCI", "http://scanf.info/"]
+lang: tr-tr
+---
+Python Guido Van Rossum tarafından 90'ların başında yaratılmıştır. Şu anda 
+varolanlar arasında en iyi dillerden birisidir. Ben (Louie Dinh) Python
+dilinin syntax'ının belirginliğine aşığım. O basit olarak çalıştırılabilir 
+pseudocode'dur.
+
+Geri bildirimlerden son derece mutluluk duyarım! Bana [@louiedinh](http://twitter.com/louiedinh)
+adresinden ya da louiedinh [at] [google's email service] adresinden ulaşabilirsiniz.
+
+Çeviri için geri bildirimleri de [@kulekci](http://twitter.com/kulekci) 
+adresine yapabilirsiniz. 
+
+Not: Bu yazıdaki özellikler Python 2.7 için geçerlidir, ama Python 2.x için de 
+uygulanabilir. Python 3 için başka bir zaman tekrar bakınız. 
+
+
+```python
+# Tek satır yorum hash işareti ile başlar.
+""" Çoklu satır diziler üç tane çift tırnak 
+    arasında yazılır. Ve yorum olarak da 
+    kullanılabilir
+"""
+
+
+####################################################
+## 1. İlkel Veri Tipleri ve Operatörler
+####################################################
+
+# Sayılar
+3 #=> 3
+
+# Matematik beklediğiniz gibi
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız
+# sonuç otomatik olarak kırpılır. 
+5 / 2 #=> 2
+
+# Bölünme işlemini düzenlemek için kayan noktalı sayıları bilmeniz gerekir.
+2.0     # Bu bir kayan noktalı sayı
+11.0 / 4.0 #=> 2.75 ahhh...daha iyi
+
+# İşlem önceliğini parantezler ile sağlayabilirsiniz.
+(1 + 3) * 2 #=> 8
+
+# Boolean değerleri bilindiği gibi
+True
+False
+
+# not ile nagatif(mantıksal) değerini alma
+not True #=> False
+not False #=> True
+
+# Eşitlik ==
+1 == 1 #=> True
+2 == 1 #=> False
+
+# Eşitsizlik !=
+1 != 1 #=> False
+2 != 1 #=> True
+
+# Daha fazla karşılaştırma
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
+
+# Karşılaştırma zincirleme yapılabilir!
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
+
+# Karakter dizisi " veya ' ile oluşturulabilir
+"This is a string."
+'This is also a string.'
+
+# Karakter dizileri birbirleri ile eklenebilir
+"Hello " + "world!" #=> "Hello world!"
+
+# A string can be treated like a list of characters
+# Bir string'e karakter listesi gibi davranabilirsiniz. 
+"This is a string"[0] #=> 'T'
+
+# % karakter dizisini(string) formatlamak için kullanılır, bunun gibi:
+"%s can be %s" % ("strings", "interpolated")
+
+# String'leri formatlamanın yeni bir yöntem ise format metodudur. 
+# Bu metod tercih edilen yöntemdir.
+"{0} can be {1}".format("strings", "formatted")
+# Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz.
+"{name} wants to eat {food}".format(name="Bob", food="lasagna")
+
+# None bir objedir
+None #=> None
+
+# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın.
+# Onun yerine "is" kullanın.
+"etc" is None #=> False
+None is None  #=> True
+
+# 'is' operatörü obje kimliği için test etmektedir. Bu ilkel değerler
+# için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır.
+
+# None, 0 ve boş string/list'ler False olarak değerlendirilir.
+# Tüm eşitlikler True döner
+0 == False  #=> True
+"" == False #=> True
+
+
+####################################################
+## 2. Değişkenler ve Kolleksiyonlar
+####################################################
+
+# Ekrana yazdırma oldukça kolaydır.
+print "I'm Python. Nice to meet you!"
+
+
+# Değişkenlere bir değer atamadan önce tanımlamaya gerek yoktur.
+some_var = 5    # Değişken isimlerinde gelenek küçük karakter ve alt çizgi 
+                # kullanmaktır.
+some_var #=> 5
+
+# Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye 
+# çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla 
+# bilgi için kontrol akışı kısmına göz atınız.
+some_other_var  # isim hatası fırlatılır
+
+# isterseniz "if"i bir ifade gibi kullanabilirsiniz.
+"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
+
+# Listeler
+li = []
+# Önceden değerleri tanımlanmış listeler
+other_li = [4, 5, 6]
+
+# Bir listenin sonuna birşeyler eklemek
+li.append(1)    #li şu anda [1]
+li.append(2)    #li şu anda [1, 2]
+li.append(4)    #li şu anda [1, 2, 4]
+li.append(3)    #li şu anda [1, 2, 4, 3]
+# pop ile sondan birşeyler silmek
+li.pop()        #=> 3 and li is now [1, 2, 4]
+# Tekrar sonuna eklemek
+li.append(3)    # li is now [1, 2, 4, 3] again.
+
+# Dizi gibi listenin elemanlarına erişmek
+li[0] #=> 1
+# Son elemanın değerine ulaşmak
+li[-1] #=> 3
+
+# Listede bulunmayan bir index'teki elemana erişirken "IndexError" hatası 
+# fırlatılır 
+li[4] # IndexError fırlatılır
+
+# slice syntax'ı ile belli aralıktakı değerlere bakabilirsiniz.
+# (Açık ve kapalı aralıklıdır.)
+li[1:3] #=> [2, 4]
+# Başlangıcı ihmal etme
+li[2:] #=> [4, 3]
+# Sonu ihmal etme
+li[:3] #=> [1, 2, 4]
+
+# "del" ile istenilen bir elemanı listeden silmek
+del li[2] # li is now [1, 2, 3]
+
+# Listeleri birbiri ile birleştirebilirsiniz.
+li + other_li #=> [1, 2, 3, 4, 5, 6] - Not: li ve other_li yanlız bırakılır
+
+# extend ile listeleri birleştirmek
+li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]
+
+# bir değerin liste içerisinde varlığını "in" ile kontrol etmek
+1 in li #=> True
+
+# "len" ile listenin uzunluğunu bulmak
+len(li) #=> 6
+
+# Tüpler listeler gibidir sadece değişmezler(immutable)
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3  # TypeError fırlatılır.
+
+# Litelerde yapılanların hepsini tüplerde de yapılabilir
+len(tup) #=> 3
+tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tup[:2] #=> (1, 2)
+2 in tup #=> True
+
+# Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere
+# atanabilir
+a, b, c = (1, 2, 3)     # a şu anda 1, b şu anda 2 ve c şu anda 3
+# Eğer parantez kullanmaz iseniz tüpler varsayılan olarak oluşturulur
+d, e, f = 4, 5, 6
+# şimdi iki değeri değiş tokuş etmek çok kolaydır.
+e, d = d, e     # d şimdi 5 ve e şimdi 4
+
+
+# Sözlükler (Dictionaries) key-value saklanır.
+empty_dict = {}
+# Sözlüklere önceden değer atama örneği
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Değere ulaşmak için [] kullanılır
+filled_dict["one"] #=> 1
+
+# Tüm anahtarlara(key) "keys()" metodu ile ulaşılır
+filled_dict.keys() #=> ["three", "two", "one"]
+# Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir
+# Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir 
+
+# Tüm değerleri almak için "values()" kullanabilirsiniz.
+filled_dict.values() #=> [3, 2, 1]
+# Not - Sıralama ile ilgili anahtarlar ile aynı durum geçerlidir.
+
+# Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir
+"one" in filled_dict #=> True
+1 in filled_dict #=> False
+
+# Olmayan bir anahtar çağrıldığında KeyError fırlatılır.
+filled_dict["four"] # KeyError
+
+# "get()" metodu KeyError fırlatılmasını önler
+filled_dict.get("one") #=> 1
+filled_dict.get("four") #=> None
+# get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama
+# imknaı sağlar.
+filled_dict.get("one", 4) #=> 1
+filled_dict.get("four", 4) #=> 4
+
+# "setdefault()" metodu sözlüğe yeni bir key-value eşleşmesi eklemenin 
+# güvenli bir yoludur.
+filled_dict.setdefault("five", 5) #filled_dict["five"] is set to 5
+filled_dict.setdefault("five", 6) #filled_dict["five"] is still 5
+
+
+# Sets store ... well sets
+empty_set = set()
+# Bir demek değer ile bir "set" oluşturmak
+some_set = set([1,2,2,3,4]) # some_set is now set([1, 2, 3, 4])
+
+# Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir
+filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
+
+# Bir set'e daha fazla eleman eklemek
+filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5}
+
+# "&" işareti ile iki set'in kesişimlerini alınabilir
+other_set = {3, 4, 5, 6}
+filled_set & other_set #=> {3, 4, 5}
+
+# | işareti ile 
+filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
+
+# "-" işareti ile iki set'in farkları alınabilir
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz
+2 in filled_set #=> True
+10 in filled_set #=> False
+
+
+####################################################
+## 3. Akış Denetimi
+####################################################
+
+# Bir değişken oluşturmak
+some_var = 5
+
+# Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir!
+# "some_var is smaller than 10" yazdırılır.
+if some_var > 10:
+    print "some_var is totally bigger than 10."
+elif some_var < 10:    # elif ifadesi isteğe bağlıdır
+    print "some_var is smaller than 10."
+else:           # Bu da isteğe bağlıdır.
+    print "some_var is indeed 10."
+
+
+"""
+For döngüleri listeler üzerinde iterasyon yapar
+Ekrana yazdırılan:
+    dog is a mammal
+    cat is a mammal
+    mouse is a mammal
+"""
+for animal in ["dog", "cat", "mouse"]:
+    # Biçimlendirmeleri string'e katmak için % kullanabilirsiniz
+    print "%s is a mammal" % animal
+    
+"""
+"range(number)" ifadesi sıfırdan verilen sayıya kadar bir sayı listesi döner
+Ekrana yazdırılan:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print i
+
+"""
+While döngüsü koşul sağlanmayana kadar devam eder
+Ekrana yazdırılan:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print x
+    x += 1  # Shorthand for x = x + 1
+
+# try/except bloğu ile hatalar ayıklanabilir
+
+# Python 2.6 ve üstü için çalışacaktır:
+try:
+    # "raise" bir hata fırlatmak için kullanılabilir
+    raise IndexError("This is an index error")
+except IndexError as e:
+    pass    # Pass is just a no-op. Usually you would do recovery here.
+
+
+####################################################
+## 4. Fonksiyonlar
+####################################################
+
+
+# Yeni bir fonksiyon oluşturmak için "def" kullanılır
+def add(x, y):
+    print "x is %s and y is %s" % (x, y)
+    return x + y    # Return values with a return statement
+
+# Fonksiyonu parametre ile çağırmak
+add(5, 6) #=> prints out "x is 5 and y is 6" and returns 11
+
+# Diğer bir yol fonksiyonları anahtar argümanları ile çağırmak
+add(y=6, x=5)   # Anahtar argümanlarının sırası farklı da olabilir
+
+# Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+# Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da 
+# tanımlayabilirsiniz.
+def keyword_args(**kwargs):
+    return kwargs
+
+# Şu şekilde kullanılacaktır
+keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
+
+# Eğer isterseniz ikisini aynı anda da yapabilirsiniz
+def all_the_args(*args, **kwargs):
+    print args
+    print kwargs
+"""
+all_the_args(1, 2, a=3, b=4) prints:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz!
+# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args) # foo(1, 2, 3, 4) ile eşit
+all_the_args(**kwargs) # foo(a=3, b=4) ile eşit
+all_the_args(*args, **kwargs) # foo(1, 2, 3, 4, a=3, b=4) ile eşit
+
+# Python first-class fonksiyonlara sahiptir
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3) #=> 13
+
+# Anonymous fonksiyonlar da vardır
+(lambda x: x > 2)(3) #=> True
+
+# Dahili yüksek seviye fonksiyonlar vardır
+map(add_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+
+# Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz. 
+[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+
+####################################################
+## 5. Sınıflar
+####################################################
+
+# We subclass from object to get a class.
+class Human(object):
+    
+    # Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır.
+    species = "H. sapiens"
+
+    # Basic initializer
+    def __init__(self, name):
+        # Metoda gelen argümanın değerini sınıfın elemanı olan "name" 
+        # değişkenine atama
+        self.name = name
+
+    # Bir instance metodu. Tüm metodlar ilk argüman olarak "self" 
+    # parametresini alır
+    def say(self, msg):
+       return "%s: %s" % (self.name, msg)
+
+    # Bir sınıf metodu tüm "instance"lar arasında paylaşılır
+    # İlk argüman olarak sınıfı çağırarak çağrılırlar
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Bir sınıf örneği oluşturmak
+i = Human(name="Ian")
+print i.say("hi")     # "Ian: hi" çıktısı verir
+
+j = Human("Joel")
+print j.say("hello")  # "Joel: hello" çıktısı verir
+
+# Sınıf metodunu çağıralım
+i.get_species() #=> "H. sapiens"
+
+# Paylaşılan sınıf özellik değiştirelim.
+Human.species = "H. neanderthalensis"
+i.get_species() #=> "H. neanderthalensis"
+j.get_species() #=> "H. neanderthalensis"
+
+# Statik metodu çağırma
+Human.grunt() #=> "*grunt*"
+
+
+####################################################
+## 6. Modüller
+####################################################
+
+# Modülleri sayfaya dahil edebilirsiniz
+import math
+print math.sqrt(16) #=> 4.0
+
+# Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
+from math import ceil, floor
+print ceil(3.7)  #=> 4.0
+print floor(3.7) #=> 3.0
+
+# Modüldeki tüm fonksiyonları dahil edebilirsiniz
+# Uyarı: bu önerilmez
+from math import *
+
+# Modülün adını kısaltabilirsiniz
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül 
+# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı
+# aynı olmalıdır.
+
+# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz.
+import math
+dir(math)
+
+
+
+```
+
+## Daha fazlası için hazır mısınız?
+
+### Ücretsiz Dökümanlar
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [The Official Docs](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+
+### Dead Tree
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
diff --git a/tr-tr/ruby-tr.html.markdown b/tr-tr/ruby-tr.html.markdown
new file mode 100644
index 00000000..7bc21c83
--- /dev/null
+++ b/tr-tr/ruby-tr.html.markdown
@@ -0,0 +1,1598 @@
+---
+name: ruby
+language: ruby
+filename: learnruby-tr.rb
+contributors:
+  - ["Seçkin KÜKRER", "https://github.com/LeaveNhA"]
+lang: tr-tr
+---
+
+# Dile nazik bir giriş.
+
+## Ruby Nedir ?
+
+Ruby, doğrudan bir Google aramasıyla aklınızdakini bulmanız zor olabilir. İngilizce bu kelime, `Ruby` (IPA: ˈruːbi) "kırmızı taş" anlamına gelen Fransızca kökenli bir kelime olan `rubi`'den gelmektedir.
+
+Yaratıcısı tarafından, yine esinlenilen bir dil olarak ortaya çıkan `Ruby`, Perl, Smalltalk, Eiffel, Ada, Lisp programlama dillerinin en iyi özelliklerini almıştır. ! [İmperativ]() programlama mentalitesi üzerine kurmayı seçtiği bu teknoloji, günümüzde sektöründe öncü.
+
+
+## Tarihçe
+
+Ruby 1995’te halka duyurulduğundan beri, dünya çapında programcıların dikkatini çekmeye başlamıştır. 2006 Ruby’nin altın yılı olmuştur. Dünyanın en büyük şehirlerinde aktif kullanıcı grupları ve Ruby ile ilgili konferanslar gerçekleştirilmiştir.
+
+Daha sonraları `Ruby`, dünya çapında programlama dillerinin büyümesini ve popülaritesini ölçen dizinlerin (TIOBE dizini gibi) çoğunda ilk 10 içinde yer almıştır. Büyümenin çoğu, Ruby ile yazılmış yazılımların popülaritesiyle ilgilidir, özellikle de Ruby on Rails web çatısıyla.
+
+! [kaynak]()
+
+## Sektördeki Konumu ve Geleceği ?
+
+Çoğu uzmana göre, şu anda sadece `Rails` teknolojisi için bir betik dili olarak sıkışmış durumda.
+
+Bazıları ise, dilin kendi geleceğini, 2020 içinde yayınlanması planlanan `Ruby 3` ile sağlamlaştıracağını ve yeni imkanlar ve sektörek kullanım ve tercihler ile popüleritesinin artacağını düşünüyor.
+
+## Her Şey Nesne
+
+Matz'ın incelemiş olduğu diller sonucunda, teknik olarak en iyi sözdizimin kaynağını “Perl’den daha güçlü ama Python’dan daha nesneye yönelik bir betik dili” olarak tanımlamış.
+
+Her şeyin Nesne olarak görüldüğü bir programlama teknolojisi, bütünlük kavramı açısından herkese kucak açan bir pürüzsüzlük sunuyor. `Ruby`'nin neden tartışmasız, saf bir Nesne yönelimli bir programlama dili olduğuna dair örnekleri aşağıda vereceğim.
+
+## Diğer Gerçeklemeler
+
+- [JRuby](http://jruby.org/), JVM’in (Java Virtual Machine) üstünde çalışan Ruby’dir, JVM’in eniyileyen JIT derleyicisi, çöp toplayıcısı, eşzamanlı thread’leri, araç ekosistemi, ve muazzam sayıdaki kütüphanelerinden faydalanır.
+- [Rubinius](http://rubini.us/), ‘Ruby’da yazılmış Ruby’dir’. LLVM’in üstüne inşa edilmiştir ve ayrıca diğer dillerin üstüne inşa edebilecekleri şık bir sanal makine de sunar.
+- [TruffleRuby](https://github.com/oracle/truffleruby), GraalVM’in üstünde çalışan yüksek performanslı bir Ruby gerçeklemesidir.
+- [IronRuby](http://www.ironruby.net/), “.NET Web Çatısı’yla sıkı sıkıya bağlı” bir gerçeklemedir.
+
+Diğer gerçeklemeler için, lütfen ileri okumaya danışınız.
+
+```ruby
+# Bu karakter ile başlayan satırlar, yorum satırı olarak değerlendirilir.
+# Diğer yorum satırı tanımlamaları için tanımlamalar ve ifadeler kısmına danışın.
+
+## Örnek yapısı; bu örnek dosyadaki her Ruby ifadesi, Ruby yorumlayıcısı
+## tarafından yorumlanarak sonucu `=>` ifadesinin sağına yazılır.
+## örnek ifade #=> örnek sonuç
+## formatındadır.
+## Bazen satır aşımını önlemek için
+## örnek ifade
+## #=> örnek sonuç
+## şeklinde yer verilecektir.
+
+# --------------------------------
+# Veriler ve Temsilleri
+# --------------------------------
+
+## --
+## Sayılar:
+## --
+### Ruby, tamsayı veri tipini destekler. Sayısal değerlerin sisteminizdeki temsili
+### bu veri yapısıdır.
+
+# Tam sayı örneği.
+1453 #=> 1453 
+
+## Okunabilirlik için, binlik ya da ondalık kısmını `_` ile
+## ayırmak mümkündür ve bu karakter tümüyle görmezden gelinir.
+3_14 #=> 314
+
+## Negatif sayılar `-` ile başlıyor.
+-3750 #=> -3750
+
+## Oktal sayılar
+03603 #=> 1923
+
+## Onaltılık sayılar
+0x23B #=> 571
+
+## İkilik sayılar
+0b11110000011 #=> 1923
+
+## Büyük sayılar temsili
+12345678901234567890  #=> 12345678901234567890
+
+## Kayan noktalı sayılar
+
+## Bir kayan-noktalı/Ondalıklı sayı.
+3.14 #=> 3.14
+
+## Bilimsel notasyon
+1.0e3 #=> 1000.0
+
+## Bir ipucu,
+## üsten önce işaret!
+3e+9 #=> 3000000000.0
+
+## --
+# Mantıksal Değerler
+## --
+
+## Mantıksal doğru ifadesi.
+true #=> true
+
+## Mantıksal yanlış ifadesi.
+false #=> false
+
+## --
+# Metinler
+## --
+
+## Metin sabitleri
+'Bu, bir metin ifadesi.'
+
+## Kaçışlar için 
+'Kaçışlar için "\\"' #=> "Kaçışlar için \"\\\""
+
+## Alternatif ise çift tırnaklı ifadeler.
+"Bu da bir metin ifadesi."
+
+## Kaçışlarda farkı ise,
+"Kaçılar için '\\'" #=> "Kaçılar için '\\'"
+## bazı kaçış notasyonlarına gerek kalmaması.
+
+## Bazı notasyon karakterleri
+
+### Yeni Satır (New Line 0x0a)
+"\n" #=> "\n"
+
+### Boşluk (Space 0x20)
+"\s" #=> "\s"
+
+## --
+# Karakterler 
+## --
+
+## Basitçe önlerine soru işareti getirilmiş
+## tek karakter sabitleridir.
+?a #=> "a"
+
+
+## --
+# Semboller
+## --
+## Ruby'de semboller, temsilleri bakımından 
+## Clojure'daki semboller ile benzerlerdir.
+:sembol #=> :sembol
+
+## Kendileri, birinci sınıf değerdir.
+:türk.class #=> Symbol
+## Ve aynı zamanda Unicode desteği vardır. (1.9 sürümünden beri)
+
+
+## --
+# Diziler
+## --
+## Basitçe, Ruby dizileri birilerinden virgül ile ayrılmış,
+## değer veya değer sahibi referansların köşeli parantezler
+## ile çevrelenmesi ile oluşturulur. ([])
+[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+## Metinler için de durum aynı.
+["Mustafa", "Kemal", "ATATÜRK"] #=> ["Mustafa", "Kemal", "ATATÜRK"]
+
+## Aynı zamanda, Ruby dizileri tip bağımsız nesne ardışıklarıdır.
+[1881, "Mustafa", "Kemal", "ATATÜRK", 1923, "∞"]
+## Aynı zamanda Unicode destekler (1.9 sürümünden beri)
+
+## --
+# Eşlemeler
+## --
+## Ruby eşlemeleri, süslü parantezler içinde virgül ile ayrılan,
+## anahtar ve değer ikililieridir.
+
+## Bir tane de olabilir,
+{"izmir" => "kızları"} #=> {"izmir" => "kızları"}
+
+## Ya da, birden fazla...
+{"izmir" => "kızları", "paris" => "sokakları"} #=> {"izmir" => "kızları", "paris" => "sokakları"}
+
+## Aslında her değeri anahtar veya değer olarak
+## yerleştirmek mümkün.
+
+## Sembolleri,
+{:zafer => "30 Ağustos!"} #=> {:zafer=>"30 Ağustos!"}
+
+## Rakamları bile.
+{28101923 => "Efendiler, yarın Cumhuriyeti'i ilân edeceğiz!"}
+#=> {28101923=>"Efendiler, yarın Cumhuriyeti'i ilân edeceğiz!"}
+
+## Semboller için ufak bir sözdizimsel şekerleme mevcut ki,
+{istanbul: "beyefendi"} #=> {:istanbul=>"beyefendi"}
+## Bu kullanıma göre, sembol anahtarlar ile değerler arasına
+## `=>` yerine basitçe sembolün başına gelecek `:` sembolü
+## getiriliyor.
+
+
+## --
+# Aralıklar
+## --
+## Ruby aralıkları temeliyle başlangıç ve bitiş
+## değerleri arasındaki aralığın veriye dönüştürülmesi
+## için bir dil olanağıdır.
+
+## (başlangıç..bitiş) notasyonu kullanılabilir.
+(0..10) #=> 0..10
+## REPL'ın bize verdiği ifade sizi yanıltmasın, bu bir aralıktır.
+## Meraklılarıyla, dökümanın devamında içindeki değerleri
+## gezeceğiz.
+
+## Range.new notasyonu ile de ilklenebilirler.
+Range.new(0, 10) #=> 0..10
+
+## --
+# Düzenli İfadeler
+## --
+## İki / operatörünün ortasına tanımlanırlar.
+//.class #=> Regexp
+
+## Örnek bir düzenli ifade, a harfi için.
+/[a]/ #=> /[a]/
+
+# --------------------------------
+# Değelerin Manipüle edilmesi
+# --------------------------------
+
+## --
+## Rakamlar
+## --
+
+## Aritmatik, bildiğimiz şekilde.
+## !! infix notasyon
+
+235 + 1218 #=> 1453
+123 - 35 #=> 88
+2 * 2 #=> 4
+1 / 1 #=> 1
+
+## Bit tabanlı işlemler.
+2 & 5 #=> 0
+3 | 9 #=> 11
+2 ^ 5 #=> 7
+## Aslında C tipi ailesi dillerdeki gibi. Sezgisel bir yaklaşımla, hayatta kalınabilir.
+## Ama yine de dökümantasyona başvurulmasını tavsiye ederim.
+
+
+## --
+## Mantıksal
+## --
+
+## ! operatörü teklidir, ve aldığı değerin mantıksal tersini alır.
+!true #=> false
+!false #=> true
+
+
+## --
+## Metinler
+## --
+
+### Boş mu ?
+"".empty? #=> true
+
+### Bir bölümünü alalım.
+"Ölürüm TÜRKİYEM!".slice(7, 7) #=> "Türkiye"
+## Bir başka şekilde, indis notasyonu ile,
+"Ölürüm Türkiye'm!"[7, 7] #=> "Türkiye"
+
+## Küçük harfe dönüştürelim
+"LAY-LAY-LOM sana göre sevmeler...".downcase
+#=> "lay-lay-lom sana göre sevmeler..."
+
+## Büyük harfa dönüştürelim
+"beşiktaş".upcase #=> "BEŞIKTAŞ"
+
+## Karakterlerine ayıralım
+"BEŞİKTAŞ".chars #=> ["B", "E", "Ş", "İ", "K", "T", "A", "Ş"]
+
+## Çevrelemek için
+"Ahmet Mete IŞIKARA".center(30)
+#=> "      Ahmet Mete IŞIKARA      "
+
+## İçerik kontrolü için include metodu
+"aşk".include?(?a) #=> true
+## argümanı metin tipinde de verebilirdik, ama
+## yukarıdaki temsillerde gördüğümüz gibi,
+## yorumlayıcı, karakter sabitini metin olarak işliyor zaten.
+
+## Konumunu alalım.
+"Dayı".index("a") #=> 1
+## Elbette, tasarımında sağlıklı kararlar alınmış her
+## dil gibi, Ruby'de 0'dan saymaya başlıyor.
+
+## Metin yerleştirme yapalım
+"Ali Baba'nın x çiftliği var.".sub("x", "bir")
+#=> "Ali Baba'nın bir çiftliği var."
+
+## Birden fazla eşleşme için, değiştirme yapalım
+"Dal sarkar x kalkar, x kalkar dal sarkar.".gsub("x", "kartal")
+#=> "Dal sarkar kartal kalkar, kartal kalkar dal sarkar."
+
+## Düzenli ifadeler ile, cümledeki sesli harfleri değiştirelim.
+"Bir berber bir bere...".gsub(/[ie]/, "*")
+#=> "B*r b*rb*r b*r b*r*..."
+
+## Diğer işlevler için ileri okumadaki kaynağa başvurunuz.
+
+
+## --
+## Eşlemeler
+## --
+
+## basit bir eşleme ile başlayalım.
+{:boy => 1.74} #=> {:boy => 1.74}
+
+## Belirli bir anahtar, eşlememizde barınıyor mu diye
+## kontrol ediyoruz.
+{:boy => 1.74}.has_key? :boy
+#=> true
+## Parantezlerin yokluğu sizi yanıltmasın,
+## bu bir fonksiyon çağırısıdır.
+
+## Eşlemeden veri çekiyoruz
+{:boy => 1.74}.fetch :boy
+#=> 1.74
+
+## Eşlemelere veri ekliyoruz
+{:boy => 1.74}.merge!(kilo: 74)
+#=> {:boy=>1.74, :kilo=>74}
+
+## Anahtarlarımıza bakalım
+{:boy=>1.74, :kilo=>74}.keys
+#=> [:boy, :kilo]
+
+## Değerlerimize bakalım
+{:boy=>1.74, :kilo=>74}.values
+#=> [1.74, 74]
+
+## Dizi olarak almak istersek
+{:boy=>1.74, :kilo=>74}.to_a
+#=> [[:boy, 1.74], [:kilo, 74]]
+## Endişelenmeyin, dönüşümler için koca bir bölüm
+## ayırdım.
+
+
+## --
+## Diziler
+## --
+
+## Örnek bir dizi ile başlayalım.
+["Mustafa", "Kemal", "ATATÜRK"]
+#=> ["Mustafa", "Kemal", "ATATÜRK"]
+
+## İlk değeri alıyoruz
+["Mustafa", "Kemal", "ATATÜRK"].first
+#=> "Mustafa"
+
+## Son Değeri,
+["Mustafa", "Kemal", "ATATÜRK"].last
+#=> "ATATÜRK"
+
+## Indis araması için `fetch` metodu.
+["Mustafa", "Kemal", "ATATÜRK"].fetch 1
+#=> "Kemal"
+
+## Var olamyan bir indis ararsak hata alıyoruz.
+
+## Fakat seçimli ikinci argüman bize indisin
+## bulunamaması halinde döndürülecek değeri
+## belirleme imkanı veriyor.
+["Mustafa", "Kemal", "ATATÜRK"].fetch 20101927, "Nutuk"
+#=> "Nutuk"
+
+## Birden fazla değer almak için, slice metodunu
+## kullanabiliriz
+["Fatih", "Sultan", "Mehmet"].slice 1..2
+#=> ["Sultan", "Mehmet"]
+
+## Ya da, indis notasyonu da kullanılabilir.
+["Fatih", "Sultan", "Mehmet"][1..2]
+#=> ["Sultan", "Mehmet"]
+
+## Baştan n tane eleman almak için take metodunu kullanıyoruz
+["Fatih", "Sultan", "Mehmet"].take 2
+#=> ["Fatih", "Sultan"]
+
+## Rastgele bir dizi elemanı elde etmek için sample metodunu
+## kullanıyoruz
+["Fatih", "Sultan", "Mehmet"].sample
+#=> "Fatih"
+
+## `sample` metodu seçimli bir argüman kabul eder.
+## bu argüman rastgele istenen eleman sayısını temsil eder
+["Fatih", "Sultan", "Mehmet"].sample 2
+#=> ["Fatih", "Sultan"]
+
+## Aradığınız eleman, dizide var mı kontrolü için
+## include? metodu kullanılıyor
+["Fatih", "Sultan", "Mehmet"].include? "Fatih"
+#=> true
+
+## Dizinizdeki elemanları koşul dahilinde seçimlemek için
+## select metodunu kullanıyoruz
+["Fatih", "Sultan", "Mehmet"].select {|s| s.include? ?a}
+#=> ["Fatih", "Sultan"]
+## Süzme işleminin koşulu, a karakteri içeren nesneler için olumlu.
+## Not: filter metodu, select için bir takma addır.
+
+## Ters bir yöntem, süzgeçleme için ise;
+["Fatih", "Sultan", "Mehmet"].reject {|s| s.include? ?a}
+#=> ["Mehmet"]
+## koşulumuz aynıydı, seçimleme metodumuzu değiştirdik.
+
+### Yapısal düzenlemeler için:
+## Dizileri ters çevirmek,
+["Fatih", "Sultan", "Mehmet"].reverse
+#=> ["Mehmet", "Sultan", "Fatih"]
+
+## Sıralamak için sort metodu,
+["İş", "Aşk", "Para"].sort
+#=> ["Aşk", "Para", "İş"]
+
+## Ön koşulla sıralamak için,
+["İş", "Aşk", "Para"].sort {|a,b| b <=> a }
+#=> ["İş", "Para", "Aşk"]
+## Koşulumuz basitçe tersine sıralamak için bir tanımdır.
+## ileride karşılaştırma operatörlerini göreceğiz.
+
+## Tekrarlı elemanların temizlenmesi için
+[1,2,3,4,5,6,7,1,2,4,1,5,6,1,2,5].uniq
+#=> [1, 2, 3, 4, 5, 6, 7]
+
+## Dizilerin birleştirilmesi için
+[1,2] + [3,4]
+#=> [1, 2, 3, 4]
+## infix notasyon sizi yanıltmasın,
+## tasarımı gereği, her şey sınıflar ve metotlarına çağırım
+## olarak yürüyor.
+## Kanıtlayalım;
+[1,2].+([3,4])
+#=> [1, 2, 3, 4]
+
+## Peki ya aynı elemanları içerebilecek dizileri birleştirmek
+## istersek ?
+[1,2] | [2,3,4]
+#=> [1, 2, 3, 4]
+## | operatörü bizi, nihai sonuçtaki tekrarlı veriden koruyor.
+
+## Peki ya bir diziyi, eleman bazında diğeriyle 
+## süzmek istersek ?
+[1,2] - [2,3,4]
+#=> [1]
+## Notasyon sizi yanıltmasın, Küme gibi davranan bir dizi işlevi.
+
+### Veri Dönüşümleri için:
+## Dizideki her elemana uygulamak istediğiniz bir
+## dönüşümü, map metodu ile uygulayabilirsiniz,
+["Kontak İsmi",
+ "Kontak Telefon Numarası"].map {|element| "<label>#{element}</label>"}
+#=> ["<label>Kontak İsmi</label>", "<label>Kontak Telefon Numarası</label>"]
+## HTML konusu için yine LearnXinYminutes'e danışabilirsiniz.
+
+## Son elde ettiğimiz veriyi birleştirmek için,
+["<label>Kontak İsmi</label>",
+ "<label>Kontak Telefon Numarası</label>"].join ""
+#=> "<label>Kontak İsmi</label><label>Kontak Telefon Numarası</label>"
+
+## Veriyi indirgemek için ise reduce metodu kullanırız,
+["<label>Kontak İsmi</label>",
+ "<label>Kontak Telefon Numarası</label>"]
+ .reduce("") {|akümülatör, veri| akümülatör + veri}
+#=> "<label>Kontak İsmi</label><label>Kontak Telefon Numarası</label>"
+## Akümülatör, her operasyondan dönen ara-geçici değer.
+## Bu değeri, parantez içinde ilkledik,
+## eğer vermeseydik, dizinin ilk elemanı olacaktı.
+
+## Tabi, daha kolay bir yolu var;
+["<label>Kontak İsmi</label>", 
+ "<label>Kontak Telefon Numarası</label>"].reduce(:+)
+#=> "<label>Kontak İsmi</label><label>Kontak Telefon Numarası</label>"
+## reduce metodu, ikili bir operasyonu (akümülatör için metot!)
+## sembol olarak vermenize izin verir ve bu, reduce için
+## indirgeme fonksiyonu olarak kullanılır.
+
+## Nüansları olsa da, son üç Ruby çağırımı aynı sonucu vermektedir.
+
+
+## --
+## Semboller
+## --
+
+## Ruby sembolleri, çalışma zamanında değiştirilemezler.
+## Ama metinsel değerlerden semboller elde etmek mümkündür.
+## Bunu dönüşümler kısmında işlemek daha doğru olacak diye düşündüm.
+
+# --------------------------------
+# Dönüşümler
+# --------------------------------
+
+## --
+# Rakamlar 
+## --
+
+## Sayısal değerlerin diğer tiplere dönüşümü;
+
+## Sayısal -> Metinsel
+1923.to_s #=> "1923"
+
+## Sayısal -> Mantıksal
+!1923 #=> false
+## Farkedebileceğiniz gibi,
+## sayısal değerler, mantıksal doğru'ya değerlendiriliyor.
+
+## Sayısal -> Sembol
+## Maalesef, Ruby bile Sayısal değerden Sembol değerlerine
+## doğrudan dönüşüm için metot barındırmıyor.
+## Bunu yine de başarmak istersek, değeri önce
+## Metinsel'e dönüştürerek Sembol dönüşümü için hazırlarız.
+1923.to_s.to_sym
+#=> :"1923"
+
+## Sayısal -> Dizi | bölümlenerek
+## Yine doğrudan bir dönüşüm yoktur.
+## Böyle bir doğrudan dönüşüm teşvik de edilmez.
+## Ama ihtiyaç olabilecek bir dönüşüm.
+1923.to_s.split('')
+#=> ["1", "9", "2", "3"]
+## Öncelikle Metinsel dönüşüm yapılır, sonra
+## her bir karakter için ayrılır.
+## Yine her bir rakamı sayısal bir şekilde elde etmek için
+## her birini Metinsel'den Sayısal değere dönüştürecek
+## ifade aşağıdaki gibidir.
+1923.to_s.split('').map { |i| i.to_i }
+#=> [1, 9, 2, 3]
+
+
+## --
+# Mantıksal 
+## --
+
+## Mantıksal -> Metinsel
+true.to_s #=> "true"
+false.to_s #=> "false"
+
+## Mantıksal değeler için gerçeklenmiş başka bir dönüşüm
+## metodu olmadığı için, bu kısmı dilde ufak bir nüansa ayırmak
+## istedim.
+## Kaynak için ileri okumaya başvurunuz.
+
+## Hangi programlama dilinden gelirseniz gelin,
+## dilde doğruluk değerleri diye bir küme vardır.
+## Hangi değerlerin mantıksal doğru değerine dönüşeceği,
+## bu değer yerine geçebileceği
+## fikri üzerine kurulu bir küme.
+## Ve Ruby'de nil değeri, false dışında, mantıksal yanlış değerine çözümlenen tek şey.
+## Bu ön bilgi ile doyduysak, başlayalım.
+
+!!nil   #=> false
+!!false #=> false
+!!0     #=> true
+!!""    #=> true
+## Şimdi ne oldu burada ?
+## `!!` ifadesi; değilinin değili, yani kendisi. Tek bir farkla.
+## Verinin türü değiştiriliyor. Mantıksal olarak yorumlanıyor.
+## Yukarıda, nil ve false ifadeleri mantıksal olarak yanlış  olarak yorumlanıyor.
+## Diğerleri ise mantıksal doğru.
+
+
+## --
+# Metinsel 
+## --
+
+## Metinsel -> Sayısal
+## Öncelikle dilde ufak bir tuzağa dikkat çekmek isterim.
+"".to_i #=> 0
+"asd".to_i #=> 0
+## Sayısal yorumlaması geçersiz ve boş her metinsel değer,
+## 0 rakamına değerlendirilir.
+
+## Başarılı bir dönüşüm,
+"1234".to_i #=> 1234
+
+## Sayı sistemini belirleyebileceğiniz seçimli bir argüman
+## kabul ediyor, to_i metodu.
+"1234".to_i 5 #=> 194
+## 1234 sayısının, beşlik tabandaki karşılığı.
+
+## Tam sayı dışında doğrudan dönüşümler
+## dil olanağı olarak sunulmuş durumda;
+
+## Kompleks sayı olarak,
+"1234".to_c #=> (1234+0i)
+
+## Ondalık (Kayan-noktalı) sayı olarak,
+"1234".to_f #=> 1234.0
+
+## Rasyonel sayı olarak,
+"1234".to_r #=> (1234/1)
+
+## Metinsel -> Mantıksal
+
+## Mantıksal değerin kendisi için tersinin, tersini alırız
+!!"seçkin" #=> true
+
+## Mantıksal tersi için ise tersini,
+!"seçkin" #=> false
+
+## Metinsel -> Sembol
+"cengiz".to_sym #=> :cengiz
+
+## Metinsel -> Dizi
+"Cengiz Han".split #=> ["Cengiz", "Han"]
+
+## split metodu, seçimli argümanının varsayılan değeri
+## boşluk karakteridir.
+
+## Metinsel -> Dizi | bölümlenerek
+"Cengiz Han".split ""
+#=> ["C", "e", "n", "g", "i", "z", " ", "H", "a", "n"]
+
+
+## --
+# Sembol 
+## --
+
+## Sembol -> Metinsel
+:metin.to_s #=> "metin"
+## Başka bir dönüşüm için dilin bir teşviki yoktur.
+
+## --
+# Diziler 
+## --
+
+## Dizi -> Metinsel
+[1,2,3,4,5].to_s #=> "[1, 2, 3, 4, 5]"
+
+
+## --
+# Eşlemeler 
+## --
+
+## Eşleme -> Dizi
+{a: 1, b: 2, c: 3}.to_a
+#=> [[:a, 1], [:b, 2], [:c, 3]]
+## Her bir anahtar-değer çifti bir dizi olarak
+## değerlendirilir ve elemanları sırasıyla
+## anahtar ve değerdir.
+
+## Eşleme -> Metinsel
+{a: 1, b: 2, c: 3}.to_s
+#=> "{:a=>1, :b=>2, :c=>3}"
+## inspect metodu için bir takma addır.
+
+
+# --------------------------------
+# Tanımlamalar, ifadeler, yorumlama.
+# --------------------------------
+
+## --
+## Yorumlama
+## --
+
+## Dökümanın başından beri gördüğümüz bu tek satır yorumlama operatörü
+## (#)
+## kendinden sonra gelen her şeyin, satır boyunca yorumlama olarak
+## değerlendirilmesi gerektiğini Ruby yorumlayıcısına söyler.
+
+## Ruby, farklı yorumlama imkanları da sağlamaktadır.
+## Örneğin;
+=begin
+  Başlangıç ifadesi (=begin), sonlandırma ifadesi (=end)
+  ile arasında kalan her şeyi yorum satırı olarak ele alır.
+=end
+
+## --
+## Global değişkenler.
+## --
+
+## Ruby evrensel değişkenleri, kapsamı en geniş değişken türüdür.
+## Her yerden erişilebilir...
+
+## Basitçe dolar sembolü ( $ ) ile başlarlar.
+$evrensel_bir_değişken = 42 #=> 42
+
+## Bir çok metadoloji ve yöntem ve teknoloji, size
+## evrensel değişkenler kullanmanın projenizi karmaşıklaştıracağı
+## ve bakımını zorlaştıracağını söyler; Haklıdırlar...
+
+## --
+## Varlık değişkenleri.
+## --
+
+## At ( @ ) sembölü ile başlarlar ve isimlerinin de ifade ettiği
+## gibi, kendileri bir Sınıf'ın değeridir.
+
+class Varlık
+    def initialize()
+        @varlık_değişkeni = 101
+    end
+    
+    def göster()
+        puts "Varlık değişkeni: #@varlık_değişkeni"
+    end
+end
+
+varlık1 = Varlık.new()
+
+varlık1.göster()
+#=> Varlık değişkeni: 101
+
+## Sınıf tanımı şimdilik kafanızı karıştırmasın.
+## İlgilenmemiz gereken kısım;
+## @varlık_değişkeni = 101
+## ifadesidir. Ve nesne özelinde tanımlama yapar.
+## Kapsamı sadece o nesnedir.
+
+## ! NOT: ilklenmemiş varlık değişkenleri nil ön değeri ile
+## yaşam döngüsüne başlar.
+
+## --
+## Sınıf değişkenleri.
+## --
+
+## Sınıf değişkenleri iki at ( @@ ) sembölü ile başlarlar.
+## Tanımlar, herhangi bir metot içinde
+## kullanılmadan önce ilklenmelidirler.
+## İlklenmemiş bir Sınıf Değişkenine referansta bulunmak,
+## bir hata oluşturur.
+
+class Sınıf
+    @@sınıf_nesne_sayısı = 0
+
+    def initialize()
+        @@sınıf_nesne_sayısı += 1
+    end
+    
+    def göster()
+        puts "Sınıf sayısı: #@@sınıf_nesne_sayısı"
+    end
+end
+
+sınıf_varlığı1 = Sınıf.new()
+sınıf_varlığı2 = Sınıf.new()
+sınıf_varlığı3 = Sınıf.new()
+
+sınıf_varlığı1.göster()
+#=> Sınıf sayısı: 3
+
+
+## --
+## Yerel değişkenler.
+## --
+
+## Yerel değişkenlerin isimlendirmesi küçük harf
+## ya da alt çizgi ( _ ) ile başlar ve kapsamı tanımın
+## yapıldığı sınıf, modül, metot yada blok içinde kalır.
+
+## --
+## Sabitler.
+## --
+
+## Ruby sabitleri, büyük harf ile tanımlanırlar ve
+## kapsamları için iki senaryo mevcuttur;
+
+## - Sınıf ya da Modül içinde tanımlanırlarsa
+## Tanımın yapıldığı blok içinden erişilebilir.
+
+## - Sınıf ya da Modül dışında yapılan tanımlar ise
+## Evrensel bir kapsama sahiptir ve her yerden
+## erişilebilirler.
+
+## Örneğin:
+
+class Sabit
+   SABİT = 299_792_458
+
+   def göster
+      puts "Sabit değer: #{SABİT}"
+   end
+end
+
+# Create Objects
+sabit = Sabit.new()
+
+sabit.göster()
+#=> Sabit değer: 299792458
+
+## İfadenin tanımındaki alt çizgiler sizi yanıltmasın
+## binlik ayracı olarak kullandım ve Ruby yorumlayıcısı
+## tamamen görmezden geliyor.
+## Bknz: Veriler ve Temsiller: Sayılar.
+
+## --
+## Sözde Değişkenler.
+## --
+
+## Ruby özel bir dil.
+## Öyle ki, Bazı sözde-değişkenler ile
+## size, ihtiyacınız olabileceği erişimi sağlar.
+## Ama onlara atama yapamazsınız.
+
+## Sözde değişkenler ve kullanımları
+## ile ilgili İleri okumaya başvurunuz.
+
+
+# --------------------------------
+# Konvansiyonlar ve teşvikler.
+# --------------------------------
+
+## Konvansiyonlar:
+
+## --
+## İsimlendirme Konvansiyonları:
+## Döküman boyunca yaptığım gibi,
+## tanımlayıcılar ve erişilebilir tanımlanmış ifadeler
+## için lütfen önerildiği gibi İngilizce kullanın.
+## İsimlendirme, Bilgisayar bilimlerinde yeterince
+## ağır bir zemin ve dilin teşvik ettiği rehber
+## ve önerdiği konvansiyonları takip ederek
+## bakımı, okuması ve geliştirmesi kolay projeler
+## gerçeklemek mümkündür.
+
+## --
+## Semboller, Metotlar ve Değişkenler için
+##-Snake Case ( snake_case ) kullanılması önerilir.
+
+## --
+## Sınıflar için Camel Case (CamelCase):
+## Sınıf isimlendirmeleri için önerildiği gibi,
+## Camel Case isimlendirme notasyonuna sadık kalın.
+
+## --
+## Dosyalar ve Klasörler için Snake Case (snake_case):
+## Dosya ve klasörleri isimlendirmek için lütfen
+## Snake Case isimlendirme konvansiyonuna sadık kalın.
+
+## --
+## Dosya Başına Bir Sınıf:
+## Her dosyada bir sınıf barındırmaya özen gösterin.
+
+## ---
+## Bu kısımdaki teşvik içerikleri
+## rubocop-hq/ruby-style-guide'dan gelmektedir.
+
+## ! Rehbere göre bu dökümanı düzenle!
+
+## --
+## Girintileme:
+## Girintileme için TAB yerine, iki boşluk kullanın.
+
+def bir_metot
+    birşeyler_yap
+end
+## Yerine;
+def bir_metot
+  birşeyler_yap
+end
+
+## --
+## Satır Başına Karakter:
+## Satır başına maksimum 80 karakter olacak şekilde
+## dökümanı yapılandırın.
+
+## --
+## Satır Sonları:
+## Unix-Stili satır sonlarını kulanın.
+## Eğer Git kullanıyorsanız;
+## $ git config --global core.autocrlf true
+## ifadesi sizi bu zahmetten kurtaracaktır.
+
+## --
+## Satır Başına Bir İfade:
+## Satır başına bir ifade kullanın.
+
+puts 'test!'; puts 'test!'
+## Yerine;
+puts 'test!'
+puts 'test!'
+
+## --
+## Boşluklar ve Operatörler:
+## Operatörler, virgüller, ifade ayraçları
+## aralarında boşluk bırakın.
+
+toplam=1+2
+x,z=1,2
+class FooError<StandardError;end
+## Yerine;
+toplam = 1 + 2
+x , z = 1 , 2
+class FooError < StandardError; end
+## Bir kaç istisna hariç
+## - Üs operatörü
+## - Rasyonel sayı gösteriminde kullanılan eğik çizgi.
+## - Güvenli gösterim operatörü.
+
+
+### Daha fazlası için ileri okumadaki
+### bu rehbere danışabilirsiniz...
+
+# --------------------------------
+# Bloklar, Kontrol blokları ve örnekler.
+# --------------------------------
+
+## --
+## Ruby Blokları:
+## Süslü parantezler ya da `do`, `end` ile çevrelenen,
+## değişkenleri ortama bağlı işlevlerdir.
+## Diğer dillerde !{Closure} ( closure ) karşılığı
+## bulur.
+## Ruby'de bloklar, ifadeleri gruplamanın bir şeklidir.
+## Bloklar tanımlandıklarında çalıştırılmazlar,
+## Ruby, bu yönetimi akıllıca yapar.
+
+## Örneğin;
+
+## Tanımlamamız
+def selamla_sonra_çağır
+  puts 'Selamlar!'
+  yield ## tüm sihir burada!
+end
+
+## Şimdi tanımı çağıralım
+selamla_sonra_çağır {puts 'Çağrı, gerçekleşti!'}
+#= Selamlar!
+#= Çağrı, gerçekleşti! 
+#=> nil
+## Çağırım, kendini çağıran kaynağa nil döndürmekte.
+## Değerlendirmenin sonucunda, Ruby yorumlayıcısı,
+## ifadenin değerini nil olarak çıktılar.
+## Fakat, puts çağrıları, girdi/çıktı işlevimizi
+## yerine getirir ve metinleri ekrana basar.
+
+## Blokların argüman almaları da mümkündür:
+def selamla_sonra_değer_ile_çağır
+  puts 'Selamlar!'
+  yield('Hain Kostok') ## tüm sihir burada!
+end
+
+selamla_sonra_değer_ile_çağır {|isim| puts "Sana da selam, #{isim}!"}
+#= Selamlar!
+#= Sana da selam, Hain Kostok!
+#=> nil
+
+## Detaylı bilgi için, ileri okumaya başvurunuz.
+
+## --
+## Eğer ( if ) kontrol ifadesi:
+## Algoritmanızda dallanma imkanı sağlar.
+## Şablonu:
+## if koşul_ifadesi [then]
+##   yürütülecek_kod
+## [elsif bir_diğer_koşul [then]
+##   yürütülecek_diğer_kod]
+## [else
+##   yürütülecek_bir_diğer_kod]
+## end
+
+## Bu kalıba sadık kalarak, dallanmalarımızı kodlarız.
+## Köşeli parantezler, sezgisel olarak anlaşılacağı üzere
+## seçimli ifadelerdir.
+
+## Örnek:
+if true
+  puts 'Koşul ifadesi, buradan devam edecek!'
+else
+  puts 'Buradan değil.'
+end
+#= Koşul ifadesi, buradan devam edecek!
+#=> nil
+
+## --
+## Eğer ( if ) düzenleyicisi:
+## Kompak bir dil olanağıdır. Aynı şekilde, çalıştırılacak kod
+## ve bir koşul ifadesi alır. Ve koşul ifadesine bakarak
+## ifadenin yürütüleceğine karar verir.
+## Şablonu:
+## çalıştırılacak_kod if koşul_ifadesi
+
+## Örnek:
+
+puts 'Bu ifade yürütülecek!' if true
+#= Bu ifade yürütülecek!
+#=> nil
+
+
+## --
+## Durum ( case ) kontrol ifadesi:
+## Bir koşul ifadesi ve bir ya da daha fazla karşılaştırma ifadesi
+## alarak, eşleşen bloğu yürütür.
+## Şablonu:
+## case koşullanacak_ifade
+## [when karşılaştırma_ifadesi [, karşılaştırma_ifadeleri ...] [then]
+##   yürütülecek_kod ]...
+## [else
+##   eşleşme_olmazsa_yürütülecek_kod ]
+## end
+
+yaş = 27
+case yaş
+when 0 .. 2
+   puts "bebek"
+when 3 .. 6
+   puts "küçük çocuk"
+when 7 .. 12
+   puts "çocuk"
+when 13 .. 18
+   puts "genç"
+else
+   puts "yetişkin"
+end
+#= yetişkin
+#=> nil
+
+## --
+## .. Sürece ( while ) kontrol ifadesi:
+## Aldığı koşul ifadesini kontrol eder,
+## kontrol bloğunu çağırır ve tekrar kontrol eder.
+## Koşul ifadesi doğru olduğu sürece, kontrol bloğu
+## çağırılmaya devam eder.
+## Şablonu:
+## while koşul_ifadesi [do]
+##   yürütülecek_kod
+## end
+
+## Örnek:
+
+$n = 0
+$sayı = 5
+
+while $n < $sayı  do
+   puts("Döngü içinde n = #$n" )
+   $n +=1
+end
+#= Döngü içinde n = 0
+#= Döngü içinde n = 1
+#= Döngü içinde n = 2
+#= Döngü içinde n = 3
+#= Döngü içinde n = 4
+#=> nil
+
+## --
+## .. Sürece ( while ) düzenleyicisi:
+## Eğer düzenleyecisi gibi, kompak bir dil olanağıdur.
+## Kontrol ifadesinin işlevini yerine getirir,
+## ama satır içi kullanıma müsade ederek.
+## Şablonu:
+## çalıştırılacak_kod while koşul_ifadesi
+## Yada:
+## begin
+##   çalıştırılacak_kod
+## end while koşul_ifadesi
+
+## --
+## İçin ( for ) kontrol ifadesi:
+## N kere, I kere, X kere gibi ifadelerin dildeki kontrol
+## karşılığıdır. Çoklu veri üzerinde iterasyonlar yapmanızı
+## veri üzerinde operasyonlar yürütmenizi sağlar.
+## Şablonu:
+## for değişken [, başka_değişken ...] in ifade [do]
+##   yürütülecek_kod
+## end
+
+## Örnek:
+for i in 1..5
+  puts i
+end
+#= 0
+#= 1
+#= 2
+#= 3
+#= 4
+#= 5
+#=> 0..5
+
+## Ardışıkları itere etmek için tek yol bu değil tabii.
+## İlerleyen kısımda buna yer verilecektir.
+
+## --
+## Sonlandırıcı ( break ) kontrol ifadesi:
+## Bu kontrol ifadesi yürütüldüğünde, çalışma zamanını 
+## en iç tekrarlı bloktan çıkarır.
+
+## Örnek:
+for i in 1..5
+  break if i > 2
+  puts i
+end
+#= 0
+#= 1
+#= 2
+#=> nil
+## break kontrol ifadesi, if düzenleyecisi ile çevrelenmiştir.
+## if i > 2
+##   break
+## end
+## ifadesi ile eşdeğerdir.
+## ifade yürütüldüğü anda, en yakın tekrarlı blok terkedilir.
+## Yorumlayıcı, sonraki ifadeden yürütmeye devam eder.
+
+## Diğer kontrol ifadeleri ve kullanımları için ileri okumaya başvurunuz...
+
+
+# --------------------------------
+# Özel anahtar kelimeler; kullanımları ve örnekleri.
+# --------------------------------
+
+## --
+## __ENCODING__: 
+## Bu anahtar kelime size yorumlayıcı kodlama türünü verecektir.
+
+__ENCODING__
+#=> "#<Encoding:UTF-8>"
+
+## Platform, araç ve çalışma zamanı yürütme
+## yönteminize bağlı olarak alacağınız çıktı
+## değişiklik gösterebilir.
+
+## --
+## __LINE__:
+## Geçerli dosyada, yürütme satır numarasını verir.
+
+__LINE__
+#=> 67
+
+## Platform, araç ve çalışma zamanı yürütme
+## yönteminize bağlı olarak alacağınız çıktı
+## değişiklik gösterebilir.
+
+## --
+## BEGIN ve END:
+## BEGIN:
+## Dosyadaki tüm içerikten önce yürütülür.
+## END:
+## Dosyadaki tüm içeriklerden sonra yürütülür.
+
+## --
+## alias:
+## Herhangi bir tanımlayıcı için takma ad tanımlamanıza
+## olanak sağlar.
+
+$eski = 0
+alias $yeni $eski
+
+$yeni
+#=> 0
+
+## --
+## and:
+## Düşük öncelikli bir Mantıksal VE operatörü.
+
+## --
+## begin / end ve rescue:
+## İstisnalar begin / end blokları
+## arasında ele alınır ve `rescue` anahtar kelimesi ile
+## işlenirler.
+## İstisnalar ve mantalitesine dair ön girişi
+## Teşvik edilen paradigma ve anlatımı kısmında bulabilirsiniz.
+
+## Hata yönetimi, Ruby'de de özenle işlenmiş bir konudur.
+
+## Örnek:
+
+begin
+  yanlış_bir_hesaplama = 2/0
+  puts "Hesaplama sonucu: #{yanlış_bir_hesaplama}"
+  rescue ZeroDivisionError => hata_nesnesi
+    puts "Sıfıra bölümle ilgili bir hata yakalandı: #{hata_nesnesi.message}"
+end
+#= Sıfıra bölümle ilgili bir hata yakalandı: divided by 0
+#=> nil
+
+## Örneğimizde matematiksel sistemimiz için hatalı bir
+## işlem gerçekleştiriyoruz. Sonrasında hatayı ilgili
+## hata durumu için belirlediğimi alanda yönetiyoruz.
+## Örnekte hatayı çıktılayarak yönettik, gerçek dünyada
+## biraz daha kompleks gerçekleşebilir.
+## Gerçek dünya örnekleri için ileri okumaya başvurabilirsiniz.
+
+
+## --
+## defined?:
+## defined?, argümanını metinsel olarak açıklayan bir dil olanağıdır.
+
+## Örnek:
+RUBY_VERSION
+#=> "2.4.0"
+
+defined? RUBY_VERSION
+#=> "constant"
+
+defined? nil
+#=> "nil"
+
+defined? puts
+#=> "method"
+
+
+## --
+## ensure:
+## Hata yönetiminin bir parçası olarak dilde görev atfedilen ensure,
+## blok içinde, hata olsun ya da olmasın yürütüleceği garanti edilen
+## dil ifadeleri için bir imkandır.
+
+## Örnek:
+
+begin
+  yanlış_bir_hesaplama = 2/0
+  puts "Hesaplama sonucu: #{yanlış_bir_hesaplama}"
+  rescue ZeroDivisionError => hata_nesnesi
+    puts "Sıfıra bölümle ilgili bir hata yakalandı: #{hata_nesnesi.message}"
+  ensure
+    puts "Hesaplama bloğu sonlandı!"
+end
+#= Sıfıra bölümle ilgili bir hata yakalandı: divided by 0
+#= Hesaplama bloğu sonlandı!
+#=> nil
+
+
+## --
+## self:
+## Nesnenin kendisine erişim sağlayan bir dil olanağı.
+
+## Örnek:
+
+dünya = "Dünya!"
+#=> "Dünya!"
+
+dünya
+#=> "Dünya!"
+
+dünya.class
+#=> String
+
+def dünya.selamla
+  "Merhaba, " + self
+end
+#=> :selamla
+
+dünya.selamla
+#=> "Merhaba, Dünya!"
+
+## Nesnenin kendisine bir metot tanımladık,
+## bunu yaparken de değerine erişim sağladık.
+
+## --
+## super:
+## Nesne yönelimli programlama (spesifik olarak, obje tabanlı)
+## paradigmasına göre, kalıtım konseptinde, türeyen sınıfın
+## türetildiği sınıfa erişimi (üst sınıfı, atası, hiyerarşik üstü)
+## bu anahtar kelime ile gerçekleşir.
+
+class A
+  def initialize(a)
+    @a = a
+  end
+end
+
+class B < A
+  def initialize(a, b)
+    @b = b
+    super a
+  end
+end
+
+b = B.new 1, 2
+#=> #<B:0x00007f852d04c7e8 @b=2, @a=1>
+## super ile üst sınıfın ilklenmesi gerçekleştirildi,
+## aldığımız çıktıda da @a=1 çıktısıyla gözlemlenebilir.
+
+## Bu konunun, dilin paradigma teşviği ile ilgili
+## olduğunu ve anlamazsanız, Paradigma başlığını bitirdikten
+## sonra tekrar bu örneği değerlendirmeniz gerektiğini hatırlatırım.
+
+## --
+## yield:
+## Ruby blokları kısmında anlattık, ama, burada da bir nüanstan
+## bahsetmeden geçemeyeceğim.
+## Çalıştırılabilir ifadeleri çalıştırmanın birden fazla yolu vardır.
+## Fakat yield, en performanslı dil olanağı olarak dökümanda işlenmiş.
+## Kaynak için ileri okumaya danışın.
+
+
+
+# --------------------------------
+# G/Ç ( I/O )
+# --------------------------------
+
+=begin
+  G/Ç, Girdi/Çıktı ( Input/Output ) kısaltmasıdır.
+  Temelde, sistemden girdi almak ve çıktı yaratmak amacıyla vardır.
+  Girdi örnekleri:
+    - Klavyeden bastığınız herhangi bir tuş.
+    - Fare hareketleriniz ya da tıklamalarınız.
+    - Mikrofonunuzun aldığı sesler.
+  
+  Çıktı örnekleri:
+    - Herhangi bir dil ifadesinin sonucu.
+    - Dijital bir ses dosyasının sese dönüşmesi.
+    - Ekranda gördükleriniz.
+  
+  Fakat endişelenmeyin, G/Ç derken, şu anda 
+  biz sadece Ruby'de,
+    - Dosya okuma/yazma.
+    - Ekrana metin yazdırma / Bilgi okuma.
+    - Ağ soketleri. ( biraz da olsa )
+  işlerinden bahsediyor olacağız.
+=end
+
+defined? IO
+#=> "constant"
+
+IO.class
+#=> Class
+
+## IO sınıfı, File ve Socket gibi pratik kullanımı olan sınıfların atasıdır.
+## Septikler için;
+
+File.superclass
+#=> IO
+## Gözlemlediğiniz üzere, superclass metodu, üst sınıfı veriyor.
+
+## --
+## Dosya Okuma ve Yazma:
+## Ruby'de dosya okuma ve yazma işlemleri için, File
+## sınıfını kullanacağız.
+
+## Dosyaya yazmak için;
+File.write 'test.txt', "a,b,c"
+#=> 5
+## 5, ifadenin ürettiği dönüş değeridir.
+## ve, çıktılanan karakter sayısını verir.
+
+## Dosyadan okuma için;
+## Bu kısım, açıklayıcı olması açısından
+## ifadeleri teker teker işleyeceğiz.
+
+File
+#=> File
+## Sınıfımız.
+
+File.readlines 'test.txt'
+#=> ["a,b,c"]
+## readlines File sınıfının bir metodu ve aldığı argüman dosya yoludur.
+
+File.readlines('test.txt').first
+#=> "a,b,c"
+## Dönüş değeri bir diziydi, her bir satır bir eleman olacak şekilde.
+## Biz, kendi verilerimizi, kendi ayıracımızla kaydetmeyi seçtik.
+## Eğer, `\n` satır ifadesi ile ayırmayı seçseydik, readlines
+## metodu zaten işlevi gereği, bize değerleri ayrı ayrı verecekti.
+
+File.readlines('test.txt').first.split ','
+#=> ["a", "b", "c"]
+## verilerimizi aldık.
+
+## Eğer yeni satır karakterini ayıraç olarak kullansaydık;
+File.write 'ntest.txt', ['a', 'b', 'c'].join("\n")
+#=> 5
+
+File.readlines('ntest.txt').map(&:chomp)
+#=> ["a", "b", "c"]
+## Bu da genel kullanımlı bir yaklaşımdır.
+
+## --
+## Ekrana bilgi yazdırma ve Okuma:
+## Konsol'a bilgi çıktılamak için,
+## önceden tanımlanmış $stdout global nesnesini kullanacağız.
+## Pratik kullanımda, prints işlevinden bir farkı yoktur.
+## Aynı sonuca ikisi ile de ulaşabilirsiniz.
+
+$stdout.print "Bu bir çıktı.\n"
+#= Bu bir çıktı.
+#=> nil
+
+## Şimdi kullanıcıdan bilgi okuyalım:
+$stdin.gets
+#! Bu kısımda hiç bir çıktı verilmez ve aksine
+#! sizden girdi beklenir. Bir metin yazın ve onaylamak için
+#! enter tuşunu kullanın.
+#- Bu bir girdi metni!
+#=> "Bu bir girdi metni!\n"
+
+## Aldığımız veriyi temizlenin yolunu biliyoruz.
+## Dönüş değerine chomp metodunu uygulamak.
+$stdin.gets.chomp
+#- Bu bir girdi metni!
+#=> "Bu bir girdi metni!"
+
+
+## --
+## Ağ girdi/çıktı yönetimi
+## Ruby'de soketler (Socket)
+## haricen çalışma zamanına dahil edilir.
+
+require 'socket'
+#=> true
+
+soket = TCPSocket.new('google.com', 80)
+#=> #<TCPSocket:fd 13, AF_INET, 192.168.0.11, 63989>
+## Alacağınız çıktı değişiklik gösterebilir.
+## Soketi oluşturduk ve bir değişkene atadık.
+## Şimdi bunun üzerinden okuma ve yazma işlemlerini
+## gerçekleştireceğiz.
+
+soket.write "GET / HTTP/1.1"
+#=> 14
+
+soket.write "\r\n\r\n"
+#=> 4
+## İki write metodunun sonucu da, sokete yazılan verinin
+## uzunluğudur.
+
+## Şimdi okuma zamanı, soketi açtık, isteğimizi bildirdik.
+## Şimdi soket üzerinden aldığımız cevabı ekrana yazdıralım.
+
+soket.recv 80
+#=> "HTTP/1.1 200 OK\r\nDate: Thu, 03 Sep 2020 10:48:21 GMT\r\nExpires: -1\r\nCache-Control"
+## Alacağınız çıktı değişiklik gösterebilir.
+## Ancak, başarılı şekilde okuma yaptık.
+
+
+
+# --------------------------------
+# Teşviğinde bulunduğu paradigma ve derinlemesine anlatımı.
+# --------------------------------
+
+## --
+## Nesne Yönelimli Programlama Nedir?
+## Kısaca NYP, en basit anlatımıyla;
+## nesnelerle programlamadır.
+## Nesne paradigması, her programcıya doğal ve sezgisel gelir.
+## Bunun sebebi, zaten gerçekliği algılama şeklimize uygun olmasıdır.
+## Araba, onu bir araya getiren nesnelerden oluşur,
+## tekerlekleri, direksiyonu, kasası, ve diğer parçalarıyla.
+## Ama bu, tam tanım değildir. NYP'de, Nesneler,
+## Bilgilere ( evet, varlık olarak başka nesneler de sayılabilir )
+## ve bu bilgileri yönetecek ( hesaplamalar gerçekleştirecek 
+## ya da aksiyonlar alacak -- G/Ç -- gibi ) metotlara sahiptir.
+
+## Bir nesnenin en net tanımı böyle yapılabilirken,
+## NYP, bir gerçek dünya problemi için bir araya getirilmiş
+## -- çoğunlukla birden fazla -- sınıfların yapıları,
+## ilişkileri ve işlevlerini ele alır.
+
+## Bir paradigma olarak NYP, bizlere her varlığı nesne olarak
+## modellemeyi ve problem uzayımızdaki nesnelerle olan ilişkilerini
+## Ruby'de NYP için sağlanan imkanlarla yönetmeyi öğütler.
+
+## Sınıf içerisinde saklanan bilgiye öznitelik ya da özellik,
+## işlevlere ise metot denilir.
+## NYP jargonu için ileri okumaya başvurabilirsiniz.
+
+## --
+## Ruby'de NYP teşviki:
+
+## Nesneler, Sınıfların gerçeklenmiş halleridir.
+## Tam tersi ile, Sınıflar ise, nesnelerin soyut kalıplarıdır.
+
+## Bir sınıf tanımı yapalım ve gerçekleyelim:
+
+class Araba
+end
+#=> nil
+## Evet, evet. Tanımımız hiç bir öznitelik ( attributes ) ya da
+## metot ( method ) içermiyor.
+
+## Şimdi bir özellik ekleyelim
+class Araba
+  def initialize(hız)
+    @hız = hız
+  end
+end
+
+araba = Araba.new 100
+#=> #<Araba:0x00007f7f300e59c8 @hız=100>
+
+## En naif haliyle, hız bilgisi saklayan bir araba sınıfı gerçekledik.
+## initialize metodu, Ruby imkanları ile, nesne yaşam döngünüzün ilk adımıdır.
+## Bu döngüyü aşağıdaki gibi betimlemek mümkündür.
+## İlkleme ( initialize ) -> [İşlevlerin çağırımı] -> Sonlandırma
+## İlkleme, initialize metodu ile ele alınır, alınacak tüm argümanlar,
+## sınıfın iş mantığı doğrultusuyla, bu ilk işlevde yönetilir ve nesne
+## kullanıma hazır hale getirilir.
+
+## Şimdi bir işlev ekleyelim.
+
+class Araba
+  def initialize(hız)
+    @hız = hız
+  end
+  
+  def git!
+    puts 'Hınn, hınn!'
+  end
+end
+
+araba = Araba.new 100
+#=> #<Araba:0x00007f7f300e59c8 @hız=100>
+
+## Şimdi metodu çağırıyoruz.
+araba.git!
+#= Hınn, hınn!
+#=> nil
+
+## Başlığın amacı sadece Ruby'nin NYP olanaklarını ve
+## teşviğini işlemek değil. Paradigmaya bir giriş kazandırmak.
+## Bundan dolayı, etkileşim içinde birden fazla sınıf görmeliyiz.
+
+class Tekerlek
+  YERLİ = 5
+  İTHAL = 1
+
+  def initialize (tür)
+    @güç = tür
+  end
+
+  def döndür!
+    @güç -= 1
+  end
+end
+
+class Araba
+  def initialize (hız)
+    @hız = hız
+    @tekerlekler = (1..4).map {|| Tekerlek.new(Tekerlek::YERLİ)}
+  end
+
+  def git!
+    if @tekerlekler.map(&:döndür!).filter {|ömür| ömür < 0}.first then
+      puts 'Paat!'
+    else
+      puts 'Hınnn, hınnn!'
+    end
+  end
+end
+
+## nesnemizi oluşturuyoruz
+araba = Araba.new 100
+
+## altı sefer, araba nesnesinin git! metodunu çağırıyoruz.
+(0..6).map {|| araba.git! }
+#= Hınnn, hınnn!
+#= Hınnn, hınnn!
+#= Hınnn, hınnn!
+#= Hınnn, hınnn!
+#= Hınnn, hınnn!
+#= Paat!
+#= Paat!
+
+## İş mantığımıza göre, arabamızın dört tekeri ve ve Yerli olanlar
+## 5 birim dayanıklılığa sahip. ;)
+## Bu beş birim tükenince, araba gitmek yerine,
+## patlak teker çıktısı alıyoruz.
+
+
+## Şimdiye kadar gördüklerimizi bir analiz edelim;
+## Araba, sınıfın ismi. Her sınıf, tanımlamasak da, temel bir
+## kurucu metot içerecek şekilde dil işleyicisi tarafından
+## ele alınıyor.
+## Bizim bir tanımımız var ama.
+## Hız bilgisi alıyoruz.
+## bu bilgi, sınıf özniteliğidir. Sınıf, bu bilgiye kendi içinden erişebilir.
+## Bir de, binek araçların dört tekerleği olduğu fikriyle,
+## nesne içinde, kurucu metot içinde dört tane Tekerlek nesnesi gerçekliyor
+## ve saklıyoruz.
+## İş mantığımıza göre onlara erişmemiz gerekiyor.
+## git! metodu içinde, erişiyor ve kullanıyoruz.
+## metotların sonundaki ünlem işareti bir konvansiyondur,
+## metotların saf olmayan çağırımlar gerçeklediği anlamına gelmektedir.
+## Kendilerini ( ya da sahip olduğu diğer nesneleri ) değiştirdikleri,
+## bir girdi/çıktı gerçekleştirdikleri yada buna benzer yan etki içeren
+## bir ifade barındırdıkları anlamına gelir.
+
+## Sizi temin ederim ki, NYP, bu dökümanı ( hali hazırda ~1560 satır )
+## genel anlatımı için bile ikiye katlayabilir.
+## Lütfen detaylı bilgi için ileri okumaya başvurunuz.
+```
+
+# İleri okumalar.
+
+Tümüyle İngilizce olan bu ileri okumalara inat, bu detaylı özgün Türkçe içeriği üretmek istedim.
+Dilerim, benden sonra katkıda bulunanlar olur.
+
+- [Ruby Style Guide](https://rubystyle.guide), Ruby stil rehberi.
+- [Ruby-Doc üzerinde Proc](https://ruby-doc.org/core-2.4.0/Proc.html), Ruby Blokları ve Proc kavramı için.
+- [Ruby-Doc üzerinde String](https://ruby-doc.org/core-2.6/String.html) sınıfı, işlevleri, metotları.
+- [Ruby-Doc üzerinde TrueClass](https://ruby-doc.org/core-2.5.1/TrueClass.html#method-i-to_s) Dildeki mantıksal ifadelerin gerçeklemesi olan TrueClass (ve FalseClass için de aynı bağlantı üzerinden içeriğe ulaşılabilir) dönüşüm içeriği kaynağı.
+- [Ruby Gerçeklemeleri Listesi](https://github.com/codicoscepticos/ruby-implementations) Ruby'nin farklı platformlardaki gerçeklemeleri. Opal ve Topaz dikkat çekenleridir.
+- [The Object-Oriented Thought Process](https://www.amazon.com/Object-Oriented-Thought-Process-Developers-Library/dp/0321861272) kitap, bir paradigma olarak NYP ve düşünce yapısından bahsediyor. Bir paradigma olarak, NYP, türetildiği temel paradigmadan ne almış, başka paradigmalara ne kadar imkan sağlıyor ve paralel paradigma uyumu konusunda tüm sorularınıza cevap bulabilirsiniz. Yazar, belli etmese de, pragmatik bir yaklaşımda.
+- [Block Argument](https://docs.ruby-lang.org/en/2.4.0/syntax/methods_rdoc.html#label-Block+Argument) Ruby Blokları ve yield hakkındaki Ruby resmi döküman sayfası ve alt başlığı.
+- [A Theory of Objects]() Class-Based Languages başlığında inceleniyorlar.
diff --git a/tr-tr/sql-tr.html.markdown b/tr-tr/sql-tr.html.markdown
new file mode 100644
index 00000000..54007d32
--- /dev/null
+++ b/tr-tr/sql-tr.html.markdown
@@ -0,0 +1,125 @@
+---

+language: SQL

+contributors:

+  - ["Metin Yalçınkaya", "https://github.com/mtnylnky"]

+lang: tr-tr

+filename: learnsql-tr.sql

+---

+

+

+```sql

+-- Yorumlar iki tire ile başlar

+

+-- KISITLAR

+Not null -- Bir kolon asla boş olamaz

+default -- Boş olan yerlere varsayılan bir değer atar

+unique -- Bir kolondaki tüm değerlerin farklı olması kısıtlaması

+primary key -- Bir tablodaki her veri için kimlik bilgisi niteliğindedir

+check -- Bir kolondaki değerlerin belli bir kısıtlamayı sağlamasını sağlar

+

+-- Tablo oluşturulur

+CREATE TABLE tablo1 ();

+

+-- Tabloyu içerisinde kolonlar ile oluşturma

+CREATE TABLE tablo1(id INTEGER PRIMARY KEY NOT NULL UNIQUE, ad TEXT, soyad TEXT, yas INTEGER);

+

+-- TABLO varlığını kontrol eder

+.table

+

+-- Veri tabanında olan bütün tabloları görüntüler.

+.schema

+

+-- Satır ekle

+INSERT INTO tablo1 ( ad, soyad) VALUES ("Deger1","Deger2");

+

+-- Veritabanında tablo üzerindeki verileri görüntüle 

+-- Sadece 'ad' gibi sınırlı bir veri için

+SELECT ad FROM tablo1;

+-- Bütün veriler için

+SELECT * FROM tablo1;

+

+-- Veri güncelleme

+UPDATE tablo1 SET ad = "deger1-2"; WHERE name = "Deger1";

+

+-- Satır sil

+DELETE FROM tablo1 WHERE id = 1;

+DELETE FROM tablo1 WHERE ad = "Deger1" OR ad = "Deger2";

+

+-- Tabloya sonradan kolon ekleme

+ALTER TABLE tablo1 ADD COLUMN email TEXT;

+

+-- Tablodaki kolon adı değiştirme

+EXEC sp_rename ' tablo1.[ad]', Ad, 'COLUMN';

+

+-- Tablo adı değiştirme

+ALTER TABLE table1 RENAME TO Table1;

+

+-- Tabloyu silme

+DROP TABLE Table1;

+

+-- BİR TABLOYU BAŞKA TABLO KULLANARAK DOLDURMAK

+INSERT INTO Tablo2 SELECT id,ad, soyad, email from Tablo1;

+

+-- LIKE KOMUTU

+-- Belirli bir kritere göre arama yaparken kullanılır

+-- Adı 'A' ile başlayan veriler

+SELECT * FROM tablo1 WHERE adi LIKE "A%";

+-- İçinde 'A' olan veriler

+SELECT * FROM tablo1 WHERE adi LIKE "%A%";

+

+-- LIMIT KOMUTU

+-- Gösterilen satır sayısını sınırlamak için

+SELECT * FROM Tablo1 LIMIT 6;

+-- Gösterilen satırları belirli bir noktadan başlamak üzere sınırlamak için

+SELECT * FROM Tablo1 LIMIT 6 OFFSET 3;

+

+-- ORDER BY KOMUTU

+-- Herhangi bir kolona göre gösterilen değerleri azalan veya artan şekilde sıralamak için

+SELECT kolon FROM tablo1 WHERE yas ORDER BY column1, column2, .. columnN] [ASC | DESC];

+SELECT * FROM Tablo1 ORDER BY yas ASC

+SELECT * FROM Tablo1 ORDER BY yas DESC

+

+-- DISTINCT ANAHTAR SÖZCÜĞÜ

+-- Bu anahtar sözcükle sadece farklı değerler gösterilir.

+SELECT DISTINCT yas FROM tablo1;

+

+-- JOIN KOMUTU

+-- CROSS JOIN

+-- Cross join bir tablodaki her satırı ikinci tablodaki bir satır ile eşleştirmek için kulanılır.

+-- Eğer birinci tabloda x satır ikinci tabloda y satır varsa sonuçta x*y satır olur.

+SELECT ... FROM table1 CROSS JOIN table2 …

+SELECT ad, yas FROM Tablo1 CROSS JOIN Tablo2;

+

+-- INNER JOIN

+-- Inner join iki tablodaki ortak kolon değerlerini kullanarak bir sonuç üretir.

+SELECT ... FROM table1 [INNER] JOIN table2 ON conditional_expression …

+SELECT ad, yas FROM Tablo1 INNER JOIN Tablo2 ON Tablo1.ad = Tablo2.soyad;

+

+-- OUTER JOIN

+-- Outer join iki tablodaki ortak kolon değerlerinin dışında kalanları kullanarak bir sonuç üretir.

+SELECT isci_num, isim, dept FROM Tablo1 LEFT OUTER JOIN Tablo2 ON Tablo1.id = Tablo2.isci_num;

+

+-- ÇEKİRDEK FONKSİYONLAR

+COUNT -- Sayma

+AVG -- Ortalama

+ABS -- Mutlak değer

+SUM -- Toplam

+RANDOM -- Rastgele

+ROUND -- Yuvarlama

+MAX -- Maksimim

+MIN -- Minimum

+UPPER -- Büyük Harf

+LOWER -- Küçük Harf

+LENGTH -- Uzunluk

+CURRENT_TIMESTAMP -- Zaman

+

+SELECT max(yas) FROM Table1;

+SELECT min(yas) FROM Table1;

+SELECT avg(yas) FROM Table1;

+SELECT * From Table1 WHERE yas ==18;

+SELECT sum(yas) FROM Table1;

+SELECT random() AS Random;

+SELECT upper(ad) FROM Table1;

+SELECT lower(ad) FROM Table1;

+SELECT ad, length(ad) FROM Table1;

+```
\ No newline at end of file
diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index 15056bb8..4c2cf59b 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -2,7 +2,7 @@
 language: swift
 contributors:
   - ["Özgür Şahin", "https://github.com/ozgurshn/"]
-filename: learnswift.swift
+filename: learnswift-tr.swift
 lang: tr-tr
 ---
 
@@ -443,47 +443,47 @@ if let daire = benimBosDairem {
 // Sınıflar gibi metotlar içerebilirler.
 
 enum Kart {
-    case Kupa, Maca, Sinek, Karo
+    case kupa, maca, sinek, karo
     func getIcon() -> String {
         switch self {
-        case .Maca: return "♤"
-        case .Kupa: return "♡"
-        case .Karo: return "♢"
-        case .Sinek: return "♧"
+        case .maca: return "♤"
+        case .kupa: return "♡"
+        case .karo: return "♢"
+        case .sinek: return "♧"
         }
     }
 }
 
 // Enum değerleri kısayol syntaxa izin verir. Eğer değişken tipi açık olarak belirtildiyse enum tipini yazmaya gerek kalmaz.
-var kartTipi: Kart = .Kupa
+var kartTipi: Kart = .kupa
 
 // Integer olmayan enumlar direk değer (rawValue) atama gerektirir.
 enum KitapAdi: String {
-    case John = "John"
-    case Luke = "Luke"
+    case john = "John"
+    case luke = "Luke"
 }
-print("Name: \(KitapAdi.John.rawValue)")
+print("Name: \(KitapAdi.john.rawValue)")
 
 // Değerlerle ilişkilendirilmiş Enum
 enum Mobilya {
     // Int ile ilişkilendirilmiş
-    case Masa(yukseklik: Int)
+    case masa(yukseklik: Int)
     // String ve Int ile ilişkilendirilmiş
-    case Sandalye(String, Int)
-    
+    case sandalye(String, Int)
+
     func aciklama() -> String {
         switch self {
-        case .Masa(let yukseklik):
+        case .masa(let yukseklik):
             return "Masa boyu \(yukseklik) cm"
-        case .Sandalye(let marka, let yukseklik):
+        case .sandalye(let marka, let yukseklik):
             return "\(brand) marka sandalyenin boyu \(yukseklik) cm"
         }
     }
 }
 
-var masa: Mobilya = .Masa(yukseklik: 80)
+var masa: Mobilya = .masa(yukseklik: 80)
 print(masa.aciklama())     // "Masa boyu 80 cm"
-var sandalye = Mobilya.Sandalye("Foo", 40)
+var sandalye = Mobilya.sandalye("Foo", 40)
 print(sandalye.aciklama())    // "Foo marka sandalyenin boyu 40 cm"