Merge pull request #1 from adambard/master

Merging from master.

10 files changed, 2627 insertions, 19 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/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/dynamic-programming-tr.html.markdown b/tr-tr/dynamic-programming-tr.html.markdown
index 606ecf04..e6a734a7 100644
--- a/tr-tr/dynamic-programming-tr.html.markdown
+++ b/tr-tr/dynamic-programming-tr.html.markdown
@@ -8,24 +8,28 @@ translators:
 lang: tr-tr
 ---
 
-Dinamik Programlama
-Giriş
+# 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ı
+## Bu tür sorunların çözüm yolları
 
-1-Yukarıdan aşağıya:
+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:
+2. Aşağıdan yukarıya:
 Sorunu analiz edin ve alt problemlerin çözülme sırasını görün ve önemsiz alt sorundan verilen soruna doğru başlayın. Bu süreçte, problemi çözmeden önce alt problemlerin çözülmesi gerekmektedir. Buna Dinamik Programlama denir.
 
-Örnek
-En Uzun Artan Subsequence problemi belirli bir dizinin en uzun artan alt dizini bulmaktır. S = {a1, a2, a3, a4, ............., an-1} dizisi göz önüne alındığında, en uzun bir alt kümeyi bulmak zorundayız, böylece tüm j ve i, j için <I, aj <ai alt kümesinde. Her şeyden önce, en son alt dizgenin (LSi) değerini dizinin son elemanı olan ai'nin her indeksinde bulmalıyız. Daha sonra en büyük LSi, verilen dizideki en uzun alt dizin olacaktır. Başlamak için, ai, dizinin elemanı olduğundan (Son öğe) LSi atanır. Sonra tüm j için j <i ve aj <ai gibi, En Büyük LSj'yi buluruz ve LSi'ye ekleriz. Sonra algoritma O (n2) zaman alır.
+## Ö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.
+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.
 
@@ -40,10 +44,12 @@ for i=0 to n-1
     
 ```  
 
-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
+### 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
 
-Online Kaynaklar
-https://www.codechef.com/wiki/tutorial-dynamic-programming
+- [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/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..99a3eb4e 100644
--- a/tr-tr/python-tr.html.markdown
+++ b/tr-tr/python-tr.html.markdown
@@ -458,7 +458,7 @@ Human.grunt() #=> "*grunt*"
 
 # Modülleri sayfaya dahil edebilirsiniz
 import math
-print math.sqrt(16) #=> 4
+print math.sqrt(16) #=> 4.0
 
 # Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
 from math import ceil, floor
diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index e53d5568..b78d517f 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Louie Dinh", "http://pythonpracticeprojects.com"]
     - ["Steven Basart", "http://github.com/xksteven"]
     - ["Andre Polykanine", "https://github.com/Oire"]
-    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Batuhan Osman T.", "https://github.com/BTaskaya"]
 translators:
     - ["Eray AYDIN", "http://erayaydin.me/"]
 lang: tr-tr
@@ -484,7 +484,7 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
 
 
 # Sınıf oluşturmak için objeden alt sınıf oluşturacağız.
-class Insan(obje):
+class Insan(object):
 
     # Sınıf değeri. Sınıfın tüm nesneleri tarafından kullanılabilir
     tur = "H. sapiens"
@@ -499,7 +499,7 @@ class Insan(obje):
 
     # 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)
+        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
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